Merge ../linux-2.6

185 files changed, 11497 insertions, 3203 deletions

diff --git a/drivers/Kconfig b/drivers/Kconfig
index bddf431bbb72..9f5c0da57c90 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -70,4 +70,6 @@ source "drivers/sn/Kconfig"
 
 source "drivers/edac/Kconfig"
 
+source "drivers/rtc/Kconfig"
+
 endmenu
diff --git a/drivers/Makefile b/drivers/Makefile
index 5c69b86db624..424955274e60 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -56,6 +56,7 @@ obj-$(CONFIG_USB_GADGET)	+= usb/gadget/
 obj-$(CONFIG_GAMEPORT)          += input/gameport/
 obj-$(CONFIG_INPUT)             += input/
 obj-$(CONFIG_I2O)               += message/
+obj-$(CONFIG_RTC_LIB)           += rtc/
 obj-$(CONFIG_I2C)               += i2c/
 obj-$(CONFIG_W1)                += w1/
 obj-$(CONFIG_HWMON)             += hwmon/
diff --git a/drivers/atm/lanai.c b/drivers/atm/lanai.c
index 69f4c7ce9a63..cac09e353be8 100644
--- a/drivers/atm/lanai.c
+++ b/drivers/atm/lanai.c
@@ -1972,7 +1972,7 @@ static int __devinit lanai_pci_start(struct lanai_dev *lanai)
                     "(itf %d): No suitable DMA available.\n", lanai->number);
                 return -EBUSY;
         }
-        if (pci_set_consistent_dma_mask(pci, 0xFFFFFFFF) != 0) {
+        if (pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) != 0) {
                 printk(KERN_WARNING DEV_LABEL
                     "(itf %d): No suitable DMA available.\n", lanai->number);
                 return -EBUSY;
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 105a0d61eb1f..dd547af4681a 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -47,16 +47,16 @@ static struct kset_uevent_ops memory_uevent_ops = {
         .uevent         = memory_uevent,
 };
 
-static struct notifier_block *memory_chain;
+static BLOCKING_NOTIFIER_HEAD(memory_chain);
 
 int register_memory_notifier(struct notifier_block *nb)
 {
-        return notifier_chain_register(&memory_chain, nb);
+        return blocking_notifier_chain_register(&memory_chain, nb);
 }
 
 void unregister_memory_notifier(struct notifier_block *nb)
 {
-        notifier_chain_unregister(&memory_chain, nb);
+        blocking_notifier_chain_unregister(&memory_chain, nb);
 }
 
 /*
@@ -140,7 +140,7 @@ static ssize_t show_mem_state(struct sys_device *dev, char *buf)
 
 static inline int memory_notify(unsigned long val, void *v)
 {
-        return notifier_call_chain(&memory_chain, val, v);
+        return blocking_notifier_call_chain(&memory_chain, val, v);
 }
 
 /*
diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 9bdea2a5cf0e..45bcda544880 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -41,6 +41,7 @@
 #include <linux/timer.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/jiffies.h>
 #include <linux/random.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -311,11 +312,10 @@ static boolean DAC960_CreateAuxiliaryStructures(DAC960_Controller_T *Controller)
                 CommandsRemaining = CommandAllocationGroupSize;
           CommandGroupByteCount =
                 CommandsRemaining * CommandAllocationLength;
-          AllocationPointer = kmalloc(CommandGroupByteCount, GFP_ATOMIC);
+          AllocationPointer = kzalloc(CommandGroupByteCount, GFP_ATOMIC);
           if (AllocationPointer == NULL)
                 return DAC960_Failure(Controller,
                                         "AUXILIARY STRUCTURE CREATION");
-          memset(AllocationPointer, 0, CommandGroupByteCount);
          }
       Command = (DAC960_Command_T *) AllocationPointer;
       AllocationPointer += CommandAllocationLength;
@@ -2709,14 +2709,12 @@ DAC960_DetectController(struct pci_dev *PCI_Device,
   void __iomem *BaseAddress;
   int i;
 
-  Controller = (DAC960_Controller_T *)
-        kmalloc(sizeof(DAC960_Controller_T), GFP_ATOMIC);
+  Controller = kzalloc(sizeof(DAC960_Controller_T), GFP_ATOMIC);
   if (Controller == NULL) {
         DAC960_Error("Unable to allocate Controller structure for "
                        "Controller at\n", NULL);
         return NULL;
   }
-  memset(Controller, 0, sizeof(DAC960_Controller_T));
   Controller->ControllerNumber = DAC960_ControllerCount;
   DAC960_Controllers[DAC960_ControllerCount++] = Controller;
   Controller->Bus = PCI_Device->bus->number;
@@ -3657,8 +3655,8 @@ static void DAC960_V1_ProcessCompletedCommand(DAC960_Command_T *Command)
               (NewEnquiry->EventLogSequenceNumber !=
                OldEnquiry->EventLogSequenceNumber) ||
               Controller->MonitoringTimerCount == 0 ||
-              (jiffies - Controller->SecondaryMonitoringTime
-               >= DAC960_SecondaryMonitoringInterval))
+              time_after_eq(jiffies, Controller->SecondaryMonitoringTime
+               + DAC960_SecondaryMonitoringInterval))
             {
               Controller->V1.NeedLogicalDriveInformation = true;
               Controller->V1.NewEventLogSequenceNumber =
@@ -5643,8 +5641,8 @@ static void DAC960_MonitoringTimerFunction(unsigned long TimerData)
       unsigned int StatusChangeCounter =
         Controller->V2.HealthStatusBuffer->StatusChangeCounter;
       boolean ForceMonitoringCommand = false;
-      if (jiffies - Controller->SecondaryMonitoringTime
-          > DAC960_SecondaryMonitoringInterval)
+      if (time_after(jiffies, Controller->SecondaryMonitoringTime
+          + DAC960_SecondaryMonitoringInterval))
         {
           int LogicalDriveNumber;
           for (LogicalDriveNumber = 0;
@@ -5672,8 +5670,8 @@ static void DAC960_MonitoringTimerFunction(unsigned long TimerData)
            ControllerInfo->ConsistencyChecksActive +
            ControllerInfo->RebuildsActive +
            ControllerInfo->OnlineExpansionsActive == 0 ||
-           jiffies - Controller->PrimaryMonitoringTime
-           < DAC960_MonitoringTimerInterval) &&
+           time_before(jiffies, Controller->PrimaryMonitoringTime
+           + DAC960_MonitoringTimerInterval)) &&
           !ForceMonitoringCommand)
         {
           Controller->MonitoringTimer.expires =
@@ -5810,8 +5808,8 @@ static void DAC960_Message(DAC960_MessageLevel_T MessageLevel,
       Controller->ProgressBufferLength = Length;
       if (Controller->EphemeralProgressMessage)
         {
-          if (jiffies - Controller->LastProgressReportTime
-              >= DAC960_ProgressReportingInterval)
+          if (time_after_eq(jiffies, Controller->LastProgressReportTime
+              + DAC960_ProgressReportingInterval))
             {
               printk("%sDAC960#%d: %s", DAC960_MessageLevelMap[MessageLevel],
                      Controller->ControllerNumber, Buffer);
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index 875ae7699025..ae0949b3394f 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -383,8 +383,9 @@ config BLK_DEV_RAM
           thus say N here.
 
 config BLK_DEV_RAM_COUNT
-        int "Default number of RAM disks" if BLK_DEV_RAM
+        int "Default number of RAM disks"
         default "16"
+        depends on BLK_DEV_RAM
         help
           The default value is 16 RAM disks. Change this if you know what
           are doing. If you boot from a filesystem that needs to be extracted
diff --git a/drivers/block/acsi_slm.c b/drivers/block/acsi_slm.c
index a5c1c8e871ec..4cb9c1336287 100644
--- a/drivers/block/acsi_slm.c
+++ b/drivers/block/acsi_slm.c
@@ -369,8 +369,6 @@ static ssize_t slm_read( struct file *file, char *buf, size_t count,
         int length;
         int end;
 
-        if (count < 0)
-                return( -EINVAL );
         if (!(page = __get_free_page( GFP_KERNEL )))
                 return( -ENOMEM );
         
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 71ec9e664383..1b0fd31c57c3 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -996,13 +996,11 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                         status = -EINVAL;
                         goto cleanup1;
                 }
-                buff = (unsigned char **) kmalloc(MAXSGENTRIES * 
-                                sizeof(char *), GFP_KERNEL);
+                buff = kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
                 if (!buff) {
                         status = -ENOMEM;
                         goto cleanup1;
                 }
-                memset(buff, 0, MAXSGENTRIES);
                 buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int), 
                                         GFP_KERNEL);
                 if (!buff_size) {
@@ -2729,9 +2727,9 @@ static void __devinit cciss_interrupt_mode(ctlr_info_t *c, struct pci_dev *pdev,
                         return;
                 }
         }
+default_int_mode:
 #endif /* CONFIG_PCI_MSI */
         /* if we get here we're going to use the default interrupt mode */
-default_int_mode:
         c->intr[SIMPLE_MODE_INT] = pdev->irq;
         return;
 }
@@ -2940,13 +2938,12 @@ static void cciss_getgeometry(int cntl_num)
         int block_size;
         int total_size; 
 
-        ld_buff = kmalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
+        ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
         if (ld_buff == NULL)
         {
                 printk(KERN_ERR "cciss: out of memory\n");
                 return;
         }
-        memset(ld_buff, 0, sizeof(ReportLunData_struct));
         size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
         if (size_buff == NULL)
         {
@@ -3060,10 +3057,9 @@ static int alloc_cciss_hba(void)
         for(i=0; i< MAX_CTLR; i++) {
                 if (!hba[i]) {
                         ctlr_info_t *p;
-                        p = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
+                        p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
                         if (!p)
                                 goto Enomem;
-                        memset(p, 0, sizeof(ctlr_info_t));
                         for (n = 0; n < NWD; n++)
                                 p->gendisk[n] = disk[n];
                         hba[i] = p;
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index 0e66e904bd8c..597c007fe81b 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -1027,12 +1027,11 @@ cciss_update_non_disk_devices(int cntl_num, int hostno)
         int i;
 
         c = (ctlr_info_t *) hba[cntl_num];      
-        ld_buff = kmalloc(reportlunsize, GFP_KERNEL);
+        ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
         if (ld_buff == NULL) {
                 printk(KERN_ERR "cciss: out of memory\n");
                 return;
         }
-        memset(ld_buff, 0, reportlunsize);
         inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
         if (inq_buff == NULL) {
                 printk(KERN_ERR "cciss: out of memory\n");
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index d3ad9081697e..bedb689b051f 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -170,6 +170,7 @@ static int print_unex = 1;
 #include <linux/mm.h>
 #include <linux/bio.h>
 #include <linux/string.h>
+#include <linux/jiffies.h>
 #include <linux/fcntl.h>
 #include <linux/delay.h>
 #include <linux/mc146818rtc.h>  /* CMOS defines */
@@ -747,7 +748,7 @@ static int disk_change(int drive)
 {
         int fdc = FDC(drive);
 #ifdef FLOPPY_SANITY_CHECK
-        if (jiffies - UDRS->select_date < UDP->select_delay)
+        if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
                 DPRINT("WARNING disk change called early\n");
         if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
             (FDCS->dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
@@ -1075,7 +1076,7 @@ static int fd_wait_for_completion(unsigned long delay, timeout_fn function)
                 return 1;
         }
 
-        if ((signed)(jiffies - delay) < 0) {
+        if (time_before(jiffies, delay)) {
                 del_timer(&fd_timer);
                 fd_timer.function = function;
                 fd_timer.expires = delay;
@@ -1535,7 +1536,7 @@ static void setup_rw_floppy(void)
                  * again just before spinup completion. Beware that
                  * after scandrives, we must again wait for selection.
                  */
-                if ((signed)(ready_date - jiffies) > DP->select_delay) {
+                if (time_after(ready_date, jiffies + DP->select_delay)) {
                         ready_date -= DP->select_delay;
                         function = (timeout_fn) floppy_start;
                 } else
@@ -3823,7 +3824,7 @@ static int check_floppy_change(struct gendisk *disk)
         if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
                 return 1;
 
-        if (UDP->checkfreq < (int)(jiffies - UDRS->last_checked)) {
+        if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
                 if (floppy_grab_irq_and_dma()) {
                         return 1;
                 }
diff --git a/drivers/block/paride/bpck6.c b/drivers/block/paride/bpck6.c
index 08d858ad64db..41a237c5957d 100644
--- a/drivers/block/paride/bpck6.c
+++ b/drivers/block/paride/bpck6.c
@@ -224,10 +224,9 @@ static void bpck6_log_adapter( PIA *pi, char * scratch, int verbose )
 
 static int bpck6_init_proto(PIA *pi)
 {
-        Interface *p = kmalloc(sizeof(Interface), GFP_KERNEL);
+        Interface *p = kzalloc(sizeof(Interface), GFP_KERNEL);
 
         if (p) {
-                memset(p, 0, sizeof(Interface));
                 pi->private = (unsigned long)p;
                 return 0;
         }
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 62d2464c12f2..2403721f9db1 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -151,6 +151,7 @@ enum {D_PRT, D_PRO, D_UNI, D_MOD, D_GEO, D_SBY, D_DLY, D_SLV};
 #include <linux/cdrom.h>        /* for the eject ioctl */
 #include <linux/blkdev.h>
 #include <linux/blkpg.h>
+#include <linux/kernel.h>
 #include <asm/uaccess.h>
 #include <linux/sched.h>
 #include <linux/workqueue.h>
@@ -275,7 +276,7 @@ static void pd_print_error(struct pd_unit *disk, char *msg, int status)
         int i;
 
         printk("%s: %s: status = 0x%x =", disk->name, msg, status);
-        for (i = 0; i < 18; i++)
+        for (i = 0; i < ARRAY_SIZE(pd_errs); i++)
                 if (status & (1 << i))
                         printk(" %s", pd_errs[i]);
         printk("\n");
diff --git a/drivers/block/paride/pg.c b/drivers/block/paride/pg.c
index 6f5df0fad703..79b868254032 100644
--- a/drivers/block/paride/pg.c
+++ b/drivers/block/paride/pg.c
@@ -643,7 +643,8 @@ static ssize_t pg_read(struct file *filp, char __user *buf, size_t count, loff_t
 
 static int __init pg_init(void)
 {
-        int unit, err = 0;
+        int unit;
+        int err;
 
         if (disable){
                 err = -1;
@@ -657,16 +658,17 @@ static int __init pg_init(void)
                 goto out;
         }
 
-        if (register_chrdev(major, name, &pg_fops)) {
+        err = register_chrdev(major, name, &pg_fops);
+        if (err < 0) {
                 printk("pg_init: unable to get major number %d\n", major);
                 for (unit = 0; unit < PG_UNITS; unit++) {
                         struct pg *dev = &devices[unit];
                         if (dev->present)
                                 pi_release(dev->pi);
                 }
-                err = -1;
                 goto out;
         }
+        major = err;    /* In case the user specified `major=0' (dynamic) */
         pg_class = class_create(THIS_MODULE, "pg");
         if (IS_ERR(pg_class)) {
                 err = PTR_ERR(pg_class);
diff --git a/drivers/block/paride/pt.c b/drivers/block/paride/pt.c
index 715ae5dc88fb..d2013d362403 100644
--- a/drivers/block/paride/pt.c
+++ b/drivers/block/paride/pt.c
@@ -943,7 +943,8 @@ static ssize_t pt_write(struct file *filp, const char __user *buf, size_t count,
 
 static int __init pt_init(void)
 {
-        int unit, err = 0;
+        int unit;
+        int err;
 
         if (disable) {
                 err = -1;
@@ -955,14 +956,15 @@ static int __init pt_init(void)
                 goto out;
         }
 
-        if (register_chrdev(major, name, &pt_fops)) {
+        err = register_chrdev(major, name, &pt_fops);
+        if (err < 0) {
                 printk("pt_init: unable to get major number %d\n", major);
                 for (unit = 0; unit < PT_UNITS; unit++)
                         if (pt[unit].present)
                                 pi_release(pt[unit].pi);
-                err = -1;
                 goto out;
         }
+        major = err;
         pt_class = class_create(THIS_MODULE, "pt");
         if (IS_ERR(pt_class)) {
                 err = PTR_ERR(pt_class);
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index c16e66b9c7a7..f7d4c65a7b8c 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -50,6 +50,7 @@
 #include <linux/timer.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
+#include <linux/dma-mapping.h>
 
 #include <linux/fcntl.h>        /* O_ACCMODE */
 #include <linux/hdreg.h>  /* HDIO_GETGEO */
@@ -881,8 +882,8 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
         printk(KERN_INFO "Micro Memory(tm) controller #%d found at %02x:%02x (PCI Mem Module (Battery Backup))\n",
                card->card_number, dev->bus->number, dev->devfn);
 
-        if (pci_set_dma_mask(dev, 0xffffffffffffffffLL) &&
-            pci_set_dma_mask(dev, 0xffffffffLL)) {
+        if (pci_set_dma_mask(dev, DMA_64BIT_MASK) &&
+            pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
                 printk(KERN_WARNING "MM%d: NO suitable DMA found\n",num_cards);
                 return  -ENOMEM;
         }
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 7a85b3a26ff8..889cad07774e 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -713,7 +713,7 @@ config NVRAM
 
 config RTC
         tristate "Enhanced Real Time Clock Support"
-        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV
+        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV && !ARM
         ---help---
           If you say Y here and create a character special file /dev/rtc with
           major number 10 and minor number 135 using mknod ("man mknod"), you
diff --git a/drivers/char/agp/nvidia-agp.c b/drivers/char/agp/nvidia-agp.c
index 70b8ed9cd172..4c67135c12d8 100644
--- a/drivers/char/agp/nvidia-agp.c
+++ b/drivers/char/agp/nvidia-agp.c
@@ -11,6 +11,7 @@
 #include <linux/gfp.h>
 #include <linux/page-flags.h>
 #include <linux/mm.h>
+#include <linux/jiffies.h>
 #include "agp.h"
 
 /* NVIDIA registers */
@@ -256,7 +257,7 @@ static void nvidia_tlbflush(struct agp_memory *mem)
                 do {
                         pci_read_config_dword(nvidia_private.dev_1,
                                         NVIDIA_1_WBC, &wbc_reg);
-                        if ((signed)(end - jiffies) <= 0) {
+                        if (time_before_eq(end, jiffies)) {
                                 printk(KERN_ERR PFX
                                     "TLB flush took more than 3 seconds.\n");
                         }
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 641f7633878c..b7f7951c4587 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -175,7 +175,7 @@ int drm_stub_open(struct inode *inode, struct file *filp)
         drm_device_t *dev = NULL;
         int minor = iminor(inode);
         int err = -ENODEV;
-        struct file_operations *old_fops;
+        const struct file_operations *old_fops;
 
         DRM_DEBUG("\n");
 
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c
index ae0aa6d7e0bb..c658dde3633b 100644
--- a/drivers/char/drm/i810_dma.c
+++ b/drivers/char/drm/i810_dma.c
@@ -126,7 +126,7 @@ static int i810_map_buffer(drm_buf_t * buf, struct file *filp)
         drm_device_t *dev = priv->head->dev;
         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
         drm_i810_private_t *dev_priv = dev->dev_private;
-        struct file_operations *old_fops;
+        const struct file_operations *old_fops;
         int retcode = 0;
 
         if (buf_priv->currently_mapped == I810_BUF_MAPPED)
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c
index 163f2cbfe60d..b0f815d8cea8 100644
--- a/drivers/char/drm/i830_dma.c
+++ b/drivers/char/drm/i830_dma.c
@@ -128,7 +128,7 @@ static int i830_map_buffer(drm_buf_t * buf, struct file *filp)
         drm_device_t *dev = priv->head->dev;
         drm_i830_buf_priv_t *buf_priv = buf->dev_private;
         drm_i830_private_t *dev_priv = dev->dev_private;
-        struct file_operations *old_fops;
+        const struct file_operations *old_fops;
         unsigned long virtual;
         int retcode = 0;
 
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index b8fb87c6c29f..40eb005b9d77 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -3744,7 +3744,7 @@ static int ipmi_init_msghandler(void)
         ipmi_timer.expires = jiffies + IPMI_TIMEOUT_JIFFIES;
         add_timer(&ipmi_timer);
 
-        notifier_chain_register(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
         initialized = 1;
 
@@ -3764,7 +3764,7 @@ static __exit void cleanup_ipmi(void)
         if (!initialized)
                 return;
 
-        notifier_chain_unregister(&panic_notifier_list, &panic_block);
+        atomic_notifier_chain_unregister(&panic_notifier_list, &panic_block);
 
         /* This can't be called if any interfaces exist, so no worry about
            shutting down the interfaces. */
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 12f858dc9994..35fbd4d8ed4b 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -237,10 +237,10 @@ struct smi_info
 
 static int try_smi_init(struct smi_info *smi);
 
-static struct notifier_block *xaction_notifier_list;
+static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
 static int register_xaction_notifier(struct notifier_block * nb)
 {
-        return notifier_chain_register(&xaction_notifier_list, nb);
+        return atomic_notifier_chain_register(&xaction_notifier_list, nb);
 }
 
 static void si_restart_short_timer(struct smi_info *smi_info);
@@ -302,7 +302,8 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                 do_gettimeofday(&t);
                 printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
-                err = notifier_call_chain(&xaction_notifier_list, 0, smi_info);
+                err = atomic_notifier_call_chain(&xaction_notifier_list,
+                                0, smi_info);
                 if (err & NOTIFY_STOP_MASK) {
                         rv = SI_SM_CALL_WITHOUT_DELAY;
                         goto out;
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index 616539310d9a..7ece9f3c8f70 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -1158,7 +1158,8 @@ static int __init ipmi_wdog_init(void)
         }
 
         register_reboot_notifier(&wdog_reboot_notifier);
-        notifier_chain_register(&panic_notifier_list, &wdog_panic_notifier);
+        atomic_notifier_chain_register(&panic_notifier_list,
+                        &wdog_panic_notifier);
 
         printk(KERN_INFO PFX "driver initialized\n");
 
@@ -1176,7 +1177,8 @@ static __exit void ipmi_unregister_watchdog(void)
                 release_nmi(&ipmi_nmi_handler);
 #endif
 
-        notifier_chain_unregister(&panic_notifier_list, &wdog_panic_notifier);
+        atomic_notifier_chain_unregister(&panic_notifier_list,
+                        &wdog_panic_notifier);
         unregister_reboot_notifier(&wdog_reboot_notifier);
 
         if (! watchdog_user)
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 5245ba1649ed..66719f9d294c 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -899,7 +899,7 @@ static const struct {
         unsigned int            minor;
         char                    *name;
         umode_t                 mode;
-        struct file_operations  *fops;
+        const struct file_operations    *fops;
 } devlist[] = { /* list of minor devices */
         {1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops},
         {2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 3e4c0414a01a..96eb2a709e21 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -129,7 +129,7 @@ static int misc_open(struct inode * inode, struct file * file)
         int minor = iminor(inode);
         struct miscdevice *c;
         int err = -ENODEV;
-        struct file_operations *old_fops, *new_fops = NULL;
+        const struct file_operations *old_fops, *new_fops = NULL;
         
         down(&misc_sem);
         
diff --git a/drivers/char/mxser.h b/drivers/char/mxser.h
index e7fd0b08e0b7..7e188a4d602a 100644
--- a/drivers/char/mxser.h
+++ b/drivers/char/mxser.h
@@ -118,7 +118,7 @@
 
 // enable CTS interrupt
 #define MOXA_MUST_IER_ECTSI             0x80
-// eanble RTS interrupt
+// enable RTS interrupt
 #define MOXA_MUST_IER_ERTSI             0x40
 // enable Xon/Xoff interrupt
 #define MOXA_MUST_IER_XINT              0x20
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index d68be61f0a49..fee2aca3f6a5 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -941,17 +941,6 @@ static void* mgsl_get_text_ptr(void)
         return mgsl_get_text_ptr;
 }
 
-/*
- * tmp_buf is used as a temporary buffer by mgsl_write.  We need to
- * lock it in case the COPY_FROM_USER blocks while swapping in a page,
- * and some other program tries to do a serial write at the same time.
- * Since the lock will only come under contention when the system is
- * swapping and available memory is low, it makes sense to share one
- * buffer across all the serial ioports, since it significantly saves
- * memory if large numbers of serial ports are open.
- */
-static unsigned char *tmp_buf;
-
 static inline int mgsl_paranoia_check(struct mgsl_struct *info,
                                         char *name, const char *routine)
 {
@@ -2150,7 +2139,7 @@ static int mgsl_write(struct tty_struct * tty,
         if (mgsl_paranoia_check(info, tty->name, "mgsl_write"))
                 goto cleanup;
 
-        if (!tty || !info->xmit_buf || !tmp_buf)
+        if (!tty || !info->xmit_buf)
                 goto cleanup;
 
         if ( info->params.mode == MGSL_MODE_HDLC ||
@@ -3438,7 +3427,6 @@ static int mgsl_open(struct tty_struct *tty, struct file * filp)
 {
         struct mgsl_struct      *info;
         int                     retval, line;
-        unsigned long           page;
         unsigned long flags;
 
         /* verify range of specified line number */     
@@ -3472,18 +3460,6 @@ static int mgsl_open(struct tty_struct *tty, struct file * filp)
                 goto cleanup;
         }
         
-        if (!tmp_buf) {
-                page = get_zeroed_page(GFP_KERNEL);
-                if (!page) {
-                        retval = -ENOMEM;
-                        goto cleanup;
-                }
-                if (tmp_buf)
-                        free_page(page);
-                else
-                        tmp_buf = (unsigned char *) page;
-        }
-        
         info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
         spin_lock_irqsave(&info->netlock, flags);
@@ -4502,11 +4478,6 @@ static void synclink_cleanup(void)
                 kfree(tmp);
         }
         
-        if (tmp_buf) {
-                free_page((unsigned long) tmp_buf);
-                tmp_buf = NULL;
-        }
-        
         if (pci_registered)
                 pci_unregister_driver(&synclink_pci_driver);
 }
@@ -6025,7 +5996,7 @@ static void usc_set_async_mode( struct mgsl_struct *info )
          * <15..8>      ?               RxFIFO IRQ Request Level
          *
          * Note: For async mode the receive FIFO level must be set
-         * to 0 to aviod the situation where the FIFO contains fewer bytes
+         * to 0 to avoid the situation where the FIFO contains fewer bytes
          * than the trigger level and no more data is expected.
          *
          * <7>          0               Exited Hunt IA (Interrupt Arm)
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 738ec2f4e563..b4d1f4eea435 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -1,5 +1,5 @@
 /*
- * $Id: synclink_gt.c,v 4.22 2006/01/09 20:16:06 paulkf Exp $
+ * $Id: synclink_gt.c,v 4.25 2006/02/06 21:20:33 paulkf Exp $
  *
  * Device driver for Microgate SyncLink GT serial adapters.
  *
@@ -92,7 +92,7 @@
  * module identification
  */
 static char *driver_name     = "SyncLink GT";
-static char *driver_version  = "$Revision: 4.22 $";
+static char *driver_version  = "$Revision: 4.25 $";
 static char *tty_driver_name = "synclink_gt";
 static char *tty_dev_prefix  = "ttySLG";
 MODULE_LICENSE("GPL");
@@ -188,6 +188,20 @@ static void hdlcdev_exit(struct slgt_info *info);
 #define SLGT_REG_SIZE  256
 
 /*
+ * conditional wait facility
+ */
+struct cond_wait {
+        struct cond_wait *next;
+        wait_queue_head_t q;
+        wait_queue_t wait;
+        unsigned int data;
+};
+static void init_cond_wait(struct cond_wait *w, unsigned int data);
+static void add_cond_wait(struct cond_wait **head, struct cond_wait *w);
+static void remove_cond_wait(struct cond_wait **head, struct cond_wait *w);
+static void flush_cond_wait(struct cond_wait **head);
+
+/*
  * DMA buffer descriptor and access macros
  */
 struct slgt_desc
@@ -269,6 +283,9 @@ struct slgt_info {
         struct timer_list       tx_timer;
         struct timer_list       rx_timer;
 
+        unsigned int            gpio_present;
+        struct cond_wait        *gpio_wait_q;
+
         spinlock_t lock;        /* spinlock for synchronizing with ISR */
 
         struct work_struct task;
@@ -379,6 +396,11 @@ static MGSL_PARAMS default_params = {
 #define MASK_OVERRUN BIT4
 
 #define GSR   0x00 /* global status */
+#define JCR   0x04 /* JTAG control */
+#define IODR  0x08 /* GPIO direction */
+#define IOER  0x0c /* GPIO interrupt enable */
+#define IOVR  0x10 /* GPIO value */
+#define IOSR  0x14 /* GPIO interrupt status */
 #define TDR   0x80 /* tx data */
 #define RDR   0x80 /* rx data */
 #define TCR   0x82 /* tx control */
@@ -503,6 +525,9 @@ static int  tiocmset(struct tty_struct *tty, struct file *file,
 static void set_break(struct tty_struct *tty, int break_state);
 static int  get_interface(struct slgt_info *info, int __user *if_mode);
 static int  set_interface(struct slgt_info *info, int if_mode);
+static int  set_gpio(struct slgt_info *info, struct gpio_desc __user *gpio);
+static int  get_gpio(struct slgt_info *info, struct gpio_desc __user *gpio);
+static int  wait_gpio(struct slgt_info *info, struct gpio_desc __user *gpio);
 
 /*
  * driver functions
@@ -1112,6 +1137,12 @@ static int ioctl(struct tty_struct *tty, struct file *file,
                 return get_interface(info, argp);
         case MGSL_IOCSIF:
                 return set_interface(info,(int)arg);
+        case MGSL_IOCSGPIO:
+                return set_gpio(info, argp);
+        case MGSL_IOCGGPIO:
+                return get_gpio(info, argp);
+        case MGSL_IOCWAITGPIO:
+                return wait_gpio(info, argp);
         case TIOCGICOUNT:
                 spin_lock_irqsave(&info->lock,flags);
                 cnow = info->icount;
@@ -1762,10 +1793,6 @@ static void rx_async(struct slgt_info *info)
                 DBGDATA(info, p, count, "rx");
 
                 for(i=0 ; i < count; i+=2, p+=2) {
-                        if (tty && chars) {
-                                tty_flip_buffer_push(tty);
-                                chars = 0;
-                        }
                         ch = *p;
                         icount->rx++;
 
@@ -2158,6 +2185,24 @@ static void isr_txeom(struct slgt_info *info, unsigned short status)
         }
 }
 
+static void isr_gpio(struct slgt_info *info, unsigned int changed, unsigned int state)
+{
+        struct cond_wait *w, *prev;
+
+        /* wake processes waiting for specific transitions */
+        for (w = info->gpio_wait_q, prev = NULL ; w != NULL ; w = w->next) {
+                if (w->data & changed) {
+                        w->data = state;
+                        wake_up_interruptible(&w->q);
+                        if (prev != NULL)
+                                prev->next = w->next;
+                        else
+                                info->gpio_wait_q = w->next;
+                } else
+                        prev = w;
+        }
+}
+
 /* interrupt service routine
  *
  *      irq     interrupt number
@@ -2193,6 +2238,22 @@ static irqreturn_t slgt_interrupt(int irq, void *dev_id, struct pt_regs * regs)
                 }
         }
 
+        if (info->gpio_present) {
+                unsigned int state;
+                unsigned int changed;
+                while ((changed = rd_reg32(info, IOSR)) != 0) {
+                        DBGISR(("%s iosr=%08x\n", info->device_name, changed));
+                        /* read latched state of GPIO signals */
+                        state = rd_reg32(info, IOVR);
+                        /* clear pending GPIO interrupt bits */
+                        wr_reg32(info, IOSR, changed);
+                        for (i=0 ; i < info->port_count ; i++) {
+                                if (info->port_array[i] != NULL)
+                                        isr_gpio(info->port_array[i], changed, state);
+                        }
+                }
+        }
+
         for(i=0; i < info->port_count ; i++) {
                 struct slgt_info *port = info->port_array[i];
 
@@ -2276,6 +2337,8 @@ static void shutdown(struct slgt_info *info)
                 set_signals(info);
         }
 
+        flush_cond_wait(&info->gpio_wait_q);
+
         spin_unlock_irqrestore(&info->lock,flags);
 
         if (info->tty)
@@ -2650,6 +2713,175 @@ static int set_interface(struct slgt_info *info, int if_mode)
         return 0;
 }
 
+/*
+ * set general purpose IO pin state and direction
+ *
+ * user_gpio fields:
+ * state   each bit indicates a pin state
+ * smask   set bit indicates pin state to set
+ * dir     each bit indicates a pin direction (0=input, 1=output)
+ * dmask   set bit indicates pin direction to set
+ */
+static int set_gpio(struct slgt_info *info, struct gpio_desc __user *user_gpio)
+{
+        unsigned long flags;
+        struct gpio_desc gpio;
+        __u32 data;
+
+        if (!info->gpio_present)
+                return -EINVAL;
+        if (copy_from_user(&gpio, user_gpio, sizeof(gpio)))
+                return -EFAULT;
+        DBGINFO(("%s set_gpio state=%08x smask=%08x dir=%08x dmask=%08x\n",
+                 info->device_name, gpio.state, gpio.smask,
+                 gpio.dir, gpio.dmask));
+
+        spin_lock_irqsave(&info->lock,flags);
+        if (gpio.dmask) {
+                data = rd_reg32(info, IODR);
+                data |= gpio.dmask & gpio.dir;
+                data &= ~(gpio.dmask & ~gpio.dir);
+                wr_reg32(info, IODR, data);
+        }
+        if (gpio.smask) {
+                data = rd_reg32(info, IOVR);
+                data |= gpio.smask & gpio.state;
+                data &= ~(gpio.smask & ~gpio.state);
+                wr_reg32(info, IOVR, data);
+        }
+        spin_unlock_irqrestore(&info->lock,flags);
+
+        return 0;
+}
+
+/*
+ * get general purpose IO pin state and direction
+ */
+static int get_gpio(struct slgt_info *info, struct gpio_desc __user *user_gpio)
+{
+        struct gpio_desc gpio;
+        if (!info->gpio_present)
+                return -EINVAL;
+        gpio.state = rd_reg32(info, IOVR);
+        gpio.smask = 0xffffffff;
+        gpio.dir   = rd_reg32(info, IODR);
+        gpio.dmask = 0xffffffff;
+        if (copy_to_user(user_gpio, &gpio, sizeof(gpio)))
+                return -EFAULT;
+        DBGINFO(("%s get_gpio state=%08x dir=%08x\n",
+                 info->device_name, gpio.state, gpio.dir));
+        return 0;
+}
+
+/*
+ * conditional wait facility
+ */
+static void init_cond_wait(struct cond_wait *w, unsigned int data)
+{
+        init_waitqueue_head(&w->q);
+        init_waitqueue_entry(&w->wait, current);
+        w->data = data;
+}
+
+static void add_cond_wait(struct cond_wait **head, struct cond_wait *w)
+{
+        set_current_state(TASK_INTERRUPTIBLE);
+        add_wait_queue(&w->q, &w->wait);
+        w->next = *head;
+        *head = w;
+}
+
+static void remove_cond_wait(struct cond_wait **head, struct cond_wait *cw)
+{
+        struct cond_wait *w, *prev;
+        remove_wait_queue(&cw->q, &cw->wait);
+        set_current_state(TASK_RUNNING);
+        for (w = *head, prev = NULL ; w != NULL ; prev = w, w = w->next) {
+                if (w == cw) {
+                        if (prev != NULL)
+                                prev->next = w->next;
+                        else
+                                *head = w->next;
+                        break;
+                }
+        }
+}
+
+static void flush_cond_wait(struct cond_wait **head)
+{
+        while (*head != NULL) {
+                wake_up_interruptible(&(*head)->q);
+                *head = (*head)->next;
+        }
+}
+
+/*
+ * wait for general purpose I/O pin(s) to enter specified state
+ *
+ * user_gpio fields:
+ * state - bit indicates target pin state
+ * smask - set bit indicates watched pin
+ *
+ * The wait ends when at least one watched pin enters the specified
+ * state. When 0 (no error) is returned, user_gpio->state is set to the
+ * state of all GPIO pins when the wait ends.
+ *
+ * Note: Each pin may be a dedicated input, dedicated output, or
+ * configurable input/output. The number and configuration of pins
+ * varies with the specific adapter model. Only input pins (dedicated
+ * or configured) can be monitored with this function.
+ */
+static int wait_gpio(struct slgt_info *info, struct gpio_desc __user *user_gpio)
+{
+        unsigned long flags;
+        int rc = 0;
+        struct gpio_desc gpio;
+        struct cond_wait wait;
+        u32 state;
+
+        if (!info->gpio_present)
+                return -EINVAL;
+        if (copy_from_user(&gpio, user_gpio, sizeof(gpio)))
+                return -EFAULT;
+        DBGINFO(("%s wait_gpio() state=%08x smask=%08x\n",
+                 info->device_name, gpio.state, gpio.smask));
+        /* ignore output pins identified by set IODR bit */
+        if ((gpio.smask &= ~rd_reg32(info, IODR)) == 0)
+                return -EINVAL;
+        init_cond_wait(&wait, gpio.smask);
+
+        spin_lock_irqsave(&info->lock, flags);
+        /* enable interrupts for watched pins */
+        wr_reg32(info, IOER, rd_reg32(info, IOER) | gpio.smask);
+        /* get current pin states */
+        state = rd_reg32(info, IOVR);
+
+        if (gpio.smask & ~(state ^ gpio.state)) {
+                /* already in target state */
+                gpio.state = state;
+        } else {
+                /* wait for target state */
+                add_cond_wait(&info->gpio_wait_q, &wait);
+                spin_unlock_irqrestore(&info->lock, flags);
+                schedule();
+                if (signal_pending(current))
+                        rc = -ERESTARTSYS;
+                else
+                        gpio.state = wait.data;
+                spin_lock_irqsave(&info->lock, flags);
+                remove_cond_wait(&info->gpio_wait_q, &wait);
+        }
+
+        /* disable all GPIO interrupts if no waiting processes */
+        if (info->gpio_wait_q == NULL)
+                wr_reg32(info, IOER, 0);
+        spin_unlock_irqrestore(&info->lock,flags);
+
+        if ((rc == 0) && copy_to_user(user_gpio, &gpio, sizeof(gpio)))
+                rc = -EFAULT;
+        return rc;
+}
+
 static int modem_input_wait(struct slgt_info *info,int arg)
 {
         unsigned long flags;
@@ -3166,8 +3398,10 @@ static void device_init(int adapter_num, struct pci_dev *pdev)
                 } else {
                         port_array[0]->irq_requested = 1;
                         adapter_test(port_array[0]);
-                        for (i=1 ; i < port_count ; i++)
+                        for (i=1 ; i < port_count ; i++) {
                                 port_array[i]->init_error = port_array[0]->init_error;
+                                port_array[i]->gpio_present = port_array[0]->gpio_present;
+                        }
                 }
         }
 }
@@ -4301,7 +4535,7 @@ static int register_test(struct slgt_info *info)
                         break;
                 }
         }
-
+        info->gpio_present = (rd_reg32(info, JCR) & BIT5) ? 1 : 0;
         info->init_error = rc ? 0 : DiagStatus_AddressFailure;
         return rc;
 }
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index aed80e6aec6d..9b6ae7dc8b8a 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -52,9 +52,8 @@ static void handle_update(void *data);
  * changes to devices when the CPU clock speed changes.
  * The mutex locks both lists.
  */
-static struct notifier_block *cpufreq_policy_notifier_list;
-static struct notifier_block *cpufreq_transition_notifier_list;
-static DECLARE_RWSEM (cpufreq_notifier_rwsem);
+static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
+static BLOCKING_NOTIFIER_HEAD(cpufreq_transition_notifier_list);
 
 
 static LIST_HEAD(cpufreq_governor_list);
@@ -247,8 +246,6 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
         dprintk("notification %u of frequency transition to %u kHz\n",
                 state, freqs->new);
 
-        down_read(&cpufreq_notifier_rwsem);
-
         policy = cpufreq_cpu_data[freqs->cpu];
         switch (state) {
 
@@ -266,20 +263,19 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
                                 freqs->old = policy->cur;
                         }
                 }
-                notifier_call_chain(&cpufreq_transition_notifier_list,
-                                        CPUFREQ_PRECHANGE, freqs);
+                blocking_notifier_call_chain(&cpufreq_transition_notifier_list,
+                                CPUFREQ_PRECHANGE, freqs);
                 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
                 break;
 
         case CPUFREQ_POSTCHANGE:
                 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
-                notifier_call_chain(&cpufreq_transition_notifier_list,
-                                        CPUFREQ_POSTCHANGE, freqs);
+                blocking_notifier_call_chain(&cpufreq_transition_notifier_list,
+                                CPUFREQ_POSTCHANGE, freqs);
                 if (likely(policy) && likely(policy->cpu == freqs->cpu))
                         policy->cur = freqs->new;
                 break;
         }
-        up_read(&cpufreq_notifier_rwsem);
 }
 EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
 
@@ -1007,7 +1003,7 @@ static int cpufreq_suspend(struct sys_device * sysdev, pm_message_t pmsg)
                 freqs.old = cpu_policy->cur;
                 freqs.new = cur_freq;
 
-                notifier_call_chain(&cpufreq_transition_notifier_list,
+                blocking_notifier_call_chain(&cpufreq_transition_notifier_list,
                                     CPUFREQ_SUSPENDCHANGE, &freqs);
                 adjust_jiffies(CPUFREQ_SUSPENDCHANGE, &freqs);
 
@@ -1088,7 +1084,8 @@ static int cpufreq_resume(struct sys_device * sysdev)
                         freqs.old = cpu_policy->cur;
                         freqs.new = cur_freq;
 
-                        notifier_call_chain(&cpufreq_transition_notifier_list,
+                        blocking_notifier_call_chain(
+                                        &cpufreq_transition_notifier_list,
                                         CPUFREQ_RESUMECHANGE, &freqs);
                         adjust_jiffies(CPUFREQ_RESUMECHANGE, &freqs);
 
@@ -1125,24 +1122,24 @@ static struct sysdev_driver cpufreq_sysdev_driver = {
  *      changes in cpufreq policy.
  *
  *      This function may sleep, and has the same return conditions as
- *      notifier_chain_register.
+ *      blocking_notifier_chain_register.
  */
 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
 {
         int ret;
 
-        down_write(&cpufreq_notifier_rwsem);
         switch (list) {
         case CPUFREQ_TRANSITION_NOTIFIER:
-                ret = notifier_chain_register(&cpufreq_transition_notifier_list, nb);
+                ret = blocking_notifier_chain_register(
+                                &cpufreq_transition_notifier_list, nb);
                 break;
         case CPUFREQ_POLICY_NOTIFIER:
-                ret = notifier_chain_register(&cpufreq_policy_notifier_list, nb);
+                ret = blocking_notifier_chain_register(
+                                &cpufreq_policy_notifier_list, nb);
                 break;
         default:
                 ret = -EINVAL;
         }
-        up_write(&cpufreq_notifier_rwsem);
 
         return ret;
 }
@@ -1157,24 +1154,24 @@ EXPORT_SYMBOL(cpufreq_register_notifier);
  *      Remove a driver from the CPU frequency notifier list.
  *
  *      This function may sleep, and has the same return conditions as
- *      notifier_chain_unregister.
+ *      blocking_notifier_chain_unregister.
  */
 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
 {
         int ret;
 
-        down_write(&cpufreq_notifier_rwsem);
         switch (list) {
         case CPUFREQ_TRANSITION_NOTIFIER:
-                ret = notifier_chain_unregister(&cpufreq_transition_notifier_list, nb);
+                ret = blocking_notifier_chain_unregister(
+                                &cpufreq_transition_notifier_list, nb);
                 break;
         case CPUFREQ_POLICY_NOTIFIER:
-                ret = notifier_chain_unregister(&cpufreq_policy_notifier_list, nb);
+                ret = blocking_notifier_chain_unregister(
+                                &cpufreq_policy_notifier_list, nb);
                 break;
         default:
                 ret = -EINVAL;
         }
-        up_write(&cpufreq_notifier_rwsem);
 
         return ret;
 }
@@ -1346,29 +1343,23 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_poli
         if (ret)
                 goto error_out;
 
-        down_read(&cpufreq_notifier_rwsem);
-
         /* adjust if necessary - all reasons */
-        notifier_call_chain(&cpufreq_policy_notifier_list, CPUFREQ_ADJUST,
-                            policy);
+        blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
+                        CPUFREQ_ADJUST, policy);
 
         /* adjust if necessary - hardware incompatibility*/
-        notifier_call_chain(&cpufreq_policy_notifier_list, CPUFREQ_INCOMPATIBLE,
-                            policy);
+        blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
+                        CPUFREQ_INCOMPATIBLE, policy);
 
         /* verify the cpu speed can be set within this limit,
            which might be different to the first one */
         ret = cpufreq_driver->verify(policy);
-        if (ret) {
-                up_read(&cpufreq_notifier_rwsem);
+        if (ret)
                 goto error_out;
-        }
 
         /* notification of the new policy */
-        notifier_call_chain(&cpufreq_policy_notifier_list, CPUFREQ_NOTIFY,
-                            policy);
-
-        up_read(&cpufreq_notifier_rwsem);
+        blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
+                        CPUFREQ_NOTIFY, policy);
 
         data->min = policy->min;
         data->max = policy->max;
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index ac38766b2583..037f6bf4543c 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -35,12 +35,7 @@
  */
 
 #define DEF_FREQUENCY_UP_THRESHOLD              (80)
-#define MIN_FREQUENCY_UP_THRESHOLD              (0)
-#define MAX_FREQUENCY_UP_THRESHOLD              (100)
-
 #define DEF_FREQUENCY_DOWN_THRESHOLD            (20)
-#define MIN_FREQUENCY_DOWN_THRESHOLD            (0)
-#define MAX_FREQUENCY_DOWN_THRESHOLD            (100)
 
 /* 
  * The polling frequency of this governor depends on the capability of 
@@ -53,10 +48,14 @@
  * All times here are in uS.
  */
 static unsigned int                             def_sampling_rate;
-#define MIN_SAMPLING_RATE                       (def_sampling_rate / 2)
+#define MIN_SAMPLING_RATE_RATIO                 (2)
+/* for correct statistics, we need at least 10 ticks between each measure */
+#define MIN_STAT_SAMPLING_RATE                  (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))
+#define MIN_SAMPLING_RATE                       (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
 #define MAX_SAMPLING_RATE                       (500 * def_sampling_rate)
-#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (100000)
-#define DEF_SAMPLING_DOWN_FACTOR                (5)
+#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (1000)
+#define DEF_SAMPLING_DOWN_FACTOR                (1)
+#define MAX_SAMPLING_DOWN_FACTOR                (10)
 #define TRANSITION_LATENCY_LIMIT                (10 * 1000)
 
 static void do_dbs_timer(void *data);
@@ -66,6 +65,8 @@ struct cpu_dbs_info_s {
         unsigned int            prev_cpu_idle_up;
         unsigned int            prev_cpu_idle_down;
         unsigned int            enable;
+        unsigned int            down_skip;
+        unsigned int            requested_freq;
 };
 static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
 
@@ -87,6 +88,8 @@ static struct dbs_tuners dbs_tuners_ins = {
         .up_threshold           = DEF_FREQUENCY_UP_THRESHOLD,
         .down_threshold         = DEF_FREQUENCY_DOWN_THRESHOLD,
         .sampling_down_factor   = DEF_SAMPLING_DOWN_FACTOR,
+        .ignore_nice            = 0,
+        .freq_step              = 5,
 };
 
 static inline unsigned int get_cpu_idle_time(unsigned int cpu)
@@ -136,7 +139,7 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
         unsigned int input;
         int ret;
         ret = sscanf (buf, "%u", &input);
-        if (ret != 1 )
+        if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
                 return -EINVAL;
 
         mutex_lock(&dbs_mutex);
@@ -173,8 +176,7 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
         ret = sscanf (buf, "%u", &input);
 
         mutex_lock(&dbs_mutex);
-        if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || 
-                        input < MIN_FREQUENCY_UP_THRESHOLD ||
+        if (ret != 1 || input > 100 || input < 0 ||
                         input <= dbs_tuners_ins.down_threshold) {
                 mutex_unlock(&dbs_mutex);
                 return -EINVAL;
@@ -194,8 +196,7 @@ static ssize_t store_down_threshold(struct cpufreq_policy *unused,
         ret = sscanf (buf, "%u", &input);
 
         mutex_lock(&dbs_mutex);
-        if (ret != 1 || input > MAX_FREQUENCY_DOWN_THRESHOLD || 
-                        input < MIN_FREQUENCY_DOWN_THRESHOLD ||
+        if (ret != 1 || input > 100 || input < 0 ||
                         input >= dbs_tuners_ins.up_threshold) {
                 mutex_unlock(&dbs_mutex);
                 return -EINVAL;
@@ -297,31 +298,17 @@ static struct attribute_group dbs_attr_group = {
 static void dbs_check_cpu(int cpu)
 {
         unsigned int idle_ticks, up_idle_ticks, down_idle_ticks;
+        unsigned int tmp_idle_ticks, total_idle_ticks;
         unsigned int freq_step;
         unsigned int freq_down_sampling_rate;
-        static int down_skip[NR_CPUS];
-        static int requested_freq[NR_CPUS];
-        static unsigned short init_flag = 0;
-        struct cpu_dbs_info_s *this_dbs_info;
-        struct cpu_dbs_info_s *dbs_info;
-
+        struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
         struct cpufreq_policy *policy;
-        unsigned int j;
 
-        this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
         if (!this_dbs_info->enable)
                 return;
 
         policy = this_dbs_info->cur_policy;
 
-        if ( init_flag == 0 ) {
-                for_each_online_cpu(j) {
-                        dbs_info = &per_cpu(cpu_dbs_info, j);
-                        requested_freq[j] = dbs_info->cur_policy->cur;
-                }
-                init_flag = 1;
-        }
-        
         /* 
          * The default safe range is 20% to 80% 
          * Every sampling_rate, we check
@@ -337,39 +324,29 @@ static void dbs_check_cpu(int cpu)
          */
 
         /* Check for frequency increase */
-
         idle_ticks = UINT_MAX;
-        for_each_cpu_mask(j, policy->cpus) {
-                unsigned int tmp_idle_ticks, total_idle_ticks;
-                struct cpu_dbs_info_s *j_dbs_info;
 
-                j_dbs_info = &per_cpu(cpu_dbs_info, j);
-                /* Check for frequency increase */
-                total_idle_ticks = get_cpu_idle_time(j);
-                tmp_idle_ticks = total_idle_ticks -
-                        j_dbs_info->prev_cpu_idle_up;
-                j_dbs_info->prev_cpu_idle_up = total_idle_ticks;
-
-                if (tmp_idle_ticks < idle_ticks)
-                        idle_ticks = tmp_idle_ticks;
-        }
+        /* Check for frequency increase */
+        total_idle_ticks = get_cpu_idle_time(cpu);
+        tmp_idle_ticks = total_idle_ticks -
+                this_dbs_info->prev_cpu_idle_up;
+        this_dbs_info->prev_cpu_idle_up = total_idle_ticks;
+
+        if (tmp_idle_ticks < idle_ticks)
+                idle_ticks = tmp_idle_ticks;
 
         /* Scale idle ticks by 100 and compare with up and down ticks */
         idle_ticks *= 100;
         up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) *
-                usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
+                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
 
         if (idle_ticks < up_idle_ticks) {
-                down_skip[cpu] = 0;
-                for_each_cpu_mask(j, policy->cpus) {
-                        struct cpu_dbs_info_s *j_dbs_info;
+                this_dbs_info->down_skip = 0;
+                this_dbs_info->prev_cpu_idle_down =
+                        this_dbs_info->prev_cpu_idle_up;
 
-                        j_dbs_info = &per_cpu(cpu_dbs_info, j);
-                        j_dbs_info->prev_cpu_idle_down = 
-                                        j_dbs_info->prev_cpu_idle_up;
-                }
                 /* if we are already at full speed then break out early */
-                if (requested_freq[cpu] == policy->max)
+                if (this_dbs_info->requested_freq == policy->max)
                         return;
                 
                 freq_step = (dbs_tuners_ins.freq_step * policy->max) / 100;
@@ -378,49 +355,45 @@ static void dbs_check_cpu(int cpu)
                 if (unlikely(freq_step == 0))
                         freq_step = 5;
                 
-                requested_freq[cpu] += freq_step;
-                if (requested_freq[cpu] > policy->max)
-                        requested_freq[cpu] = policy->max;
+                this_dbs_info->requested_freq += freq_step;
+                if (this_dbs_info->requested_freq > policy->max)
+                        this_dbs_info->requested_freq = policy->max;
 
-                __cpufreq_driver_target(policy, requested_freq[cpu], 
+                __cpufreq_driver_target(policy, this_dbs_info->requested_freq,
                         CPUFREQ_RELATION_H);
                 return;
         }
 
         /* Check for frequency decrease */
-        down_skip[cpu]++;
-        if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor)
+        this_dbs_info->down_skip++;
+        if (this_dbs_info->down_skip < dbs_tuners_ins.sampling_down_factor)
                 return;
 
-        idle_ticks = UINT_MAX;
-        for_each_cpu_mask(j, policy->cpus) {
-                unsigned int tmp_idle_ticks, total_idle_ticks;
-                struct cpu_dbs_info_s *j_dbs_info;
+        /* Check for frequency decrease */
+        total_idle_ticks = this_dbs_info->prev_cpu_idle_up;
+        tmp_idle_ticks = total_idle_ticks -
+                this_dbs_info->prev_cpu_idle_down;
+        this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
 
-                j_dbs_info = &per_cpu(cpu_dbs_info, j);
-                total_idle_ticks = j_dbs_info->prev_cpu_idle_up;
-                tmp_idle_ticks = total_idle_ticks -
-                        j_dbs_info->prev_cpu_idle_down;
-                j_dbs_info->prev_cpu_idle_down = total_idle_ticks;
-
-                if (tmp_idle_ticks < idle_ticks)
-                        idle_ticks = tmp_idle_ticks;
-        }
+        if (tmp_idle_ticks < idle_ticks)
+                idle_ticks = tmp_idle_ticks;
 
         /* Scale idle ticks by 100 and compare with up and down ticks */
         idle_ticks *= 100;
-        down_skip[cpu] = 0;
+        this_dbs_info->down_skip = 0;
 
         freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *
                 dbs_tuners_ins.sampling_down_factor;
         down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) *
-                        usecs_to_jiffies(freq_down_sampling_rate);
+                usecs_to_jiffies(freq_down_sampling_rate);
 
         if (idle_ticks > down_idle_ticks) {
-                /* if we are already at the lowest speed then break out early
+                /*
+                 * if we are already at the lowest speed then break out early
                  * or if we 'cannot' reduce the speed as the user might want
-                 * freq_step to be zero */
-                if (requested_freq[cpu] == policy->min
+                 * freq_step to be zero
+                 */
+                if (this_dbs_info->requested_freq == policy->min
                                 || dbs_tuners_ins.freq_step == 0)
                         return;
 
@@ -430,13 +403,12 @@ static void dbs_check_cpu(int cpu)
                 if (unlikely(freq_step == 0))
                         freq_step = 5;
 
-                requested_freq[cpu] -= freq_step;
-                if (requested_freq[cpu] < policy->min)
-                        requested_freq[cpu] = policy->min;
+                this_dbs_info->requested_freq -= freq_step;
+                if (this_dbs_info->requested_freq < policy->min)
+                        this_dbs_info->requested_freq = policy->min;
 
-                __cpufreq_driver_target(policy,
-                        requested_freq[cpu],
-                        CPUFREQ_RELATION_H);
+                __cpufreq_driver_target(policy, this_dbs_info->requested_freq,
+                                CPUFREQ_RELATION_H);
                 return;
         }
 }
@@ -493,11 +465,13 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                         j_dbs_info = &per_cpu(cpu_dbs_info, j);
                         j_dbs_info->cur_policy = policy;
                 
-                        j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
+                        j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(cpu);
                         j_dbs_info->prev_cpu_idle_down
                                 = j_dbs_info->prev_cpu_idle_up;
                 }
                 this_dbs_info->enable = 1;
+                this_dbs_info->down_skip = 0;
+                this_dbs_info->requested_freq = policy->cur;
                 sysfs_create_group(&policy->kobj, &dbs_attr_group);
                 dbs_enable++;
                 /*
@@ -507,16 +481,17 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 if (dbs_enable == 1) {
                         unsigned int latency;
                         /* policy latency is in nS. Convert it to uS first */
+                        latency = policy->cpuinfo.transition_latency / 1000;
+                        if (latency == 0)
+                                latency = 1;
 
-                        latency = policy->cpuinfo.transition_latency;
-                        if (latency < 1000)
-                                latency = 1000;
-
-                        def_sampling_rate = (latency / 1000) *
+                        def_sampling_rate = 10 * latency *
                                         DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
+
+                        if (def_sampling_rate < MIN_STAT_SAMPLING_RATE)
+                                def_sampling_rate = MIN_STAT_SAMPLING_RATE;
+
                         dbs_tuners_ins.sampling_rate = def_sampling_rate;
-                        dbs_tuners_ins.ignore_nice = 0;
-                        dbs_tuners_ins.freq_step = 5;
 
                         dbs_timer_init();
                 }
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 69aa1db8336c..956d121cb161 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -84,6 +84,7 @@ struct dbs_tuners {
 static struct dbs_tuners dbs_tuners_ins = {
         .up_threshold = DEF_FREQUENCY_UP_THRESHOLD,
         .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR,
+        .ignore_nice = 0,
 };
 
 static inline unsigned int get_cpu_idle_time(unsigned int cpu)
@@ -350,6 +351,9 @@ static void dbs_check_cpu(int cpu)
         freq_next = (freq_next * policy->cur) /
                         (dbs_tuners_ins.up_threshold - 10);
 
+        if (freq_next < policy->min)
+                freq_next = policy->min;
+
         if (freq_next <= ((policy->cur * 95) / 100))
                 __cpufreq_driver_target(policy, freq_next, CPUFREQ_RELATION_L);
 }
@@ -395,8 +399,11 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                         return -EINVAL;
 
                 if (policy->cpuinfo.transition_latency >
-                                (TRANSITION_LATENCY_LIMIT * 1000))
+                                (TRANSITION_LATENCY_LIMIT * 1000)) {
+                        printk(KERN_WARNING "ondemand governor failed to load "
+                               "due to too long transition latency\n");
                         return -EINVAL;
+                }
                 if (this_dbs_info->enable) /* Already enabled */
                         break;
 
@@ -431,8 +438,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                                 def_sampling_rate = MIN_STAT_SAMPLING_RATE;
 
                         dbs_tuners_ins.sampling_rate = def_sampling_rate;
-                        dbs_tuners_ins.ignore_nice = 0;
-
                         dbs_timer_init();
                 }
 
diff --git a/drivers/edac/edac_mc.c b/drivers/edac/edac_mc.c
index 905f58ba8e16..ea06e3a4dc35 100644
--- a/drivers/edac/edac_mc.c
+++ b/drivers/edac/edac_mc.c
@@ -2044,7 +2044,7 @@ static int __init edac_mc_init(void)
          */
         clear_pci_parity_errors();
 
-        /* Create the MC sysfs entires */
+        /* Create the MC sysfs entries */
         if (edac_sysfs_memctrl_setup()) {
                 edac_printk(KERN_ERR, EDAC_MC,
                         "Error initializing sysfs code\n");
diff --git a/drivers/firmware/dcdbas.c b/drivers/firmware/dcdbas.c
index d6543fc4a923..339f405ff708 100644
--- a/drivers/firmware/dcdbas.c
+++ b/drivers/firmware/dcdbas.c
@@ -484,26 +484,15 @@ static void dcdbas_host_control(void)
 static int dcdbas_reboot_notify(struct notifier_block *nb, unsigned long code,
                                 void *unused)
 {
-        static unsigned int notify_cnt = 0;
-
         switch (code) {
         case SYS_DOWN:
         case SYS_HALT:
         case SYS_POWER_OFF:
                 if (host_control_on_shutdown) {
                         /* firmware is going to perform host control action */
-                        if (++notify_cnt == 2) {
-                                printk(KERN_WARNING
-                                       "Please wait for shutdown "
-                                       "action to complete...\n");
-                                dcdbas_host_control();
-                        }
-                        /*
-                         * register again and initiate the host control
-                         * action on the second notification to allow
-                         * everyone that registered to be notified
-                         */
-                        register_reboot_notifier(nb);
+                        printk(KERN_WARNING "Please wait for shutdown "
+                               "action to complete...\n");
+                        dcdbas_host_control();
                 }
                 break;
         }
@@ -514,7 +503,7 @@ static int dcdbas_reboot_notify(struct notifier_block *nb, unsigned long code,
 static struct notifier_block dcdbas_reboot_nb = {
         .notifier_call = dcdbas_reboot_notify,
         .next = NULL,
-        .priority = 0
+        .priority = INT_MIN
 };
 
 static DCDBAS_BIN_ATTR_RW(smi_data);
diff --git a/drivers/i2c/chips/Kconfig b/drivers/i2c/chips/Kconfig
index f9fae28f5612..7aa5c38f0855 100644
--- a/drivers/i2c/chips/Kconfig
+++ b/drivers/i2c/chips/Kconfig
@@ -65,15 +65,6 @@ config SENSORS_PCF8591
           This driver can also be built as a module.  If so, the module
           will be called pcf8591.
 
-config SENSORS_RTC8564
-        tristate "Epson 8564 RTC chip"
-        depends on I2C && EXPERIMENTAL
-        help
-          If you say yes here you get support for the Epson 8564 RTC chip.
-
-          This driver can also be built as a module.  If so, the module
-          will be called i2c-rtc8564.
-
 config ISP1301_OMAP
         tristate "Philips ISP1301 with OMAP OTG"
         depends on I2C && ARCH_OMAP_OTG
@@ -126,13 +117,4 @@ config SENSORS_MAX6875
           This driver can also be built as a module.  If so, the module
           will be called max6875.
 
-config RTC_X1205_I2C
-        tristate "Xicor X1205 RTC chip"
-        depends on I2C && EXPERIMENTAL
-        help
-          If you say yes here you get support for the Xicor X1205 RTC chip.
-
-          This driver can also be built as a module. If so, the module
-          will be called x1205.
-
 endmenu
diff --git a/drivers/i2c/chips/Makefile b/drivers/i2c/chips/Makefile
index 46178b57b1f1..779868ef2e26 100644
--- a/drivers/i2c/chips/Makefile
+++ b/drivers/i2c/chips/Makefile
@@ -10,10 +10,8 @@ obj-$(CONFIG_SENSORS_M41T00)	+= m41t00.o
 obj-$(CONFIG_SENSORS_PCA9539)   += pca9539.o
 obj-$(CONFIG_SENSORS_PCF8574)   += pcf8574.o
 obj-$(CONFIG_SENSORS_PCF8591)   += pcf8591.o
-obj-$(CONFIG_SENSORS_RTC8564)   += rtc8564.o
 obj-$(CONFIG_ISP1301_OMAP)      += isp1301_omap.o
 obj-$(CONFIG_TPS65010)          += tps65010.o
-obj-$(CONFIG_RTC_X1205_I2C)     += x1205.o
 
 ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)
 EXTRA_CFLAGS += -DDEBUG
diff --git a/drivers/i2c/chips/rtc8564.c b/drivers/i2c/chips/rtc8564.c
deleted file mode 100644
index 0d8699b3f488..000000000000
--- a/drivers/i2c/chips/rtc8564.c
+++ /dev/null
@@ -1,385 +0,0 @@
-/*
- *  linux/drivers/i2c/chips/rtc8564.c
- *
- *  Copyright (C) 2002-2004 Stefan Eletzhofer
- *
- *      based on linux/drivers/acron/char/pcf8583.c
- *  Copyright (C) 2000 Russell King
- *
- * 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.
- *
- * Driver for system3's EPSON RTC 8564 chip
- */
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/bcd.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/rtc.h>          /* get the user-level API */
-#include <linux/init.h>
-
-#include "rtc8564.h"
-
-#ifdef DEBUG
-# define _DBG(x, fmt, args...) do{ if (debug>=x) printk(KERN_DEBUG"%s: " fmt "\n", __FUNCTION__, ##args); } while(0);
-#else
-# define _DBG(x, fmt, args...) do { } while(0);
-#endif
-
-#define _DBGRTCTM(x, rtctm) if (debug>=x) printk("%s: secs=%d, mins=%d, hours=%d, mday=%d, " \
-                        "mon=%d, year=%d, wday=%d VL=%d\n", __FUNCTION__, \
-                        (rtctm).secs, (rtctm).mins, (rtctm).hours, (rtctm).mday, \
-                        (rtctm).mon, (rtctm).year, (rtctm).wday, (rtctm).vl);
-
-struct rtc8564_data {
-        struct i2c_client client;
-        u16 ctrl;
-};
-
-static inline u8 _rtc8564_ctrl1(struct i2c_client *client)
-{
-        struct rtc8564_data *data = i2c_get_clientdata(client);
-        return data->ctrl & 0xff;
-}
-static inline u8 _rtc8564_ctrl2(struct i2c_client *client)
-{
-        struct rtc8564_data *data = i2c_get_clientdata(client);
-        return (data->ctrl & 0xff00) >> 8;
-}
-
-#define CTRL1(c) _rtc8564_ctrl1(c)
-#define CTRL2(c) _rtc8564_ctrl2(c)
-
-static int debug;
-module_param(debug, int, S_IRUGO | S_IWUSR);
-
-static struct i2c_driver rtc8564_driver;
-
-static unsigned short ignore[] = { I2C_CLIENT_END };
-static unsigned short normal_addr[] = { 0x51, I2C_CLIENT_END };
-
-static struct i2c_client_address_data addr_data = {
-        .normal_i2c             = normal_addr,
-        .probe                  = ignore,
-        .ignore                 = ignore,
-};
-
-static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem);
-static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem);
-
-static int rtc8564_read(struct i2c_client *client, unsigned char adr,
-                        unsigned char *buf, unsigned char len)
-{
-        int ret = -EIO;
-        unsigned char addr[1] = { adr };
-        struct i2c_msg msgs[2] = {
-                {client->addr, 0, 1, addr},
-                {client->addr, I2C_M_RD, len, buf}
-        };
-
-        _DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, buf, len);
-
-        if (!buf) {
-                ret = -EINVAL;
-                goto done;
-        }
-
-        ret = i2c_transfer(client->adapter, msgs, 2);
-        if (ret == 2) {
-                ret = 0;
-        }
-
-done:
-        return ret;
-}
-
-static int rtc8564_write(struct i2c_client *client, unsigned char adr,
-                         unsigned char *data, unsigned char len)
-{
-        int ret = 0;
-        unsigned char _data[16];
-        struct i2c_msg wr;
-        int i;
-
-        if (!data || len > 15) {
-                ret = -EINVAL;
-                goto done;
-        }
-
-        _DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, data, len);
-
-        _data[0] = adr;
-        for (i = 0; i < len; i++) {
-                _data[i + 1] = data[i];
-                _DBG(5, "data[%d] = 0x%02x (%d)", i, data[i], data[i]);
-        }
-
-        wr.addr = client->addr;
-        wr.flags = 0;
-        wr.len = len + 1;
-        wr.buf = _data;
-
-        ret = i2c_transfer(client->adapter, &wr, 1);
-        if (ret == 1) {
-                ret = 0;
-        }
-
-done:
-        return ret;
-}
-
-static int rtc8564_attach(struct i2c_adapter *adap, int addr, int kind)
-{
-        int ret;
-        struct i2c_client *new_client;
-        struct rtc8564_data *d;
-        unsigned char data[10];
-        unsigned char ad[1] = { 0 };
-        struct i2c_msg ctrl_wr[1] = {
-                {addr, 0, 2, data}
-        };
-        struct i2c_msg ctrl_rd[2] = {
-                {addr, 0, 1, ad},
-                {addr, I2C_M_RD, 2, data}
-        };
-
-        d = kzalloc(sizeof(struct rtc8564_data), GFP_KERNEL);
-        if (!d) {
-                ret = -ENOMEM;
-                goto done;
-        }
-        new_client = &d->client;
-
-        strlcpy(new_client->name, "RTC8564", I2C_NAME_SIZE);
-        i2c_set_clientdata(new_client, d);
-        new_client->addr = addr;
-        new_client->adapter = adap;
-        new_client->driver = &rtc8564_driver;
-
-        _DBG(1, "client=%p", new_client);
-
-        /* init ctrl1 reg */
-        data[0] = 0;
-        data[1] = 0;
-        ret = i2c_transfer(new_client->adapter, ctrl_wr, 1);
-        if (ret != 1) {
-                printk(KERN_INFO "rtc8564: cant init ctrl1\n");
-                ret = -ENODEV;
-                goto done;
-        }
-
-        /* read back ctrl1 and ctrl2 */
-        ret = i2c_transfer(new_client->adapter, ctrl_rd, 2);
-        if (ret != 2) {
-                printk(KERN_INFO "rtc8564: cant read ctrl\n");
-                ret = -ENODEV;
-                goto done;
-        }
-
-        d->ctrl = data[0] | (data[1] << 8);
-
-        _DBG(1, "RTC8564_REG_CTRL1=%02x, RTC8564_REG_CTRL2=%02x",
-             data[0], data[1]);
-
-        ret = i2c_attach_client(new_client);
-done:
-        if (ret) {
-                kfree(d);
-        }
-        return ret;
-}
-
-static int rtc8564_probe(struct i2c_adapter *adap)
-{
-        return i2c_probe(adap, &addr_data, rtc8564_attach);
-}
-
-static int rtc8564_detach(struct i2c_client *client)
-{
-        i2c_detach_client(client);
-        kfree(i2c_get_clientdata(client));
-        return 0;
-}
-
-static int rtc8564_get_datetime(struct i2c_client *client, struct rtc_tm *dt)
-{
-        int ret = -EIO;
-        unsigned char buf[15];
-
-        _DBG(1, "client=%p, dt=%p", client, dt);
-
-        if (!dt)
-                return -EINVAL;
-
-        memset(buf, 0, sizeof(buf));
-
-        ret = rtc8564_read(client, 0, buf, 15);
-        if (ret)
-                return ret;
-
-        /* century stored in minute alarm reg */
-        dt->year = BCD2BIN(buf[RTC8564_REG_YEAR]);
-        dt->year += 100 * BCD2BIN(buf[RTC8564_REG_AL_MIN] & 0x3f);
-        dt->mday = BCD2BIN(buf[RTC8564_REG_DAY] & 0x3f);
-        dt->wday = BCD2BIN(buf[RTC8564_REG_WDAY] & 7);
-        dt->mon = BCD2BIN(buf[RTC8564_REG_MON_CENT] & 0x1f);
-
-        dt->secs = BCD2BIN(buf[RTC8564_REG_SEC] & 0x7f);
-        dt->vl = (buf[RTC8564_REG_SEC] & 0x80) == 0x80;
-        dt->mins = BCD2BIN(buf[RTC8564_REG_MIN] & 0x7f);
-        dt->hours = BCD2BIN(buf[RTC8564_REG_HR] & 0x3f);
-
-        _DBGRTCTM(2, *dt);
-
-        return 0;
-}
-
-static int
-rtc8564_set_datetime(struct i2c_client *client, struct rtc_tm *dt, int datetoo)
-{
-        int ret, len = 5;
-        unsigned char buf[15];
-
-        _DBG(1, "client=%p, dt=%p", client, dt);
-
-        if (!dt)
-                return -EINVAL;
-
-        _DBGRTCTM(2, *dt);
-
-        buf[RTC8564_REG_CTRL1] = CTRL1(client) | RTC8564_CTRL1_STOP;
-        buf[RTC8564_REG_CTRL2] = CTRL2(client);
-        buf[RTC8564_REG_SEC] = BIN2BCD(dt->secs);
-        buf[RTC8564_REG_MIN] = BIN2BCD(dt->mins);
-        buf[RTC8564_REG_HR] = BIN2BCD(dt->hours);
-
-        if (datetoo) {
-                len += 5;
-                buf[RTC8564_REG_DAY] = BIN2BCD(dt->mday);
-                buf[RTC8564_REG_WDAY] = BIN2BCD(dt->wday);
-                buf[RTC8564_REG_MON_CENT] = BIN2BCD(dt->mon) & 0x1f;
-                /* century stored in minute alarm reg */
-                buf[RTC8564_REG_YEAR] = BIN2BCD(dt->year % 100);
-                buf[RTC8564_REG_AL_MIN] = BIN2BCD(dt->year / 100);
-        }
-
-        ret = rtc8564_write(client, 0, buf, len);
-        if (ret) {
-                _DBG(1, "error writing data! %d", ret);
-        }
-
-        buf[RTC8564_REG_CTRL1] = CTRL1(client);
-        ret = rtc8564_write(client, 0, buf, 1);
-        if (ret) {
-                _DBG(1, "error writing data! %d", ret);
-        }
-
-        return ret;
-}
-
-static int rtc8564_get_ctrl(struct i2c_client *client, unsigned int *ctrl)
-{
-        struct rtc8564_data *data = i2c_get_clientdata(client);
-
-        if (!ctrl)
-                return -1;
-
-        *ctrl = data->ctrl;
-        return 0;
-}
-
-static int rtc8564_set_ctrl(struct i2c_client *client, unsigned int *ctrl)
-{
-        struct rtc8564_data *data = i2c_get_clientdata(client);
-        unsigned char buf[2];
-
-        if (!ctrl)
-                return -1;
-
-        buf[0] = *ctrl & 0xff;
-        buf[1] = (*ctrl & 0xff00) >> 8;
-        data->ctrl = *ctrl;
-
-        return rtc8564_write(client, 0, buf, 2);
-}
-
-static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem)
-{
-
-        if (!mem)
-                return -EINVAL;
-
-        return rtc8564_read(client, mem->loc, mem->data, mem->nr);
-}
-
-static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem)
-{
-
-        if (!mem)
-                return -EINVAL;
-
-        return rtc8564_write(client, mem->loc, mem->data, mem->nr);
-}
-
-static int
-rtc8564_command(struct i2c_client *client, unsigned int cmd, void *arg)
-{
-
-        _DBG(1, "cmd=%d", cmd);
-
-        switch (cmd) {
-        case RTC_GETDATETIME:
-                return rtc8564_get_datetime(client, arg);
-
-        case RTC_SETTIME:
-                return rtc8564_set_datetime(client, arg, 0);
-
-        case RTC_SETDATETIME:
-                return rtc8564_set_datetime(client, arg, 1);
-
-        case RTC_GETCTRL:
-                return rtc8564_get_ctrl(client, arg);
-
-        case RTC_SETCTRL:
-                return rtc8564_set_ctrl(client, arg);
-
-        case MEM_READ:
-                return rtc8564_read_mem(client, arg);
-
-        case MEM_WRITE:
-                return rtc8564_write_mem(client, arg);
-
-        default:
-                return -EINVAL;
-        }
-}
-
-static struct i2c_driver rtc8564_driver = {
-        .driver = {
-                .name   = "RTC8564",
-        },
-        .id             = I2C_DRIVERID_RTC8564,
-        .attach_adapter = rtc8564_probe,
-        .detach_client  = rtc8564_detach,
-        .command        = rtc8564_command
-};
-
-static __init int rtc8564_init(void)
-{
-        return i2c_add_driver(&rtc8564_driver);
-}
-
-static __exit void rtc8564_exit(void)
-{
-        i2c_del_driver(&rtc8564_driver);
-}
-
-MODULE_AUTHOR("Stefan Eletzhofer <Stefan.Eletzhofer@eletztrick.de>");
-MODULE_DESCRIPTION("EPSON RTC8564 Driver");
-MODULE_LICENSE("GPL");
-
-module_init(rtc8564_init);
-module_exit(rtc8564_exit);
diff --git a/drivers/i2c/chips/rtc8564.h b/drivers/i2c/chips/rtc8564.h
deleted file mode 100644
index e5342d10b8fa..000000000000
--- a/drivers/i2c/chips/rtc8564.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- *  linux/drivers/i2c/chips/rtc8564.h
- *
- *  Copyright (C) 2002-2004 Stefan Eletzhofer
- *
- *      based on linux/drivers/acron/char/pcf8583.h
- *  Copyright (C) 2000 Russell King
- *
- * 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.
- */
-struct rtc_tm {
-        unsigned char   secs;
-        unsigned char   mins;
-        unsigned char   hours;
-        unsigned char   mday;
-        unsigned char   mon;
-        unsigned short  year; /* xxxx 4 digits :) */
-        unsigned char   wday;
-        unsigned char   vl;
-};
-
-struct mem {
-        unsigned int    loc;
-        unsigned int    nr;
-        unsigned char   *data;
-};
-
-#define RTC_GETDATETIME 0
-#define RTC_SETTIME     1
-#define RTC_SETDATETIME 2
-#define RTC_GETCTRL     3
-#define RTC_SETCTRL     4
-#define MEM_READ        5
-#define MEM_WRITE       6
-
-#define RTC8564_REG_CTRL1               0x0 /* T  0 S 0 | T 0 0 0 */
-#define RTC8564_REG_CTRL2               0x1 /* 0  0 0 TI/TP | AF TF AIE TIE */
-#define RTC8564_REG_SEC                 0x2 /* VL 4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_MIN                 0x3 /* x  4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_HR                  0x4 /* x  x 2 1 | 8 4 2 1 */
-#define RTC8564_REG_DAY                 0x5 /* x  x 2 1 | 8 4 2 1 */
-#define RTC8564_REG_WDAY                0x6 /* x  x x x | x 4 2 1 */
-#define RTC8564_REG_MON_CENT    0x7 /* C  x x 1 | 8 4 2 1 */
-#define RTC8564_REG_YEAR                0x8 /* 8  4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_AL_MIN              0x9 /* AE 4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_AL_HR               0xa /* AE 4 2 1 | 8 4 2 1 */
-#define RTC8564_REG_AL_DAY              0xb /* AE x 2 1 | 8 4 2 1 */
-#define RTC8564_REG_AL_WDAY             0xc /* AE x x x | x 4 2 1 */
-#define RTC8564_REG_CLKOUT              0xd /* FE x x x | x x FD1 FD0 */
-#define RTC8564_REG_TCTL                0xe /* TE x x x | x x FD1 FD0 */
-#define RTC8564_REG_TIMER               0xf /* 8 bit binary */
-
-/* Control reg */
-#define RTC8564_CTRL1_TEST1             (1<<3)
-#define RTC8564_CTRL1_STOP              (1<<5)
-#define RTC8564_CTRL1_TEST2             (1<<7)
-
-#define RTC8564_CTRL2_TIE               (1<<0)
-#define RTC8564_CTRL2_AIE               (1<<1)
-#define RTC8564_CTRL2_TF                (1<<2)
-#define RTC8564_CTRL2_AF                (1<<3)
-#define RTC8564_CTRL2_TI_TP             (1<<4)
-
-/* CLKOUT frequencies */
-#define RTC8564_FD_32768HZ              (0x0)
-#define RTC8564_FD_1024HZ               (0x1)
-#define RTC8564_FD_32                   (0x2)
-#define RTC8564_FD_1HZ                  (0x3)
-
-/* Timer CTRL */
-#define RTC8564_TD_4096HZ               (0x0)
-#define RTC8564_TD_64HZ                 (0x1)
-#define RTC8564_TD_1HZ                  (0x2)
-#define RTC8564_TD_1_60HZ               (0x3)
-
-#define I2C_DRIVERID_RTC8564 0xf000
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index c7671e188017..b4a41d6d0714 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -2143,6 +2143,7 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
         req.data = (char *)&capbuf;
         req.data_len = sizeof(capbuf);
+        req.flags |= REQ_QUIET;
 
         stat = cdrom_queue_packet_command(drive, &req);
         if (stat == 0) {
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index ebc59064b475..f04791a58df0 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -433,6 +433,7 @@
 #include <linux/timer.h>
 #include <linux/mm.h>
 #include <linux/interrupt.h>
+#include <linux/jiffies.h>
 #include <linux/major.h>
 #include <linux/devfs_fs_kernel.h>
 #include <linux/errno.h>
@@ -2336,7 +2337,7 @@ static ide_startstop_t idetape_rw_callback (ide_drive_t *drive)
         }
         if (time_after(jiffies, tape->insert_time))
                 tape->insert_speed = tape->insert_size / 1024 * HZ / (jiffies - tape->insert_time);
-        if (jiffies - tape->avg_time >= HZ) {
+        if (time_after_eq(jiffies, tape->avg_time + HZ)) {
                 tape->avg_speed = tape->avg_size * HZ / (jiffies - tape->avg_time) / 1024;
                 tape->avg_size = 0;
                 tape->avg_time = jiffies;
@@ -2497,7 +2498,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
                         } else {
                                 return ide_do_reset(drive);
                         }
-                } else if (jiffies - tape->dsc_polling_start > IDETAPE_DSC_MA_THRESHOLD)
+                } else if (time_after(jiffies, tape->dsc_polling_start + IDETAPE_DSC_MA_THRESHOLD))
                         tape->dsc_polling_frequency = IDETAPE_DSC_MA_SLOW;
                 idetape_postpone_request(drive);
                 return ide_stopped;
diff --git a/drivers/ide/pci/amd74xx.c b/drivers/ide/pci/amd74xx.c
index 21965e5ef25e..b22ee5462318 100644
--- a/drivers/ide/pci/amd74xx.c
+++ b/drivers/ide/pci/amd74xx.c
@@ -347,10 +347,8 @@ static unsigned int __devinit init_chipset_amd74xx(struct pci_dev *dev, const ch
                         break;
 
                 case AMD_UDMA_66:
-                        pci_read_config_dword(dev, AMD_UDMA_TIMING, &u);
-                        for (i = 24; i >= 0; i -= 8)
-                                if ((u >> i) & 4)
-                                        amd_80w |= (1 << (1 - (i >> 4)));
+                        /* no host side cable detection */
+                        amd_80w = 0x03;
                         break;
         }
 
@@ -386,8 +384,6 @@ static unsigned int __devinit init_chipset_amd74xx(struct pci_dev *dev, const ch
         if (amd_clock < 20000 || amd_clock > 50000) {
                 printk(KERN_WARNING "%s: User given PCI clock speed impossible (%d), using 33 MHz instead.\n",
                         amd_chipset->name, amd_clock);
-                printk(KERN_WARNING "%s: Use ide0=ata66 if you want to assume 80-wire cable\n",
-                        amd_chipset->name);
                 amd_clock = 33333;
         }
 
diff --git a/drivers/ide/pci/generic.c b/drivers/ide/pci/generic.c
index 6e3ab0c38c4d..f82e82109728 100644
--- a/drivers/ide/pci/generic.c
+++ b/drivers/ide/pci/generic.c
@@ -41,14 +41,15 @@
 
 static int ide_generic_all;             /* Set to claim all devices */
 
+#ifndef MODULE
 static int __init ide_generic_all_on(char *unused)
 {
         ide_generic_all = 1;
         printk(KERN_INFO "IDE generic will claim all unknown PCI IDE storage controllers.\n");
         return 1;
 }
-
 __setup("all-generic-ide", ide_generic_all_on);
+#endif
 
 static void __devinit init_hwif_generic (ide_hwif_t *hwif)
 {
diff --git a/drivers/ide/pci/sis5513.c b/drivers/ide/pci/sis5513.c
index 75a2253a3e68..8e9d87701ce2 100644
--- a/drivers/ide/pci/sis5513.c
+++ b/drivers/ide/pci/sis5513.c
@@ -112,6 +112,7 @@ static const struct {
 
         { "SiS5596",    PCI_DEVICE_ID_SI_5596,  ATA_16   },
         { "SiS5571",    PCI_DEVICE_ID_SI_5571,  ATA_16   },
+        { "SiS5517",    PCI_DEVICE_ID_SI_5517,  ATA_16   },
         { "SiS551x",    PCI_DEVICE_ID_SI_5511,  ATA_16   },
 };
 
@@ -524,6 +525,7 @@ static void config_art_rwp_pio (ide_drive_t *drive, u8 pio)
                         case 3:         test1 = 0x30|0x03; break;
                         case 2:         test1 = 0x40|0x04; break;
                         case 1:         test1 = 0x60|0x07; break;
+                        case 0:         test1 = 0x00; break;
                         default:        break;
                 }
                 pci_write_config_byte(dev, drive_pci, test1);
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 4fe3da3c667a..f8af0945964e 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -923,7 +923,7 @@ void input_unregister_handler(struct input_handler *handler)
 static int input_open_file(struct inode *inode, struct file *file)
 {
         struct input_handler *handler = input_table[iminor(inode) >> 5];
-        struct file_operations *old_fops, *new_fops = NULL;
+        const struct file_operations *old_fops, *new_fops = NULL;
         int err;
 
         /* No load-on-demand here? */
diff --git a/drivers/isdn/capi/capi.c b/drivers/isdn/capi/capi.c
index 623adbb0d13a..9b493f0becc4 100644
--- a/drivers/isdn/capi/capi.c
+++ b/drivers/isdn/capi/capi.c
@@ -1485,6 +1485,7 @@ static int __init capi_init(void)
 {
         char *p;
         char *compileinfo;
+        int major_ret;
 
         if ((p = strchr(revision, ':')) != 0 && p[1]) {
                 strlcpy(rev, p + 2, sizeof(rev));
@@ -1493,11 +1494,12 @@ static int __init capi_init(void)
         } else
                 strcpy(rev, "1.0");
 
-        if (register_chrdev(capi_major, "capi20", &capi_fops)) {
+        major_ret = register_chrdev(capi_major, "capi20", &capi_fops);
+        if (major_ret < 0) {
                 printk(KERN_ERR "capi20: unable to get major %d\n", capi_major);
-                return -EIO;
+                return major_ret;
         }
-
+        capi_major = major_ret;
         capi_class = class_create(THIS_MODULE, "capi");
         if (IS_ERR(capi_class)) {
                 unregister_chrdev(capi_major, "capi20");
diff --git a/drivers/isdn/capi/kcapi_proc.c b/drivers/isdn/capi/kcapi_proc.c
index 2cc8b27e4c3b..ca9dc00a45c4 100644
--- a/drivers/isdn/capi/kcapi_proc.c
+++ b/drivers/isdn/capi/kcapi_proc.c
@@ -233,7 +233,7 @@ static struct file_operations proc_applstats_ops = {
 };
 
 static void
-create_seq_entry(char *name, mode_t mode, struct file_operations *f)
+create_seq_entry(char *name, mode_t mode, const struct file_operations *f)
 {
         struct proc_dir_entry *entry;
         entry = create_proc_entry(name, mode, NULL);
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 781d93b0bbd5..259fd8973ce9 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -81,7 +81,7 @@ static struct adb_driver *adb_driver_list[] = {
 static struct class *adb_dev_class;
 
 struct adb_driver *adb_controller;
-struct notifier_block *adb_client_list = NULL;
+BLOCKING_NOTIFIER_HEAD(adb_client_list);
 static int adb_got_sleep;
 static int adb_inited;
 static pid_t adb_probe_task_pid;
@@ -355,7 +355,8 @@ adb_notify_sleep(struct pmu_sleep_notifier *self, int when)
                 /* Stop autopoll */
                 if (adb_controller->autopoll)
                         adb_controller->autopoll(0);
-                ret = notifier_call_chain(&adb_client_list, ADB_MSG_POWERDOWN, NULL);
+                ret = blocking_notifier_call_chain(&adb_client_list,
+                                ADB_MSG_POWERDOWN, NULL);
                 if (ret & NOTIFY_STOP_MASK) {
                         up(&adb_probe_mutex);
                         return PBOOK_SLEEP_REFUSE;
@@ -392,7 +393,8 @@ do_adb_reset_bus(void)
         if (adb_controller->autopoll)
                 adb_controller->autopoll(0);
 
-        nret = notifier_call_chain(&adb_client_list, ADB_MSG_PRE_RESET, NULL);
+        nret = blocking_notifier_call_chain(&adb_client_list,
+                        ADB_MSG_PRE_RESET, NULL);
         if (nret & NOTIFY_STOP_MASK) {
                 if (adb_controller->autopoll)
                         adb_controller->autopoll(autopoll_devs);
@@ -427,7 +429,8 @@ do_adb_reset_bus(void)
         }
         up(&adb_handler_sem);
 
-        nret = notifier_call_chain(&adb_client_list, ADB_MSG_POST_RESET, NULL);
+        nret = blocking_notifier_call_chain(&adb_client_list,
+                        ADB_MSG_POST_RESET, NULL);
         if (nret & NOTIFY_STOP_MASK)
                 return -EBUSY;
         
diff --git a/drivers/macintosh/adbhid.c b/drivers/macintosh/adbhid.c
index 0a4c680d4ac0..394334ec5765 100644
--- a/drivers/macintosh/adbhid.c
+++ b/drivers/macintosh/adbhid.c
@@ -1214,7 +1214,8 @@ static int __init adbhid_init(void)
 
         adbhid_probe();
 
-        notifier_chain_register(&adb_client_list, &adbhid_adb_notifier);
+        blocking_notifier_chain_register(&adb_client_list,
+                        &adbhid_adb_notifier);
 
         return 0;
 }
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index 4f5f3abc9cb3..0b5ff553e39a 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -187,7 +187,7 @@ extern int disable_kernel_backlight;
 
 int __fake_sleep;
 int asleep;
-struct notifier_block *sleep_notifier_list;
+BLOCKING_NOTIFIER_HEAD(sleep_notifier_list);
 
 #ifdef CONFIG_ADB
 static int adb_dev_map = 0;
diff --git a/drivers/macintosh/via-pmu68k.c b/drivers/macintosh/via-pmu68k.c
index f08e52f2107b..35b70323e7e3 100644
--- a/drivers/macintosh/via-pmu68k.c
+++ b/drivers/macintosh/via-pmu68k.c
@@ -102,7 +102,7 @@ static int pmu_kind = PMU_UNKNOWN;
 static int pmu_fully_inited = 0;
 
 int asleep;
-struct notifier_block *sleep_notifier_list;
+BLOCKING_NOTIFIER_HEAD(sleep_notifier_list);
 
 static int pmu_probe(void);
 static int pmu_init(void);
@@ -913,7 +913,8 @@ int powerbook_sleep(void)
         struct adb_request sleep_req;
 
         /* Notify device drivers */
-        ret = notifier_call_chain(&sleep_notifier_list, PBOOK_SLEEP, NULL);
+        ret = blocking_notifier_call_chain(&sleep_notifier_list,
+                        PBOOK_SLEEP, NULL);
         if (ret & NOTIFY_STOP_MASK)
                 return -EBUSY;
 
@@ -984,7 +985,7 @@ int powerbook_sleep(void)
                         enable_irq(i);
 
         /* Notify drivers */
-        notifier_call_chain(&sleep_notifier_list, PBOOK_WAKE, NULL);
+        blocking_notifier_call_chain(&sleep_notifier_list, PBOOK_WAKE, NULL);
 
         /* reenable ADB autopoll */
         pmu_adb_autopoll(adb_dev_map);
diff --git a/drivers/macintosh/windfarm_core.c b/drivers/macintosh/windfarm_core.c
index 6c0ba04bc57a..ab3faa702d58 100644
--- a/drivers/macintosh/windfarm_core.c
+++ b/drivers/macintosh/windfarm_core.c
@@ -52,7 +52,7 @@
 static LIST_HEAD(wf_controls);
 static LIST_HEAD(wf_sensors);
 static DEFINE_MUTEX(wf_lock);
-static struct notifier_block *wf_client_list;
+static BLOCKING_NOTIFIER_HEAD(wf_client_list);
 static int wf_client_count;
 static unsigned int wf_overtemp;
 static unsigned int wf_overtemp_counter;
@@ -68,7 +68,7 @@ static struct platform_device wf_platform_device = {
 
 static inline void wf_notify(int event, void *param)
 {
-        notifier_call_chain(&wf_client_list, event, param);
+        blocking_notifier_call_chain(&wf_client_list, event, param);
 }
 
 int wf_critical_overtemp(void)
@@ -398,7 +398,7 @@ int wf_register_client(struct notifier_block *nb)
         struct wf_sensor *sr;
 
         mutex_lock(&wf_lock);
-        rc = notifier_chain_register(&wf_client_list, nb);
+        rc = blocking_notifier_chain_register(&wf_client_list, nb);
         if (rc != 0)
                 goto bail;
         wf_client_count++;
@@ -417,7 +417,7 @@ EXPORT_SYMBOL_GPL(wf_register_client);
 int wf_unregister_client(struct notifier_block *nb)
 {
         mutex_lock(&wf_lock);
-        notifier_chain_unregister(&wf_client_list, nb);
+        blocking_notifier_chain_unregister(&wf_client_list, nb);
         wf_client_count++;
         if (wf_client_count == 0)
                 wf_stop_thread();
diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index ac43f98062fd..fd2aae150ccc 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -127,6 +127,32 @@ config MD_RAID5
 
           If unsure, say Y.
 
+config MD_RAID5_RESHAPE
+        bool "Support adding drives to a raid-5 array (experimental)"
+        depends on MD_RAID5 && EXPERIMENTAL
+        ---help---
+          A RAID-5 set can be expanded by adding extra drives. This
+          requires "restriping" the array which means (almost) every
+          block must be written to a different place.
+
+          This option allows such restriping to be done while the array
+          is online.  However it is still EXPERIMENTAL code.  It should
+          work, but please be sure that you have backups.
+
+          You will need a version of mdadm newer than 2.3.1.   During the
+          early stage of reshape there is a critical section where live data
+          is being over-written.  A crash during this time needs extra care
+          for recovery.  The newer mdadm takes a copy of the data in the
+          critical section and will restore it, if necessary, after a crash.
+
+          The mdadm usage is e.g.
+               mdadm --grow /dev/md1 --raid-disks=6
+          to grow '/dev/md1' to having 6 disks.
+
+          Note: The array can only be expanded, not contracted.
+          There should be enough spares already present to make the new
+          array workable.
+
 config MD_RAID6
         tristate "RAID-6 mode"
         depends on BLK_DEV_MD
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 259e86f26549..61a590bb6241 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -518,6 +518,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         char *ivopts;
         unsigned int crypto_flags;
         unsigned int key_size;
+        unsigned long long tmpll;
 
         if (argc != 5) {
                 ti->error = PFX "Not enough arguments";
@@ -633,15 +634,17 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto bad5;
         }
 
-        if (sscanf(argv[2], SECTOR_FORMAT, &cc->iv_offset) != 1) {
+        if (sscanf(argv[2], "%llu", &tmpll) != 1) {
                 ti->error = PFX "Invalid iv_offset sector";
                 goto bad5;
         }
+        cc->iv_offset = tmpll;
 
-        if (sscanf(argv[4], SECTOR_FORMAT, &cc->start) != 1) {
+        if (sscanf(argv[4], "%llu", &tmpll) != 1) {
                 ti->error = PFX "Invalid device sector";
                 goto bad5;
         }
+        cc->start = tmpll;
 
         if (dm_get_device(ti, argv[3], cc->start, ti->len,
                           dm_table_get_mode(ti->table), &cc->dev)) {
@@ -885,8 +888,8 @@ static int crypt_status(struct dm_target *ti, status_type_t type,
                         result[sz++] = '-';
                 }
 
-                DMEMIT(" " SECTOR_FORMAT " %s " SECTOR_FORMAT,
-                       cc->iv_offset, cc->dev->name, cc->start);
+                DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset,
+                                cc->dev->name, (unsigned long long)cc->start);
                 break;
         }
         return 0;
diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index 442e2be6052e..8edd6435414d 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -15,6 +15,7 @@
 #include <linux/slab.h>
 #include <linux/devfs_fs_kernel.h>
 #include <linux/dm-ioctl.h>
+#include <linux/hdreg.h>
 
 #include <asm/uaccess.h>
 
@@ -244,9 +245,9 @@ static void __hash_remove(struct hash_cell *hc)
                 dm_table_put(table);
         }
 
-        dm_put(hc->md);
         if (hc->new_map)
                 dm_table_put(hc->new_map);
+        dm_put(hc->md);
         free_cell(hc);
 }
 
@@ -600,12 +601,22 @@ static int dev_create(struct dm_ioctl *param, size_t param_size)
  */
 static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
 {
+        struct mapped_device *md;
+        void *mdptr = NULL;
+
         if (*param->uuid)
                 return __get_uuid_cell(param->uuid);
-        else if (*param->name)
+
+        if (*param->name)
                 return __get_name_cell(param->name);
-        else
-                return dm_get_mdptr(huge_decode_dev(param->dev));
+
+        md = dm_get_md(huge_decode_dev(param->dev));
+        if (md) {
+                mdptr = dm_get_mdptr(md);
+                dm_put(md);
+        }
+
+        return mdptr;
 }
 
 static struct mapped_device *find_device(struct dm_ioctl *param)
@@ -690,6 +701,54 @@ static int dev_rename(struct dm_ioctl *param, size_t param_size)
         return dm_hash_rename(param->name, new_name);
 }
 
+static int dev_set_geometry(struct dm_ioctl *param, size_t param_size)
+{
+        int r = -EINVAL, x;
+        struct mapped_device *md;
+        struct hd_geometry geometry;
+        unsigned long indata[4];
+        char *geostr = (char *) param + param->data_start;
+
+        md = find_device(param);
+        if (!md)
+                return -ENXIO;
+
+        if (geostr < (char *) (param + 1) ||
+            invalid_str(geostr, (void *) param + param_size)) {
+                DMWARN("Invalid geometry supplied.");
+                goto out;
+        }
+
+        x = sscanf(geostr, "%lu %lu %lu %lu", indata,
+                   indata + 1, indata + 2, indata + 3);
+
+        if (x != 4) {
+                DMWARN("Unable to interpret geometry settings.");
+                goto out;
+        }
+
+        if (indata[0] > 65535 || indata[1] > 255 ||
+            indata[2] > 255 || indata[3] > ULONG_MAX) {
+                DMWARN("Geometry exceeds range limits.");
+                goto out;
+        }
+
+        geometry.cylinders = indata[0];
+        geometry.heads = indata[1];
+        geometry.sectors = indata[2];
+        geometry.start = indata[3];
+
+        r = dm_set_geometry(md, &geometry);
+        if (!r)
+                r = __dev_status(md, param);
+
+        param->data_size = 0;
+
+out:
+        dm_put(md);
+        return r;
+}
+
 static int do_suspend(struct dm_ioctl *param)
 {
         int r = 0;
@@ -975,33 +1034,43 @@ static int table_load(struct dm_ioctl *param, size_t param_size)
         int r;
         struct hash_cell *hc;
         struct dm_table *t;
+        struct mapped_device *md;
 
-        r = dm_table_create(&t, get_mode(param), param->target_count);
+        md = find_device(param);
+        if (!md)
+                return -ENXIO;
+
+        r = dm_table_create(&t, get_mode(param), param->target_count, md);
         if (r)
-                return r;
+                goto out;
 
         r = populate_table(t, param, param_size);
         if (r) {
                 dm_table_put(t);
-                return r;
+                goto out;
         }
 
         down_write(&_hash_lock);
-        hc = __find_device_hash_cell(param);
-        if (!hc) {
-                DMWARN("device doesn't appear to be in the dev hash table.");
-                up_write(&_hash_lock);
+        hc = dm_get_mdptr(md);
+        if (!hc || hc->md != md) {
+                DMWARN("device has been removed from the dev hash table.");
                 dm_table_put(t);
-                return -ENXIO;
+                up_write(&_hash_lock);
+                r = -ENXIO;
+                goto out;
         }
 
         if (hc->new_map)
                 dm_table_put(hc->new_map);
         hc->new_map = t;
+        up_write(&_hash_lock);
+
         param->flags |= DM_INACTIVE_PRESENT_FLAG;
+        r = __dev_status(md, param);
+
+out:
+        dm_put(md);
 
-        r = __dev_status(hc->md, param);
-        up_write(&_hash_lock);
         return r;
 }
 
@@ -1214,7 +1283,8 @@ static ioctl_fn lookup_ioctl(unsigned int cmd)
 
                 {DM_LIST_VERSIONS_CMD, list_versions},
 
-                {DM_TARGET_MSG_CMD, target_message}
+                {DM_TARGET_MSG_CMD, target_message},
+                {DM_DEV_SET_GEOMETRY_CMD, dev_set_geometry}
         };
 
         return (cmd >= ARRAY_SIZE(_ioctls)) ? NULL : _ioctls[cmd].fn;
diff --git a/drivers/md/dm-linear.c b/drivers/md/dm-linear.c
index 6a2cd5dc8a63..daf586c0898d 100644
--- a/drivers/md/dm-linear.c
+++ b/drivers/md/dm-linear.c
@@ -26,6 +26,7 @@ struct linear_c {
 static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 {
         struct linear_c *lc;
+        unsigned long long tmp;
 
         if (argc != 2) {
                 ti->error = "dm-linear: Invalid argument count";
@@ -38,10 +39,11 @@ static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 return -ENOMEM;
         }
 
-        if (sscanf(argv[1], SECTOR_FORMAT, &lc->start) != 1) {
+        if (sscanf(argv[1], "%llu", &tmp) != 1) {
                 ti->error = "dm-linear: Invalid device sector";
                 goto bad;
         }
+        lc->start = tmp;
 
         if (dm_get_device(ti, argv[0], lc->start, ti->len,
                           dm_table_get_mode(ti->table), &lc->dev)) {
@@ -87,8 +89,8 @@ static int linear_status(struct dm_target *ti, status_type_t type,
                 break;
 
         case STATUSTYPE_TABLE:
-                snprintf(result, maxlen, "%s " SECTOR_FORMAT, lc->dev->name,
-                         lc->start);
+                snprintf(result, maxlen, "%s %llu", lc->dev->name,
+                                (unsigned long long)lc->start);
                 break;
         }
         return 0;
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 4e90f231fbfb..d12cf3e5e076 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -402,9 +402,21 @@ static void rh_dec(struct region_hash *rh, region_t region)
 
         spin_lock_irqsave(&rh->region_lock, flags);
         if (atomic_dec_and_test(&reg->pending)) {
+                /*
+                 * There is no pending I/O for this region.
+                 * We can move the region to corresponding list for next action.
+                 * At this point, the region is not yet connected to any list.
+                 *
+                 * If the state is RH_NOSYNC, the region should be kept off
+                 * from clean list.
+                 * The hash entry for RH_NOSYNC will remain in memory
+                 * until the region is recovered or the map is reloaded.
+                 */
+
+                /* do nothing for RH_NOSYNC */
                 if (reg->state == RH_RECOVERING) {
                         list_add_tail(&reg->list, &rh->quiesced_regions);
-                } else {
+                } else if (reg->state == RH_DIRTY) {
                         reg->state = RH_CLEAN;
                         list_add(&reg->list, &rh->clean_regions);
                 }
@@ -922,9 +934,9 @@ static inline int _check_region_size(struct dm_target *ti, uint32_t size)
 static int get_mirror(struct mirror_set *ms, struct dm_target *ti,
                       unsigned int mirror, char **argv)
 {
-        sector_t offset;
+        unsigned long long offset;
 
-        if (sscanf(argv[1], SECTOR_FORMAT, &offset) != 1) {
+        if (sscanf(argv[1], "%llu", &offset) != 1) {
                 ti->error = "dm-mirror: Invalid offset";
                 return -EINVAL;
         }
@@ -1191,16 +1203,17 @@ static int mirror_status(struct dm_target *ti, status_type_t type,
                 for (m = 0; m < ms->nr_mirrors; m++)
                         DMEMIT("%s ", ms->mirror[m].dev->name);
 
-                DMEMIT(SECTOR_FORMAT "/" SECTOR_FORMAT,
-                       ms->rh.log->type->get_sync_count(ms->rh.log),
-                       ms->nr_regions);
+                DMEMIT("%llu/%llu",
+                        (unsigned long long)ms->rh.log->type->
+                                get_sync_count(ms->rh.log),
+                        (unsigned long long)ms->nr_regions);
                 break;
 
         case STATUSTYPE_TABLE:
                 DMEMIT("%d ", ms->nr_mirrors);
                 for (m = 0; m < ms->nr_mirrors; m++)
-                        DMEMIT("%s " SECTOR_FORMAT " ",
-                               ms->mirror[m].dev->name, ms->mirror[m].offset);
+                        DMEMIT("%s %llu ", ms->mirror[m].dev->name,
+                                (unsigned long long)ms->mirror[m].offset);
         }
 
         return 0;
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 7401540086df..08312b46463a 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -49,11 +49,26 @@ struct pending_exception {
         struct bio_list snapshot_bios;
 
         /*
-         * Other pending_exceptions that are processing this
-         * chunk.  When this list is empty, we know we can
-         * complete the origins.
+         * Short-term queue of pending exceptions prior to submission.
          */
-        struct list_head siblings;
+        struct list_head list;
+
+        /*
+         * The primary pending_exception is the one that holds
+         * the sibling_count and the list of origin_bios for a
+         * group of pending_exceptions.  It is always last to get freed.
+         * These fields get set up when writing to the origin.
+         */
+        struct pending_exception *primary_pe;
+
+        /*
+         * Number of pending_exceptions processing this chunk.
+         * When this drops to zero we must complete the origin bios.
+         * If incrementing or decrementing this, hold pe->snap->lock for
+         * the sibling concerned and not pe->primary_pe->snap->lock unless
+         * they are the same.
+         */
+        atomic_t sibling_count;
 
         /* Pointer back to snapshot context */
         struct dm_snapshot *snap;
@@ -377,6 +392,8 @@ static void read_snapshot_metadata(struct dm_snapshot *s)
                 down_write(&s->lock);
                 s->valid = 0;
                 up_write(&s->lock);
+
+                dm_table_event(s->table);
         }
 }
 
@@ -542,8 +559,12 @@ static void snapshot_dtr(struct dm_target *ti)
 {
         struct dm_snapshot *s = (struct dm_snapshot *) ti->private;
 
+        /* Prevent further origin writes from using this snapshot. */
+        /* After this returns there can be no new kcopyd jobs. */
         unregister_snapshot(s);
 
+        kcopyd_client_destroy(s->kcopyd_client);
+
         exit_exception_table(&s->pending, pending_cache);
         exit_exception_table(&s->complete, exception_cache);
 
@@ -552,7 +573,7 @@ static void snapshot_dtr(struct dm_target *ti)
 
         dm_put_device(ti, s->origin);
         dm_put_device(ti, s->cow);
-        kcopyd_client_destroy(s->kcopyd_client);
+
         kfree(s);
 }
 
@@ -586,78 +607,117 @@ static void error_bios(struct bio *bio)
         }
 }
 
+static inline void error_snapshot_bios(struct pending_exception *pe)
+{
+        error_bios(bio_list_get(&pe->snapshot_bios));
+}
+
 static struct bio *__flush_bios(struct pending_exception *pe)
 {
-        struct pending_exception *sibling;
+        /*
+         * If this pe is involved in a write to the origin and
+         * it is the last sibling to complete then release
+         * the bios for the original write to the origin.
+         */
+
+        if (pe->primary_pe &&
+            atomic_dec_and_test(&pe->primary_pe->sibling_count))
+                return bio_list_get(&pe->primary_pe->origin_bios);
+
+        return NULL;
+}
+
+static void __invalidate_snapshot(struct dm_snapshot *s,
+                                struct pending_exception *pe, int err)
+{
+        if (!s->valid)
+                return;
 
-        if (list_empty(&pe->siblings))
-                return bio_list_get(&pe->origin_bios);
+        if (err == -EIO)
+                DMERR("Invalidating snapshot: Error reading/writing.");
+        else if (err == -ENOMEM)
+                DMERR("Invalidating snapshot: Unable to allocate exception.");
 
-        sibling = list_entry(pe->siblings.next,
-                             struct pending_exception, siblings);
+        if (pe)
+                remove_exception(&pe->e);
 
-        list_del(&pe->siblings);
+        if (s->store.drop_snapshot)
+                s->store.drop_snapshot(&s->store);
 
-        /* This is fine as long as kcopyd is single-threaded. If kcopyd
-         * becomes multi-threaded, we'll need some locking here.
-         */
-        bio_list_merge(&sibling->origin_bios, &pe->origin_bios);
+        s->valid = 0;
 
-        return NULL;
+        dm_table_event(s->table);
 }
 
 static void pending_complete(struct pending_exception *pe, int success)
 {
         struct exception *e;
+        struct pending_exception *primary_pe;
         struct dm_snapshot *s = pe->snap;
         struct bio *flush = NULL;
 
-        if (success) {
-                e = alloc_exception();
-                if (!e) {
-                        DMWARN("Unable to allocate exception.");
-                        down_write(&s->lock);
-                        s->store.drop_snapshot(&s->store);
-                        s->valid = 0;
-                        flush = __flush_bios(pe);
-                        up_write(&s->lock);
-
-                        error_bios(bio_list_get(&pe->snapshot_bios));
-                        goto out;
-                }
-                *e = pe->e;
-
-                /*
-                 * Add a proper exception, and remove the
-                 * in-flight exception from the list.
-                 */
+        if (!success) {
+                /* Read/write error - snapshot is unusable */
                 down_write(&s->lock);
-                insert_exception(&s->complete, e);
-                remove_exception(&pe->e);
+                __invalidate_snapshot(s, pe, -EIO);
                 flush = __flush_bios(pe);
-
-                /* Submit any pending write bios */
                 up_write(&s->lock);
 
-                flush_bios(bio_list_get(&pe->snapshot_bios));
-        } else {
-                /* Read/write error - snapshot is unusable */
+                error_snapshot_bios(pe);
+                goto out;
+        }
+
+        e = alloc_exception();
+        if (!e) {
                 down_write(&s->lock);
-                if (s->valid)
-                        DMERR("Error reading/writing snapshot");
-                s->store.drop_snapshot(&s->store);
-                s->valid = 0;
-                remove_exception(&pe->e);
+                __invalidate_snapshot(s, pe, -ENOMEM);
                 flush = __flush_bios(pe);
                 up_write(&s->lock);
 
-                error_bios(bio_list_get(&pe->snapshot_bios));
+                error_snapshot_bios(pe);
+                goto out;
+        }
+        *e = pe->e;
 
-                dm_table_event(s->table);
+        /*
+         * Add a proper exception, and remove the
+         * in-flight exception from the list.
+         */
+        down_write(&s->lock);
+        if (!s->valid) {
+                flush = __flush_bios(pe);
+                up_write(&s->lock);
+
+                free_exception(e);
+
+                error_snapshot_bios(pe);
+                goto out;
         }
 
+        insert_exception(&s->complete, e);
+        remove_exception(&pe->e);
+        flush = __flush_bios(pe);
+
+        up_write(&s->lock);
+
+        /* Submit any pending write bios */
+        flush_bios(bio_list_get(&pe->snapshot_bios));
+
  out:
-        free_pending_exception(pe);
+        primary_pe = pe->primary_pe;
+
+        /*
+         * Free the pe if it's not linked to an origin write or if
+         * it's not itself a primary pe.
+         */
+        if (!primary_pe || primary_pe != pe)
+                free_pending_exception(pe);
+
+        /*
+         * Free the primary pe if nothing references it.
+         */
+        if (primary_pe && !atomic_read(&primary_pe->sibling_count))
+                free_pending_exception(primary_pe);
 
         if (flush)
                 flush_bios(flush);
@@ -734,38 +794,45 @@ __find_pending_exception(struct dm_snapshot *s, struct bio *bio)
         if (e) {
                 /* cast the exception to a pending exception */
                 pe = container_of(e, struct pending_exception, e);
+                goto out;
+        }
 
-        } else {
-                /*
-                 * Create a new pending exception, we don't want
-                 * to hold the lock while we do this.
-                 */
-                up_write(&s->lock);
-                pe = alloc_pending_exception();
-                down_write(&s->lock);
+        /*
+         * Create a new pending exception, we don't want
+         * to hold the lock while we do this.
+         */
+        up_write(&s->lock);
+        pe = alloc_pending_exception();
+        down_write(&s->lock);
 
-                e = lookup_exception(&s->pending, chunk);
-                if (e) {
-                        free_pending_exception(pe);
-                        pe = container_of(e, struct pending_exception, e);
-                } else {
-                        pe->e.old_chunk = chunk;
-                        bio_list_init(&pe->origin_bios);
-                        bio_list_init(&pe->snapshot_bios);
-                        INIT_LIST_HEAD(&pe->siblings);
-                        pe->snap = s;
-                        pe->started = 0;
-
-                        if (s->store.prepare_exception(&s->store, &pe->e)) {
-                                free_pending_exception(pe);
-                                s->valid = 0;
-                                return NULL;
-                        }
+        if (!s->valid) {
+                free_pending_exception(pe);
+                return NULL;
+        }
 
-                        insert_exception(&s->pending, &pe->e);
-                }
+        e = lookup_exception(&s->pending, chunk);
+        if (e) {
+                free_pending_exception(pe);
+                pe = container_of(e, struct pending_exception, e);
+                goto out;
+        }
+
+        pe->e.old_chunk = chunk;
+        bio_list_init(&pe->origin_bios);
+        bio_list_init(&pe->snapshot_bios);
+        pe->primary_pe = NULL;
+        atomic_set(&pe->sibling_count, 1);
+        pe->snap = s;
+        pe->started = 0;
+
+        if (s->store.prepare_exception(&s->store, &pe->e)) {
+                free_pending_exception(pe);
+                return NULL;
         }
 
+        insert_exception(&s->pending, &pe->e);
+
+ out:
         return pe;
 }
 
@@ -782,13 +849,15 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
 {
         struct exception *e;
         struct dm_snapshot *s = (struct dm_snapshot *) ti->private;
+        int copy_needed = 0;
         int r = 1;
         chunk_t chunk;
-        struct pending_exception *pe;
+        struct pending_exception *pe = NULL;
 
         chunk = sector_to_chunk(s, bio->bi_sector);
 
         /* Full snapshots are not usable */
+        /* To get here the table must be live so s->active is always set. */
         if (!s->valid)
                 return -EIO;
 
@@ -806,36 +875,41 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
                  * to copy an exception */
                 down_write(&s->lock);
 
+                if (!s->valid) {
+                        r = -EIO;
+                        goto out_unlock;
+                }
+
                 /* If the block is already remapped - use that, else remap it */
                 e = lookup_exception(&s->complete, chunk);
                 if (e) {
                         remap_exception(s, e, bio);
-                        up_write(&s->lock);
-
-                } else {
-                        pe = __find_pending_exception(s, bio);
-
-                        if (!pe) {
-                                if (s->store.drop_snapshot)
-                                        s->store.drop_snapshot(&s->store);
-                                s->valid = 0;
-                                r = -EIO;
-                                up_write(&s->lock);
-                        } else {
-                                remap_exception(s, &pe->e, bio);
-                                bio_list_add(&pe->snapshot_bios, bio);
-
-                                if (!pe->started) {
-                                        /* this is protected by snap->lock */
-                                        pe->started = 1;
-                                        up_write(&s->lock);
-                                        start_copy(pe);
-                                } else
-                                        up_write(&s->lock);
-                                r = 0;
-                        }
+                        goto out_unlock;
+                }
+
+                pe = __find_pending_exception(s, bio);
+                if (!pe) {
+                        __invalidate_snapshot(s, pe, -ENOMEM);
+                        r = -EIO;
+                        goto out_unlock;
+                }
+
+                remap_exception(s, &pe->e, bio);
+                bio_list_add(&pe->snapshot_bios, bio);
+
+                if (!pe->started) {
+                        /* this is protected by snap->lock */
+                        pe->started = 1;
+                        copy_needed = 1;
                 }
 
+                r = 0;
+
+ out_unlock:
+                up_write(&s->lock);
+
+                if (copy_needed)
+                        start_copy(pe);
         } else {
                 /*
                  * FIXME: this read path scares me because we
@@ -847,6 +921,11 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
                 /* Do reads */
                 down_read(&s->lock);
 
+                if (!s->valid) {
+                        up_read(&s->lock);
+                        return -EIO;
+                }
+
                 /* See if it it has been remapped */
                 e = lookup_exception(&s->complete, chunk);
                 if (e)
@@ -884,9 +963,9 @@ static int snapshot_status(struct dm_target *ti, status_type_t type,
                                 snap->store.fraction_full(&snap->store,
                                                           &numerator,
                                                           &denominator);
-                                snprintf(result, maxlen,
-                                         SECTOR_FORMAT "/" SECTOR_FORMAT,
-                                         numerator, denominator);
+                                snprintf(result, maxlen, "%llu/%llu",
+                                        (unsigned long long)numerator,
+                                        (unsigned long long)denominator);
                         }
                         else
                                 snprintf(result, maxlen, "Unknown");
@@ -899,9 +978,10 @@ static int snapshot_status(struct dm_target *ti, status_type_t type,
                  * to make private copies if the output is to
                  * make sense.
                  */
-                snprintf(result, maxlen, "%s %s %c " SECTOR_FORMAT,
+                snprintf(result, maxlen, "%s %s %c %llu",
                          snap->origin->name, snap->cow->name,
-                         snap->type, snap->chunk_size);
+                         snap->type,
+                         (unsigned long long)snap->chunk_size);
                 break;
         }
 
@@ -911,40 +991,27 @@ static int snapshot_status(struct dm_target *ti, status_type_t type,
 /*-----------------------------------------------------------------
  * Origin methods
  *---------------------------------------------------------------*/
-static void list_merge(struct list_head *l1, struct list_head *l2)
-{
-        struct list_head *l1_n, *l2_p;
-
-        l1_n = l1->next;
-        l2_p = l2->prev;
-
-        l1->next = l2;
-        l2->prev = l1;
-
-        l2_p->next = l1_n;
-        l1_n->prev = l2_p;
-}
-
 static int __origin_write(struct list_head *snapshots, struct bio *bio)
 {
-        int r = 1, first = 1;
+        int r = 1, first = 0;
         struct dm_snapshot *snap;
         struct exception *e;
-        struct pending_exception *pe, *last = NULL;
+        struct pending_exception *pe, *next_pe, *primary_pe = NULL;
         chunk_t chunk;
+        LIST_HEAD(pe_queue);
 
         /* Do all the snapshots on this origin */
         list_for_each_entry (snap, snapshots, list) {
 
+                down_write(&snap->lock);
+
                 /* Only deal with valid and active snapshots */
                 if (!snap->valid || !snap->active)
-                        continue;
+                        goto next_snapshot;
 
                 /* Nothing to do if writing beyond end of snapshot */
                 if (bio->bi_sector >= dm_table_get_size(snap->table))
-                        continue;
-
-                down_write(&snap->lock);
+                        goto next_snapshot;
 
                 /*
                  * Remember, different snapshots can have
@@ -956,49 +1023,75 @@ static int __origin_write(struct list_head *snapshots, struct bio *bio)
                  * Check exception table to see if block
                  * is already remapped in this snapshot
                  * and trigger an exception if not.
+                 *
+                 * sibling_count is initialised to 1 so pending_complete()
+                 * won't destroy the primary_pe while we're inside this loop.
                  */
                 e = lookup_exception(&snap->complete, chunk);
-                if (!e) {
-                        pe = __find_pending_exception(snap, bio);
-                        if (!pe) {
-                                snap->store.drop_snapshot(&snap->store);
-                                snap->valid = 0;
-
-                        } else {
-                                if (last)
-                                        list_merge(&pe->siblings,
-                                                   &last->siblings);
-
-                                last = pe;
-                                r = 0;
+                if (e)
+                        goto next_snapshot;
+
+                pe = __find_pending_exception(snap, bio);
+                if (!pe) {
+                        __invalidate_snapshot(snap, pe, ENOMEM);
+                        goto next_snapshot;
+                }
+
+                if (!primary_pe) {
+                        /*
+                         * Either every pe here has same
+                         * primary_pe or none has one yet.
+                         */
+                        if (pe->primary_pe)
+                                primary_pe = pe->primary_pe;
+                        else {
+                                primary_pe = pe;
+                                first = 1;
                         }
+
+                        bio_list_add(&primary_pe->origin_bios, bio);
+
+                        r = 0;
+                }
+
+                if (!pe->primary_pe) {
+                        atomic_inc(&primary_pe->sibling_count);
+                        pe->primary_pe = primary_pe;
+                }
+
+                if (!pe->started) {
+                        pe->started = 1;
+                        list_add_tail(&pe->list, &pe_queue);
                 }
 
+ next_snapshot:
                 up_write(&snap->lock);
         }
 
+        if (!primary_pe)
+                goto out;
+
         /*
-         * Now that we have a complete pe list we can start the copying.
+         * If this is the first time we're processing this chunk and
+         * sibling_count is now 1 it means all the pending exceptions
+         * got completed while we were in the loop above, so it falls to
+         * us here to remove the primary_pe and submit any origin_bios.
          */
-        if (last) {
-                pe = last;
-                do {
-                        down_write(&pe->snap->lock);
-                        if (first)
-                                bio_list_add(&pe->origin_bios, bio);
-                        if (!pe->started) {
-                                pe->started = 1;
-                                up_write(&pe->snap->lock);
-                                start_copy(pe);
-                        } else
-                                up_write(&pe->snap->lock);
-                        first = 0;
-                        pe = list_entry(pe->siblings.next,
-                                        struct pending_exception, siblings);
-
-                } while (pe != last);
+
+        if (first && atomic_dec_and_test(&primary_pe->sibling_count)) {
+                flush_bios(bio_list_get(&primary_pe->origin_bios));
+                free_pending_exception(primary_pe);
+                /* If we got here, pe_queue is necessarily empty. */
+                goto out;
         }
 
+        /*
+         * Now that we have a complete pe list we can start the copying.
+         */
+        list_for_each_entry_safe(pe, next_pe, &pe_queue, list)
+                start_copy(pe);
+
+ out:
         return r;
 }
 
diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index 697aacafb02a..08328a8f5a3c 100644
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -49,9 +49,9 @@ static inline struct stripe_c *alloc_context(unsigned int stripes)
 static int get_stripe(struct dm_target *ti, struct stripe_c *sc,
                       unsigned int stripe, char **argv)
 {
-        sector_t start;
+        unsigned long long start;
 
-        if (sscanf(argv[1], SECTOR_FORMAT, &start) != 1)
+        if (sscanf(argv[1], "%llu", &start) != 1)
                 return -EINVAL;
 
         if (dm_get_device(ti, argv[0], start, sc->stripe_width,
@@ -103,7 +103,7 @@ static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 return -EINVAL;
         }
 
-        if (((uint32_t)ti->len) & (chunk_size - 1)) {
+        if (ti->len & (chunk_size - 1)) {
                 ti->error = "dm-stripe: Target length not divisible by "
                     "chunk size";
                 return -EINVAL;
@@ -201,10 +201,11 @@ static int stripe_status(struct dm_target *ti,
                 break;
 
         case STATUSTYPE_TABLE:
-                DMEMIT("%d " SECTOR_FORMAT, sc->stripes, sc->chunk_mask + 1);
+                DMEMIT("%d %llu", sc->stripes,
+                        (unsigned long long)sc->chunk_mask + 1);
                 for (i = 0; i < sc->stripes; i++)
-                        DMEMIT(" %s " SECTOR_FORMAT, sc->stripe[i].dev->name,
-                               sc->stripe[i].physical_start);
+                        DMEMIT(" %s %llu", sc->stripe[i].dev->name,
+                            (unsigned long long)sc->stripe[i].physical_start);
                 break;
         }
         return 0;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 907b08ddb783..8f56a54cf0ce 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -14,6 +14,7 @@
 #include <linux/ctype.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
+#include <linux/mutex.h>
 #include <asm/atomic.h>
 
 #define MAX_DEPTH 16
@@ -22,6 +23,7 @@
 #define CHILDREN_PER_NODE (KEYS_PER_NODE + 1)
 
 struct dm_table {
+        struct mapped_device *md;
         atomic_t holders;
 
         /* btree table */
@@ -97,6 +99,8 @@ static void combine_restrictions_low(struct io_restrictions *lhs,
 
         lhs->seg_boundary_mask =
                 min_not_zero(lhs->seg_boundary_mask, rhs->seg_boundary_mask);
+
+        lhs->no_cluster |= rhs->no_cluster;
 }
 
 /*
@@ -204,7 +208,8 @@ static int alloc_targets(struct dm_table *t, unsigned int num)
         return 0;
 }
 
-int dm_table_create(struct dm_table **result, int mode, unsigned num_targets)
+int dm_table_create(struct dm_table **result, int mode,
+                    unsigned num_targets, struct mapped_device *md)
 {
         struct dm_table *t = kmalloc(sizeof(*t), GFP_KERNEL);
 
@@ -227,6 +232,7 @@ int dm_table_create(struct dm_table **result, int mode, unsigned num_targets)
         }
 
         t->mode = mode;
+        t->md = md;
         *result = t;
         return 0;
 }
@@ -345,7 +351,7 @@ static struct dm_dev *find_device(struct list_head *l, dev_t dev)
 /*
  * Open a device so we can use it as a map destination.
  */
-static int open_dev(struct dm_dev *d, dev_t dev)
+static int open_dev(struct dm_dev *d, dev_t dev, struct mapped_device *md)
 {
         static char *_claim_ptr = "I belong to device-mapper";
         struct block_device *bdev;
@@ -357,7 +363,7 @@ static int open_dev(struct dm_dev *d, dev_t dev)
         bdev = open_by_devnum(dev, d->mode);
         if (IS_ERR(bdev))
                 return PTR_ERR(bdev);
-        r = bd_claim(bdev, _claim_ptr);
+        r = bd_claim_by_disk(bdev, _claim_ptr, dm_disk(md));
         if (r)
                 blkdev_put(bdev);
         else
@@ -368,12 +374,12 @@ static int open_dev(struct dm_dev *d, dev_t dev)
 /*
  * Close a device that we've been using.
  */
-static void close_dev(struct dm_dev *d)
+static void close_dev(struct dm_dev *d, struct mapped_device *md)
 {
         if (!d->bdev)
                 return;
 
-        bd_release(d->bdev);
+        bd_release_from_disk(d->bdev, dm_disk(md));
         blkdev_put(d->bdev);
         d->bdev = NULL;
 }
@@ -394,7 +400,7 @@ static int check_device_area(struct dm_dev *dd, sector_t start, sector_t len)
  * careful to leave things as they were if we fail to reopen the
  * device.
  */
-static int upgrade_mode(struct dm_dev *dd, int new_mode)
+static int upgrade_mode(struct dm_dev *dd, int new_mode, struct mapped_device *md)
 {
         int r;
         struct dm_dev dd_copy;
@@ -404,9 +410,9 @@ static int upgrade_mode(struct dm_dev *dd, int new_mode)
 
         dd->mode |= new_mode;
         dd->bdev = NULL;
-        r = open_dev(dd, dev);
+        r = open_dev(dd, dev, md);
         if (!r)
-                close_dev(&dd_copy);
+                close_dev(&dd_copy, md);
         else
                 *dd = dd_copy;
 
@@ -448,7 +454,7 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
                 dd->mode = mode;
                 dd->bdev = NULL;
 
-                if ((r = open_dev(dd, dev))) {
+                if ((r = open_dev(dd, dev, t->md))) {
                         kfree(dd);
                         return r;
                 }
@@ -459,7 +465,7 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
                 list_add(&dd->list, &t->devices);
 
         } else if (dd->mode != (mode | dd->mode)) {
-                r = upgrade_mode(dd, mode);
+                r = upgrade_mode(dd, mode, t->md);
                 if (r)
                         return r;
         }
@@ -523,6 +529,8 @@ int dm_get_device(struct dm_target *ti, const char *path, sector_t start,
                 rs->seg_boundary_mask =
                         min_not_zero(rs->seg_boundary_mask,
                                      q->seg_boundary_mask);
+
+                rs->no_cluster |= !test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
         }
 
         return r;
@@ -534,7 +542,7 @@ int dm_get_device(struct dm_target *ti, const char *path, sector_t start,
 void dm_put_device(struct dm_target *ti, struct dm_dev *dd)
 {
         if (atomic_dec_and_test(&dd->count)) {
-                close_dev(dd);
+                close_dev(dd, ti->table->md);
                 list_del(&dd->list);
                 kfree(dd);
         }
@@ -763,14 +771,14 @@ int dm_table_complete(struct dm_table *t)
         return r;
 }
 
-static DECLARE_MUTEX(_event_lock);
+static DEFINE_MUTEX(_event_lock);
 void dm_table_event_callback(struct dm_table *t,
                              void (*fn)(void *), void *context)
 {
-        down(&_event_lock);
+        mutex_lock(&_event_lock);
         t->event_fn = fn;
         t->event_context = context;
-        up(&_event_lock);
+        mutex_unlock(&_event_lock);
 }
 
 void dm_table_event(struct dm_table *t)
@@ -781,10 +789,10 @@ void dm_table_event(struct dm_table *t)
          */
         BUG_ON(in_interrupt());
 
-        down(&_event_lock);
+        mutex_lock(&_event_lock);
         if (t->event_fn)
                 t->event_fn(t->event_context);
-        up(&_event_lock);
+        mutex_unlock(&_event_lock);
 }
 
 sector_t dm_table_get_size(struct dm_table *t)
@@ -832,6 +840,11 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q)
         q->hardsect_size = t->limits.hardsect_size;
         q->max_segment_size = t->limits.max_segment_size;
         q->seg_boundary_mask = t->limits.seg_boundary_mask;
+        if (t->limits.no_cluster)
+                q->queue_flags &= ~(1 << QUEUE_FLAG_CLUSTER);
+        else
+                q->queue_flags |= (1 << QUEUE_FLAG_CLUSTER);
+
 }
 
 unsigned int dm_table_get_num_targets(struct dm_table *t)
@@ -943,12 +956,20 @@ int dm_table_flush_all(struct dm_table *t)
         return ret;
 }
 
+struct mapped_device *dm_table_get_md(struct dm_table *t)
+{
+        dm_get(t->md);
+
+        return t->md;
+}
+
 EXPORT_SYMBOL(dm_vcalloc);
 EXPORT_SYMBOL(dm_get_device);
 EXPORT_SYMBOL(dm_put_device);
 EXPORT_SYMBOL(dm_table_event);
 EXPORT_SYMBOL(dm_table_get_size);
 EXPORT_SYMBOL(dm_table_get_mode);
+EXPORT_SYMBOL(dm_table_get_md);
 EXPORT_SYMBOL(dm_table_put);
 EXPORT_SYMBOL(dm_table_get);
 EXPORT_SYMBOL(dm_table_unplug_all);
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index a64798ef481e..4d710b7a133b 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -10,6 +10,7 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 #include <linux/moduleparam.h>
 #include <linux/blkpg.h>
 #include <linux/bio.h>
@@ -17,6 +18,7 @@
 #include <linux/mempool.h>
 #include <linux/slab.h>
 #include <linux/idr.h>
+#include <linux/hdreg.h>
 #include <linux/blktrace_api.h>
 
 static const char *_name = DM_NAME;
@@ -69,6 +71,7 @@ struct mapped_device {
 
         request_queue_t *queue;
         struct gendisk *disk;
+        char name[16];
 
         void *interface_ptr;
 
@@ -101,6 +104,9 @@ struct mapped_device {
          */
         struct super_block *frozen_sb;
         struct block_device *suspended_bdev;
+
+        /* forced geometry settings */
+        struct hd_geometry geometry;
 };
 
 #define MIN_IOS 256
@@ -226,6 +232,13 @@ static int dm_blk_close(struct inode *inode, struct file *file)
         return 0;
 }
 
+static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
+{
+        struct mapped_device *md = bdev->bd_disk->private_data;
+
+        return dm_get_geometry(md, geo);
+}
+
 static inline struct dm_io *alloc_io(struct mapped_device *md)
 {
         return mempool_alloc(md->io_pool, GFP_NOIO);
@@ -312,6 +325,33 @@ struct dm_table *dm_get_table(struct mapped_device *md)
         return t;
 }
 
+/*
+ * Get the geometry associated with a dm device
+ */
+int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo)
+{
+        *geo = md->geometry;
+
+        return 0;
+}
+
+/*
+ * Set the geometry of a device.
+ */
+int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo)
+{
+        sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors;
+
+        if (geo->start > sz) {
+                DMWARN("Start sector is beyond the geometry limits.");
+                return -EINVAL;
+        }
+
+        md->geometry = *geo;
+
+        return 0;
+}
+
 /*-----------------------------------------------------------------
  * CRUD START:
  *   A more elegant soln is in the works that uses the queue
@@ -704,14 +744,14 @@ static int dm_any_congested(void *congested_data, int bdi_bits)
 /*-----------------------------------------------------------------
  * An IDR is used to keep track of allocated minor numbers.
  *---------------------------------------------------------------*/
-static DECLARE_MUTEX(_minor_lock);
+static DEFINE_MUTEX(_minor_lock);
 static DEFINE_IDR(_minor_idr);
 
 static void free_minor(unsigned int minor)
 {
-        down(&_minor_lock);
+        mutex_lock(&_minor_lock);
         idr_remove(&_minor_idr, minor);
-        up(&_minor_lock);
+        mutex_unlock(&_minor_lock);
 }
 
 /*
@@ -724,7 +764,7 @@ static int specific_minor(struct mapped_device *md, unsigned int minor)
         if (minor >= (1 << MINORBITS))
                 return -EINVAL;
 
-        down(&_minor_lock);
+        mutex_lock(&_minor_lock);
 
         if (idr_find(&_minor_idr, minor)) {
                 r = -EBUSY;
@@ -749,7 +789,7 @@ static int specific_minor(struct mapped_device *md, unsigned int minor)
         }
 
 out:
-        up(&_minor_lock);
+        mutex_unlock(&_minor_lock);
         return r;
 }
 
@@ -758,7 +798,7 @@ static int next_free_minor(struct mapped_device *md, unsigned int *minor)
         int r;
         unsigned int m;
 
-        down(&_minor_lock);
+        mutex_lock(&_minor_lock);
 
         r = idr_pre_get(&_minor_idr, GFP_KERNEL);
         if (!r) {
@@ -780,7 +820,7 @@ static int next_free_minor(struct mapped_device *md, unsigned int *minor)
         *minor = m;
 
 out:
-        up(&_minor_lock);
+        mutex_unlock(&_minor_lock);
         return r;
 }
 
@@ -842,6 +882,7 @@ static struct mapped_device *alloc_dev(unsigned int minor, int persistent)
         md->disk->private_data = md;
         sprintf(md->disk->disk_name, "dm-%d", minor);
         add_disk(md->disk);
+        format_dev_t(md->name, MKDEV(_major, minor));
 
         atomic_set(&md->pending, 0);
         init_waitqueue_head(&md->wait);
@@ -904,6 +945,13 @@ static int __bind(struct mapped_device *md, struct dm_table *t)
         sector_t size;
 
         size = dm_table_get_size(t);
+
+        /*
+         * Wipe any geometry if the size of the table changed.
+         */
+        if (size != get_capacity(md->disk))
+                memset(&md->geometry, 0, sizeof(md->geometry));
+
         __set_size(md, size);
         if (size == 0)
                 return 0;
@@ -967,13 +1015,13 @@ static struct mapped_device *dm_find_md(dev_t dev)
         if (MAJOR(dev) != _major || minor >= (1 << MINORBITS))
                 return NULL;
 
-        down(&_minor_lock);
+        mutex_lock(&_minor_lock);
 
         md = idr_find(&_minor_idr, minor);
         if (!md || (dm_disk(md)->first_minor != minor))
                 md = NULL;
 
-        up(&_minor_lock);
+        mutex_unlock(&_minor_lock);
 
         return md;
 }
@@ -988,15 +1036,9 @@ struct mapped_device *dm_get_md(dev_t dev)
         return md;
 }
 
-void *dm_get_mdptr(dev_t dev)
+void *dm_get_mdptr(struct mapped_device *md)
 {
-        struct mapped_device *md;
-        void *mdptr = NULL;
-
-        md = dm_find_md(dev);
-        if (md)
-                mdptr = md->interface_ptr;
-        return mdptr;
+        return md->interface_ptr;
 }
 
 void dm_set_mdptr(struct mapped_device *md, void *ptr)
@@ -1011,18 +1053,18 @@ void dm_get(struct mapped_device *md)
 
 void dm_put(struct mapped_device *md)
 {
-        struct dm_table *map = dm_get_table(md);
+        struct dm_table *map;
 
         if (atomic_dec_and_test(&md->holders)) {
+                map = dm_get_table(md);
                 if (!dm_suspended(md)) {
                         dm_table_presuspend_targets(map);
                         dm_table_postsuspend_targets(map);
                 }
                 __unbind(md);
+                dm_table_put(map);
                 free_dev(md);
         }
-
-        dm_table_put(map);
 }
 
 /*
@@ -1107,6 +1149,7 @@ int dm_suspend(struct mapped_device *md, int do_lockfs)
 {
         struct dm_table *map = NULL;
         DECLARE_WAITQUEUE(wait, current);
+        struct bio *def;
         int r = -EINVAL;
 
         down(&md->suspend_lock);
@@ -1166,9 +1209,11 @@ int dm_suspend(struct mapped_device *md, int do_lockfs)
         /* were we interrupted ? */
         r = -EINTR;
         if (atomic_read(&md->pending)) {
+                clear_bit(DMF_BLOCK_IO, &md->flags);
+                def = bio_list_get(&md->deferred);
+                __flush_deferred_io(md, def);
                 up_write(&md->io_lock);
                 unlock_fs(md);
-                clear_bit(DMF_BLOCK_IO, &md->flags);
                 goto out;
         }
         up_write(&md->io_lock);
@@ -1262,6 +1307,7 @@ int dm_suspended(struct mapped_device *md)
 static struct block_device_operations dm_blk_dops = {
         .open = dm_blk_open,
         .release = dm_blk_close,
+        .getgeo = dm_blk_getgeo,
         .owner = THIS_MODULE
 };
 
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 4eaf075da217..fd90bc8f9e45 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -14,6 +14,7 @@
 #include <linux/device-mapper.h>
 #include <linux/list.h>
 #include <linux/blkdev.h>
+#include <linux/hdreg.h>
 
 #define DM_NAME "device-mapper"
 #define DMWARN(f, x...) printk(KERN_WARNING DM_NAME ": " f "\n" , ## x)
@@ -23,16 +24,6 @@
 #define DMEMIT(x...) sz += ((sz >= maxlen) ? \
                           0 : scnprintf(result + sz, maxlen - sz, x))
 
-/*
- * FIXME: I think this should be with the definition of sector_t
- * in types.h.
- */
-#ifdef CONFIG_LBD
-#define SECTOR_FORMAT "%llu"
-#else
-#define SECTOR_FORMAT "%lu"
-#endif
-
 #define SECTOR_SHIFT 9
 
 /*
@@ -57,7 +48,7 @@ struct mapped_device;
 int dm_create(struct mapped_device **md);
 int dm_create_with_minor(unsigned int minor, struct mapped_device **md);
 void dm_set_mdptr(struct mapped_device *md, void *ptr);
-void *dm_get_mdptr(dev_t dev);
+void *dm_get_mdptr(struct mapped_device *md);
 struct mapped_device *dm_get_md(dev_t dev);
 
 /*
@@ -95,11 +86,18 @@ int dm_wait_event(struct mapped_device *md, int event_nr);
 struct gendisk *dm_disk(struct mapped_device *md);
 int dm_suspended(struct mapped_device *md);
 
+/*
+ * Geometry functions.
+ */
+int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo);
+int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo);
+
 /*-----------------------------------------------------------------
  * Functions for manipulating a table.  Tables are also reference
  * counted.
  *---------------------------------------------------------------*/
-int dm_table_create(struct dm_table **result, int mode, unsigned num_targets);
+int dm_table_create(struct dm_table **result, int mode,
+                    unsigned num_targets, struct mapped_device *md);
 
 void dm_table_get(struct dm_table *t);
 void dm_table_put(struct dm_table *t);
@@ -117,6 +115,7 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q);
 unsigned int dm_table_get_num_targets(struct dm_table *t);
 struct list_head *dm_table_get_devices(struct dm_table *t);
 int dm_table_get_mode(struct dm_table *t);
+struct mapped_device *dm_table_get_md(struct dm_table *t);
 void dm_table_presuspend_targets(struct dm_table *t);
 void dm_table_postsuspend_targets(struct dm_table *t);
 void dm_table_resume_targets(struct dm_table *t);
diff --git a/drivers/md/kcopyd.c b/drivers/md/kcopyd.c
index 9dcb2c8a3853..72480a48d88b 100644
--- a/drivers/md/kcopyd.c
+++ b/drivers/md/kcopyd.c
@@ -22,6 +22,7 @@
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/workqueue.h>
+#include <linux/mutex.h>
 
 #include "kcopyd.h"
 
@@ -44,6 +45,9 @@ struct kcopyd_client {
         struct page_list *pages;
         unsigned int nr_pages;
         unsigned int nr_free_pages;
+
+        wait_queue_head_t destroyq;
+        atomic_t nr_jobs;
 };
 
 static struct page_list *alloc_pl(void)
@@ -292,10 +296,15 @@ static int run_complete_job(struct kcopyd_job *job)
         int read_err = job->read_err;
         unsigned int write_err = job->write_err;
         kcopyd_notify_fn fn = job->fn;
+        struct kcopyd_client *kc = job->kc;
 
-        kcopyd_put_pages(job->kc, job->pages);
+        kcopyd_put_pages(kc, job->pages);
         mempool_free(job, _job_pool);
         fn(read_err, write_err, context);
+
+        if (atomic_dec_and_test(&kc->nr_jobs))
+                wake_up(&kc->destroyq);
+
         return 0;
 }
 
@@ -430,6 +439,7 @@ static void do_work(void *ignored)
  */
 static void dispatch_job(struct kcopyd_job *job)
 {
+        atomic_inc(&job->kc->nr_jobs);
         push(&_pages_jobs, job);
         wake();
 }
@@ -572,21 +582,21 @@ int kcopyd_cancel(struct kcopyd_job *job, int block)
 /*-----------------------------------------------------------------
  * Unit setup
  *---------------------------------------------------------------*/
-static DECLARE_MUTEX(_client_lock);
+static DEFINE_MUTEX(_client_lock);
 static LIST_HEAD(_clients);
 
 static void client_add(struct kcopyd_client *kc)
 {
-        down(&_client_lock);
+        mutex_lock(&_client_lock);
         list_add(&kc->list, &_clients);
-        up(&_client_lock);
+        mutex_unlock(&_client_lock);
 }
 
 static void client_del(struct kcopyd_client *kc)
 {
-        down(&_client_lock);
+        mutex_lock(&_client_lock);
         list_del(&kc->list);
-        up(&_client_lock);
+        mutex_unlock(&_client_lock);
 }
 
 static DEFINE_MUTEX(kcopyd_init_lock);
@@ -669,6 +679,9 @@ int kcopyd_client_create(unsigned int nr_pages, struct kcopyd_client **result)
                 return r;
         }
 
+        init_waitqueue_head(&kc->destroyq);
+        atomic_set(&kc->nr_jobs, 0);
+
         client_add(kc);
         *result = kc;
         return 0;
@@ -676,6 +689,9 @@ int kcopyd_client_create(unsigned int nr_pages, struct kcopyd_client **result)
 
 void kcopyd_client_destroy(struct kcopyd_client *kc)
 {
+        /* Wait for completion of all jobs submitted by this client. */
+        wait_event(kc->destroyq, !atomic_read(&kc->nr_jobs));
+
         dm_io_put(kc->nr_pages);
         client_free_pages(kc);
         client_del(kc);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 5ed2228745cb..039e071c1007 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -43,6 +43,7 @@
 #include <linux/buffer_head.h> /* for invalidate_bdev */
 #include <linux/suspend.h>
 #include <linux/poll.h>
+#include <linux/mutex.h>
 
 #include <linux/init.h>
 
@@ -158,11 +159,12 @@ static int start_readonly;
  */
 static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
 static atomic_t md_event_count;
-static void md_new_event(mddev_t *mddev)
+void md_new_event(mddev_t *mddev)
 {
         atomic_inc(&md_event_count);
         wake_up(&md_event_waiters);
 }
+EXPORT_SYMBOL_GPL(md_new_event);
 
 /*
  * Enables to iterate over all existing md arrays
@@ -253,7 +255,7 @@ static mddev_t * mddev_find(dev_t unit)
         else
                 new->md_minor = MINOR(unit) >> MdpMinorShift;
 
-        init_MUTEX(&new->reconfig_sem);
+        mutex_init(&new->reconfig_mutex);
         INIT_LIST_HEAD(&new->disks);
         INIT_LIST_HEAD(&new->all_mddevs);
         init_timer(&new->safemode_timer);
@@ -266,6 +268,7 @@ static mddev_t * mddev_find(dev_t unit)
                 kfree(new);
                 return NULL;
         }
+        set_bit(QUEUE_FLAG_CLUSTER, &new->queue->queue_flags);
 
         blk_queue_make_request(new->queue, md_fail_request);
 
@@ -274,22 +277,22 @@ static mddev_t * mddev_find(dev_t unit)
 
 static inline int mddev_lock(mddev_t * mddev)
 {
-        return down_interruptible(&mddev->reconfig_sem);
+        return mutex_lock_interruptible(&mddev->reconfig_mutex);
 }
 
 static inline void mddev_lock_uninterruptible(mddev_t * mddev)
 {
-        down(&mddev->reconfig_sem);
+        mutex_lock(&mddev->reconfig_mutex);
 }
 
 static inline int mddev_trylock(mddev_t * mddev)
 {
-        return down_trylock(&mddev->reconfig_sem);
+        return mutex_trylock(&mddev->reconfig_mutex);
 }
 
 static inline void mddev_unlock(mddev_t * mddev)
 {
-        up(&mddev->reconfig_sem);
+        mutex_unlock(&mddev->reconfig_mutex);
 
         md_wakeup_thread(mddev->thread);
 }
@@ -660,7 +663,8 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
         }
 
         if (sb->major_version != 0 ||
-            sb->minor_version != 90) {
+            sb->minor_version < 90 ||
+            sb->minor_version > 91) {
                 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
                         sb->major_version, sb->minor_version,
                         b);
@@ -745,6 +749,20 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                 mddev->bitmap_offset = 0;
                 mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
 
+                if (mddev->minor_version >= 91) {
+                        mddev->reshape_position = sb->reshape_position;
+                        mddev->delta_disks = sb->delta_disks;
+                        mddev->new_level = sb->new_level;
+                        mddev->new_layout = sb->new_layout;
+                        mddev->new_chunk = sb->new_chunk;
+                } else {
+                        mddev->reshape_position = MaxSector;
+                        mddev->delta_disks = 0;
+                        mddev->new_level = mddev->level;
+                        mddev->new_layout = mddev->layout;
+                        mddev->new_chunk = mddev->chunk_size;
+                }
+
                 if (sb->state & (1<<MD_SB_CLEAN))
                         mddev->recovery_cp = MaxSector;
                 else {
@@ -764,7 +782,8 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
 
                 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
                     mddev->bitmap_file == NULL) {
-                        if (mddev->level != 1 && mddev->level != 5 && mddev->level != 6
+                        if (mddev->level != 1 && mddev->level != 4
+                            && mddev->level != 5 && mddev->level != 6
                             && mddev->level != 10) {
                                 /* FIXME use a better test */
                                 printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
@@ -838,7 +857,6 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
 
         sb->md_magic = MD_SB_MAGIC;
         sb->major_version = mddev->major_version;
-        sb->minor_version = mddev->minor_version;
         sb->patch_version = mddev->patch_version;
         sb->gvalid_words  = 0; /* ignored */
         memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
@@ -857,6 +875,17 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
         sb->events_hi = (mddev->events>>32);
         sb->events_lo = (u32)mddev->events;
 
+        if (mddev->reshape_position == MaxSector)
+                sb->minor_version = 90;
+        else {
+                sb->minor_version = 91;
+                sb->reshape_position = mddev->reshape_position;
+                sb->new_level = mddev->new_level;
+                sb->delta_disks = mddev->delta_disks;
+                sb->new_layout = mddev->new_layout;
+                sb->new_chunk = mddev->new_chunk;
+        }
+        mddev->minor_version = sb->minor_version;
         if (mddev->in_sync)
         {
                 sb->recovery_cp = mddev->recovery_cp;
@@ -893,10 +922,9 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
                         d->raid_disk = rdev2->raid_disk;
                 else
                         d->raid_disk = rdev2->desc_nr; /* compatibility */
-                if (test_bit(Faulty, &rdev2->flags)) {
+                if (test_bit(Faulty, &rdev2->flags))
                         d->state = (1<<MD_DISK_FAULTY);
-                        failed++;
-                } else if (test_bit(In_sync, &rdev2->flags)) {
+                else if (test_bit(In_sync, &rdev2->flags)) {
                         d->state = (1<<MD_DISK_ACTIVE);
                         d->state |= (1<<MD_DISK_SYNC);
                         active++;
@@ -1102,6 +1130,20 @@ static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                         }
                         mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
                 }
+                if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
+                        mddev->reshape_position = le64_to_cpu(sb->reshape_position);
+                        mddev->delta_disks = le32_to_cpu(sb->delta_disks);
+                        mddev->new_level = le32_to_cpu(sb->new_level);
+                        mddev->new_layout = le32_to_cpu(sb->new_layout);
+                        mddev->new_chunk = le32_to_cpu(sb->new_chunk)<<9;
+                } else {
+                        mddev->reshape_position = MaxSector;
+                        mddev->delta_disks = 0;
+                        mddev->new_level = mddev->level;
+                        mddev->new_layout = mddev->layout;
+                        mddev->new_chunk = mddev->chunk_size;
+                }
+
         } else if (mddev->pers == NULL) {
                 /* Insist of good event counter while assembling */
                 __u64 ev1 = le64_to_cpu(sb->events);
@@ -1173,6 +1215,14 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
                 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
                 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
         }
+        if (mddev->reshape_position != MaxSector) {
+                sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
+                sb->reshape_position = cpu_to_le64(mddev->reshape_position);
+                sb->new_layout = cpu_to_le32(mddev->new_layout);
+                sb->delta_disks = cpu_to_le32(mddev->delta_disks);
+                sb->new_level = cpu_to_le32(mddev->new_level);
+                sb->new_chunk = cpu_to_le32(mddev->new_chunk>>9);
+        }
 
         max_dev = 0;
         ITERATE_RDEV(mddev,rdev2,tmp)
@@ -1301,6 +1351,7 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
         else
                 ko = &rdev->bdev->bd_disk->kobj;
         sysfs_create_link(&rdev->kobj, ko, "block");
+        bd_claim_by_disk(rdev->bdev, rdev, mddev->gendisk);
         return 0;
 }
 
@@ -1311,6 +1362,7 @@ static void unbind_rdev_from_array(mdk_rdev_t * rdev)
                 MD_BUG();
                 return;
         }
+        bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
         list_del_init(&rdev->same_set);
         printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
         rdev->mddev = NULL;
@@ -1493,7 +1545,7 @@ static void sync_sbs(mddev_t * mddev)
         }
 }
 
-static void md_update_sb(mddev_t * mddev)
+void md_update_sb(mddev_t * mddev)
 {
         int err;
         struct list_head *tmp;
@@ -1570,6 +1622,7 @@ repeat:
         wake_up(&mddev->sb_wait);
 
 }
+EXPORT_SYMBOL_GPL(md_update_sb);
 
 /* words written to sysfs files may, or my not, be \n terminated.
  * We want to accept with case. For this we use cmd_match.
@@ -2162,7 +2215,9 @@ action_show(mddev_t *mddev, char *page)
         char *type = "idle";
         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
             test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) {
-                if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
+                if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
+                        type = "reshape";
+                else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
                         if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
                                 type = "resync";
                         else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
@@ -2193,7 +2248,14 @@ action_store(mddev_t *mddev, const char *page, size_t len)
                 return -EBUSY;
         else if (cmd_match(page, "resync") || cmd_match(page, "recover"))
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
-        else {
+        else if (cmd_match(page, "reshape")) {
+                int err;
+                if (mddev->pers->start_reshape == NULL)
+                        return -EINVAL;
+                err = mddev->pers->start_reshape(mddev);
+                if (err)
+                        return err;
+        } else {
                 if (cmd_match(page, "check"))
                         set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
                 else if (cmd_match(page, "repair"))
@@ -2304,6 +2366,63 @@ sync_completed_show(mddev_t *mddev, char *page)
 static struct md_sysfs_entry
 md_sync_completed = __ATTR_RO(sync_completed);
 
+static ssize_t
+suspend_lo_show(mddev_t *mddev, char *page)
+{
+        return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
+}
+
+static ssize_t
+suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
+{
+        char *e;
+        unsigned long long new = simple_strtoull(buf, &e, 10);
+
+        if (mddev->pers->quiesce == NULL)
+                return -EINVAL;
+        if (buf == e || (*e && *e != '\n'))
+                return -EINVAL;
+        if (new >= mddev->suspend_hi ||
+            (new > mddev->suspend_lo && new < mddev->suspend_hi)) {
+                mddev->suspend_lo = new;
+                mddev->pers->quiesce(mddev, 2);
+                return len;
+        } else
+                return -EINVAL;
+}
+static struct md_sysfs_entry md_suspend_lo =
+__ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
+
+
+static ssize_t
+suspend_hi_show(mddev_t *mddev, char *page)
+{
+        return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
+}
+
+static ssize_t
+suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
+{
+        char *e;
+        unsigned long long new = simple_strtoull(buf, &e, 10);
+
+        if (mddev->pers->quiesce == NULL)
+                return -EINVAL;
+        if (buf == e || (*e && *e != '\n'))
+                return -EINVAL;
+        if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) ||
+            (new > mddev->suspend_lo && new > mddev->suspend_hi)) {
+                mddev->suspend_hi = new;
+                mddev->pers->quiesce(mddev, 1);
+                mddev->pers->quiesce(mddev, 0);
+                return len;
+        } else
+                return -EINVAL;
+}
+static struct md_sysfs_entry md_suspend_hi =
+__ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
+
+
 static struct attribute *md_default_attrs[] = {
         &md_level.attr,
         &md_raid_disks.attr,
@@ -2321,6 +2440,8 @@ static struct attribute *md_redundancy_attrs[] = {
         &md_sync_max.attr,
         &md_sync_speed.attr,
         &md_sync_completed.attr,
+        &md_suspend_lo.attr,
+        &md_suspend_hi.attr,
         NULL,
 };
 static struct attribute_group md_redundancy_group = {
@@ -2380,7 +2501,7 @@ int mdp_major = 0;
 
 static struct kobject *md_probe(dev_t dev, int *part, void *data)
 {
-        static DECLARE_MUTEX(disks_sem);
+        static DEFINE_MUTEX(disks_mutex);
         mddev_t *mddev = mddev_find(dev);
         struct gendisk *disk;
         int partitioned = (MAJOR(dev) != MD_MAJOR);
@@ -2390,15 +2511,15 @@ static struct kobject *md_probe(dev_t dev, int *part, void *data)
         if (!mddev)
                 return NULL;
 
-        down(&disks_sem);
+        mutex_lock(&disks_mutex);
         if (mddev->gendisk) {
-                up(&disks_sem);
+                mutex_unlock(&disks_mutex);
                 mddev_put(mddev);
                 return NULL;
         }
         disk = alloc_disk(1 << shift);
         if (!disk) {
-                up(&disks_sem);
+                mutex_unlock(&disks_mutex);
                 mddev_put(mddev);
                 return NULL;
         }
@@ -2416,7 +2537,7 @@ static struct kobject *md_probe(dev_t dev, int *part, void *data)
         disk->queue = mddev->queue;
         add_disk(disk);
         mddev->gendisk = disk;
-        up(&disks_sem);
+        mutex_unlock(&disks_mutex);
         mddev->kobj.parent = &disk->kobj;
         mddev->kobj.k_name = NULL;
         snprintf(mddev->kobj.name, KOBJ_NAME_LEN, "%s", "md");
@@ -2539,6 +2660,14 @@ static int do_md_run(mddev_t * mddev)
         mddev->level = pers->level;
         strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
 
+        if (mddev->reshape_position != MaxSector &&
+            pers->start_reshape == NULL) {
+                /* This personality cannot handle reshaping... */
+                mddev->pers = NULL;
+                module_put(pers->owner);
+                return -EINVAL;
+        }
+
         mddev->recovery = 0;
         mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
         mddev->barriers_work = 1;
@@ -2772,7 +2901,6 @@ static void autorun_array(mddev_t *mddev)
  */
 static void autorun_devices(int part)
 {
-        struct list_head candidates;
         struct list_head *tmp;
         mdk_rdev_t *rdev0, *rdev;
         mddev_t *mddev;
@@ -2781,6 +2909,7 @@ static void autorun_devices(int part)
         printk(KERN_INFO "md: autorun ...\n");
         while (!list_empty(&pending_raid_disks)) {
                 dev_t dev;
+                LIST_HEAD(candidates);
                 rdev0 = list_entry(pending_raid_disks.next,
                                          mdk_rdev_t, same_set);
 
@@ -3427,11 +3556,18 @@ static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
         mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
         mddev->bitmap_offset = 0;
 
+        mddev->reshape_position = MaxSector;
+
         /*
          * Generate a 128 bit UUID
          */
         get_random_bytes(mddev->uuid, 16);
 
+        mddev->new_level = mddev->level;
+        mddev->new_chunk = mddev->chunk_size;
+        mddev->new_layout = mddev->layout;
+        mddev->delta_disks = 0;
+
         return 0;
 }
 
@@ -3440,6 +3576,7 @@ static int update_size(mddev_t *mddev, unsigned long size)
         mdk_rdev_t * rdev;
         int rv;
         struct list_head *tmp;
+        int fit = (size == 0);
 
         if (mddev->pers->resize == NULL)
                 return -EINVAL;
@@ -3457,7 +3594,6 @@ static int update_size(mddev_t *mddev, unsigned long size)
                 return -EBUSY;
         ITERATE_RDEV(mddev,rdev,tmp) {
                 sector_t avail;
-                int fit = (size == 0);
                 if (rdev->sb_offset > rdev->data_offset)
                         avail = (rdev->sb_offset*2) - rdev->data_offset;
                 else
@@ -3487,14 +3623,16 @@ static int update_raid_disks(mddev_t *mddev, int raid_disks)
 {
         int rv;
         /* change the number of raid disks */
-        if (mddev->pers->reshape == NULL)
+        if (mddev->pers->check_reshape == NULL)
                 return -EINVAL;
         if (raid_disks <= 0 ||
             raid_disks >= mddev->max_disks)
                 return -EINVAL;
-        if (mddev->sync_thread)
+        if (mddev->sync_thread || mddev->reshape_position != MaxSector)
                 return -EBUSY;
-        rv = mddev->pers->reshape(mddev, raid_disks);
+        mddev->delta_disks = raid_disks - mddev->raid_disks;
+
+        rv = mddev->pers->check_reshape(mddev);
         return rv;
 }
 
@@ -4041,7 +4179,10 @@ static void status_unused(struct seq_file *seq)
 
 static void status_resync(struct seq_file *seq, mddev_t * mddev)
 {
-        unsigned long max_blocks, resync, res, dt, db, rt;
+        sector_t max_blocks, resync, res;
+        unsigned long dt, db, rt;
+        int scale;
+        unsigned int per_milli;
 
         resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
 
@@ -4057,9 +4198,22 @@ static void status_resync(struct seq_file *seq, mddev_t * mddev)
                 MD_BUG();
                 return;
         }
-        res = (resync/1024)*1000/(max_blocks/1024 + 1);
+        /* Pick 'scale' such that (resync>>scale)*1000 will fit
+         * in a sector_t, and (max_blocks>>scale) will fit in a
+         * u32, as those are the requirements for sector_div.
+         * Thus 'scale' must be at least 10
+         */
+        scale = 10;
+        if (sizeof(sector_t) > sizeof(unsigned long)) {
+                while ( max_blocks/2 > (1ULL<<(scale+32)))
+                        scale++;
+        }
+        res = (resync>>scale)*1000;
+        sector_div(res, (u32)((max_blocks>>scale)+1));
+
+        per_milli = res;
         {
-                int i, x = res/50, y = 20-x;
+                int i, x = per_milli/50, y = 20-x;
                 seq_printf(seq, "[");
                 for (i = 0; i < x; i++)
                         seq_printf(seq, "=");
@@ -4068,10 +4222,14 @@ static void status_resync(struct seq_file *seq, mddev_t * mddev)
                         seq_printf(seq, ".");
                 seq_printf(seq, "] ");
         }
-        seq_printf(seq, " %s =%3lu.%lu%% (%lu/%lu)",
+        seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
+                   (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
+                    "reshape" :
                       (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
-                       "resync" : "recovery"),
-                      res/10, res % 10, resync, max_blocks);
+                       "resync" : "recovery")),
+                      per_milli/10, per_milli % 10,
+                   (unsigned long long) resync,
+                   (unsigned long long) max_blocks);
 
         /*
          * We do not want to overflow, so the order of operands and
@@ -4085,7 +4243,7 @@ static void status_resync(struct seq_file *seq, mddev_t * mddev)
         dt = ((jiffies - mddev->resync_mark) / HZ);
         if (!dt) dt++;
         db = resync - (mddev->resync_mark_cnt/2);
-        rt = (dt * ((max_blocks-resync) / (db/100+1)))/100;
+        rt = (dt * ((unsigned long)(max_blocks-resync) / (db/100+1)))/100;
 
         seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
 
@@ -4442,7 +4600,7 @@ static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
 
 #define SYNC_MARKS      10
 #define SYNC_MARK_STEP  (3*HZ)
-static void md_do_sync(mddev_t *mddev)
+void md_do_sync(mddev_t *mddev)
 {
         mddev_t *mddev2;
         unsigned int currspeed = 0,
@@ -4522,7 +4680,9 @@ static void md_do_sync(mddev_t *mddev)
                  */
                 max_sectors = mddev->resync_max_sectors;
                 mddev->resync_mismatches = 0;
-        } else
+        } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
+                max_sectors = mddev->size << 1;
+        else
                 /* recovery follows the physical size of devices */
                 max_sectors = mddev->size << 1;
 
@@ -4658,6 +4818,8 @@ static void md_do_sync(mddev_t *mddev)
         mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
 
         if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
+            test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
+            !test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
             mddev->curr_resync > 2 &&
             mddev->curr_resync >= mddev->recovery_cp) {
                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
@@ -4675,6 +4837,7 @@ static void md_do_sync(mddev_t *mddev)
         set_bit(MD_RECOVERY_DONE, &mddev->recovery);
         md_wakeup_thread(mddev->thread);
 }
+EXPORT_SYMBOL_GPL(md_do_sync);
 
 
 /*
@@ -4730,7 +4893,7 @@ void md_check_recovery(mddev_t *mddev)
                 ))
                 return;
 
-        if (mddev_trylock(mddev)==0) {
+        if (mddev_trylock(mddev)) {
                 int spares =0;
 
                 spin_lock_irq(&mddev->write_lock);
@@ -4866,7 +5029,7 @@ static int md_notify_reboot(struct notifier_block *this,
                 printk(KERN_INFO "md: stopping all md devices.\n");
 
                 ITERATE_MDDEV(mddev,tmp)
-                        if (mddev_trylock(mddev)==0)
+                        if (mddev_trylock(mddev))
                                 do_md_stop (mddev, 1);
                 /*
                  * certain more exotic SCSI devices are known to be
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 5d88329e3c7a..3cb0872a845d 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1402,6 +1402,9 @@ static void raid1d(mddev_t *mddev)
                         clear_bit(R1BIO_BarrierRetry, &r1_bio->state);
                         clear_bit(R1BIO_Barrier, &r1_bio->state);
                         for (i=0; i < conf->raid_disks; i++)
+                                if (r1_bio->bios[i])
+                                        atomic_inc(&r1_bio->remaining);
+                        for (i=0; i < conf->raid_disks; i++)
                                 if (r1_bio->bios[i]) {
                                         struct bio_vec *bvec;
                                         int j;
@@ -1789,6 +1792,11 @@ static int run(mddev_t *mddev)
                        mdname(mddev), mddev->level);
                 goto out;
         }
+        if (mddev->reshape_position != MaxSector) {
+                printk("raid1: %s: reshape_position set but not supported\n",
+                       mdname(mddev));
+                goto out;
+        }
         /*
          * copy the already verified devices into our private RAID1
          * bookkeeping area. [whatever we allocate in run(),
@@ -1971,7 +1979,7 @@ static int raid1_resize(mddev_t *mddev, sector_t sectors)
         return 0;
 }
 
-static int raid1_reshape(mddev_t *mddev, int raid_disks)
+static int raid1_reshape(mddev_t *mddev)
 {
         /* We need to:
          * 1/ resize the r1bio_pool
@@ -1988,10 +1996,22 @@ static int raid1_reshape(mddev_t *mddev, int raid_disks)
         struct pool_info *newpoolinfo;
         mirror_info_t *newmirrors;
         conf_t *conf = mddev_to_conf(mddev);
-        int cnt;
+        int cnt, raid_disks;
 
         int d, d2;
 
+        /* Cannot change chunk_size, layout, or level */
+        if (mddev->chunk_size != mddev->new_chunk ||
+            mddev->layout != mddev->new_layout ||
+            mddev->level != mddev->new_level) {
+                mddev->new_chunk = mddev->chunk_size;
+                mddev->new_layout = mddev->layout;
+                mddev->new_level = mddev->level;
+                return -EINVAL;
+        }
+
+        raid_disks = mddev->raid_disks + mddev->delta_disks;
+
         if (raid_disks < conf->raid_disks) {
                 cnt=0;
                 for (d= 0; d < conf->raid_disks; d++)
@@ -2038,6 +2058,7 @@ static int raid1_reshape(mddev_t *mddev, int raid_disks)
 
         mddev->degraded += (raid_disks - conf->raid_disks);
         conf->raid_disks = mddev->raid_disks = raid_disks;
+        mddev->delta_disks = 0;
 
         conf->last_used = 0; /* just make sure it is in-range */
         lower_barrier(conf);
@@ -2079,7 +2100,7 @@ static struct mdk_personality raid1_personality =
         .spare_active   = raid1_spare_active,
         .sync_request   = sync_request,
         .resize         = raid1_resize,
-        .reshape        = raid1_reshape,
+        .check_reshape  = raid1_reshape,
         .quiesce        = raid1_quiesce,
 };
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 2dba305daf3c..dae740adaf65 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -22,6 +22,7 @@
 #include <linux/raid/raid5.h>
 #include <linux/highmem.h>
 #include <linux/bitops.h>
+#include <linux/kthread.h>
 #include <asm/atomic.h>
 
 #include <linux/raid/bitmap.h>
@@ -93,11 +94,11 @@ static void __release_stripe(raid5_conf_t *conf, struct stripe_head *sh)
                                 if (atomic_read(&conf->preread_active_stripes) < IO_THRESHOLD)
                                         md_wakeup_thread(conf->mddev->thread);
                         }
-                        list_add_tail(&sh->lru, &conf->inactive_list);
                         atomic_dec(&conf->active_stripes);
-                        if (!conf->inactive_blocked ||
-                            atomic_read(&conf->active_stripes) < (conf->max_nr_stripes*3/4))
+                        if (!test_bit(STRIPE_EXPANDING, &sh->state)) {
+                                list_add_tail(&sh->lru, &conf->inactive_list);
                                 wake_up(&conf->wait_for_stripe);
+                        }
                 }
         }
 }
@@ -178,10 +179,10 @@ static int grow_buffers(struct stripe_head *sh, int num)
 
 static void raid5_build_block (struct stripe_head *sh, int i);
 
-static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
+static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx, int disks)
 {
         raid5_conf_t *conf = sh->raid_conf;
-        int disks = conf->raid_disks, i;
+        int i;
 
         if (atomic_read(&sh->count) != 0)
                 BUG();
@@ -198,7 +199,9 @@ static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
         sh->pd_idx = pd_idx;
         sh->state = 0;
 
-        for (i=disks; i--; ) {
+        sh->disks = disks;
+
+        for (i = sh->disks; i--; ) {
                 struct r5dev *dev = &sh->dev[i];
 
                 if (dev->toread || dev->towrite || dev->written ||
@@ -215,7 +218,7 @@ static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx)
         insert_hash(conf, sh);
 }
 
-static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector)
+static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector, int disks)
 {
         struct stripe_head *sh;
         struct hlist_node *hn;
@@ -223,7 +226,7 @@ static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector)
         CHECK_DEVLOCK();
         PRINTK("__find_stripe, sector %llu\n", (unsigned long long)sector);
         hlist_for_each_entry(sh, hn, stripe_hash(conf, sector), hash)
-                if (sh->sector == sector)
+                if (sh->sector == sector && sh->disks == disks)
                         return sh;
         PRINTK("__stripe %llu not in cache\n", (unsigned long long)sector);
         return NULL;
@@ -232,8 +235,8 @@ static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector)
 static void unplug_slaves(mddev_t *mddev);
 static void raid5_unplug_device(request_queue_t *q);
 
-static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector,
-                                             int pd_idx, int noblock) 
+static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector, int disks,
+                                             int pd_idx, int noblock)
 {
         struct stripe_head *sh;
 
@@ -245,7 +248,7 @@ static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector
                 wait_event_lock_irq(conf->wait_for_stripe,
                                     conf->quiesce == 0,
                                     conf->device_lock, /* nothing */);
-                sh = __find_stripe(conf, sector);
+                sh = __find_stripe(conf, sector, disks);
                 if (!sh) {
                         if (!conf->inactive_blocked)
                                 sh = get_free_stripe(conf);
@@ -259,11 +262,11 @@ static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector
                                                      < (conf->max_nr_stripes *3/4)
                                                      || !conf->inactive_blocked),
                                                     conf->device_lock,
-                                                    unplug_slaves(conf->mddev);
+                                                    unplug_slaves(conf->mddev)
                                         );
                                 conf->inactive_blocked = 0;
                         } else
-                                init_stripe(sh, sector, pd_idx);
+                                init_stripe(sh, sector, pd_idx, disks);
                 } else {
                         if (atomic_read(&sh->count)) {
                                 if (!list_empty(&sh->lru))
@@ -271,9 +274,8 @@ static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector
                         } else {
                                 if (!test_bit(STRIPE_HANDLE, &sh->state))
                                         atomic_inc(&conf->active_stripes);
-                                if (list_empty(&sh->lru))
-                                        BUG();
-                                list_del_init(&sh->lru);
+                                if (!list_empty(&sh->lru))
+                                        list_del_init(&sh->lru);
                         }
                 }
         } while (sh == NULL);
@@ -300,6 +302,7 @@ static int grow_one_stripe(raid5_conf_t *conf)
                 kmem_cache_free(conf->slab_cache, sh);
                 return 0;
         }
+        sh->disks = conf->raid_disks;
         /* we just created an active stripe so... */
         atomic_set(&sh->count, 1);
         atomic_inc(&conf->active_stripes);
@@ -313,14 +316,16 @@ static int grow_stripes(raid5_conf_t *conf, int num)
         kmem_cache_t *sc;
         int devs = conf->raid_disks;
 
-        sprintf(conf->cache_name, "raid5/%s", mdname(conf->mddev));
-
-        sc = kmem_cache_create(conf->cache_name, 
+        sprintf(conf->cache_name[0], "raid5/%s", mdname(conf->mddev));
+        sprintf(conf->cache_name[1], "raid5/%s-alt", mdname(conf->mddev));
+        conf->active_name = 0;
+        sc = kmem_cache_create(conf->cache_name[conf->active_name],
                                sizeof(struct stripe_head)+(devs-1)*sizeof(struct r5dev),
                                0, 0, NULL, NULL);
         if (!sc)
                 return 1;
         conf->slab_cache = sc;
+        conf->pool_size = devs;
         while (num--) {
                 if (!grow_one_stripe(conf))
                         return 1;
@@ -328,6 +333,129 @@ static int grow_stripes(raid5_conf_t *conf, int num)
         return 0;
 }
 
+#ifdef CONFIG_MD_RAID5_RESHAPE
+static int resize_stripes(raid5_conf_t *conf, int newsize)
+{
+        /* Make all the stripes able to hold 'newsize' devices.
+         * New slots in each stripe get 'page' set to a new page.
+         *
+         * This happens in stages:
+         * 1/ create a new kmem_cache and allocate the required number of
+         *    stripe_heads.
+         * 2/ gather all the old stripe_heads and tranfer the pages across
+         *    to the new stripe_heads.  This will have the side effect of
+         *    freezing the array as once all stripe_heads have been collected,
+         *    no IO will be possible.  Old stripe heads are freed once their
+         *    pages have been transferred over, and the old kmem_cache is
+         *    freed when all stripes are done.
+         * 3/ reallocate conf->disks to be suitable bigger.  If this fails,
+         *    we simple return a failre status - no need to clean anything up.
+         * 4/ allocate new pages for the new slots in the new stripe_heads.
+         *    If this fails, we don't bother trying the shrink the
+         *    stripe_heads down again, we just leave them as they are.
+         *    As each stripe_head is processed the new one is released into
+         *    active service.
+         *
+         * Once step2 is started, we cannot afford to wait for a write,
+         * so we use GFP_NOIO allocations.
+         */
+        struct stripe_head *osh, *nsh;
+        LIST_HEAD(newstripes);
+        struct disk_info *ndisks;
+        int err = 0;
+        kmem_cache_t *sc;
+        int i;
+
+        if (newsize <= conf->pool_size)
+                return 0; /* never bother to shrink */
+
+        /* Step 1 */
+        sc = kmem_cache_create(conf->cache_name[1-conf->active_name],
+                               sizeof(struct stripe_head)+(newsize-1)*sizeof(struct r5dev),
+                               0, 0, NULL, NULL);
+        if (!sc)
+                return -ENOMEM;
+
+        for (i = conf->max_nr_stripes; i; i--) {
+                nsh = kmem_cache_alloc(sc, GFP_KERNEL);
+                if (!nsh)
+                        break;
+
+                memset(nsh, 0, sizeof(*nsh) + (newsize-1)*sizeof(struct r5dev));
+
+                nsh->raid_conf = conf;
+                spin_lock_init(&nsh->lock);
+
+                list_add(&nsh->lru, &newstripes);
+        }
+        if (i) {
+                /* didn't get enough, give up */
+                while (!list_empty(&newstripes)) {
+                        nsh = list_entry(newstripes.next, struct stripe_head, lru);
+                        list_del(&nsh->lru);
+                        kmem_cache_free(sc, nsh);
+                }
+                kmem_cache_destroy(sc);
+                return -ENOMEM;
+        }
+        /* Step 2 - Must use GFP_NOIO now.
+         * OK, we have enough stripes, start collecting inactive
+         * stripes and copying them over
+         */
+        list_for_each_entry(nsh, &newstripes, lru) {
+                spin_lock_irq(&conf->device_lock);
+                wait_event_lock_irq(conf->wait_for_stripe,
+                                    !list_empty(&conf->inactive_list),
+                                    conf->device_lock,
+                                    unplug_slaves(conf->mddev)
+                        );
+                osh = get_free_stripe(conf);
+                spin_unlock_irq(&conf->device_lock);
+                atomic_set(&nsh->count, 1);
+                for(i=0; i<conf->pool_size; i++)
+                        nsh->dev[i].page = osh->dev[i].page;
+                for( ; i<newsize; i++)
+                        nsh->dev[i].page = NULL;
+                kmem_cache_free(conf->slab_cache, osh);
+        }
+        kmem_cache_destroy(conf->slab_cache);
+
+        /* Step 3.
+         * At this point, we are holding all the stripes so the array
+         * is completely stalled, so now is a good time to resize
+         * conf->disks.
+         */
+        ndisks = kzalloc(newsize * sizeof(struct disk_info), GFP_NOIO);
+        if (ndisks) {
+                for (i=0; i<conf->raid_disks; i++)
+                        ndisks[i] = conf->disks[i];
+                kfree(conf->disks);
+                conf->disks = ndisks;
+        } else
+                err = -ENOMEM;
+
+        /* Step 4, return new stripes to service */
+        while(!list_empty(&newstripes)) {
+                nsh = list_entry(newstripes.next, struct stripe_head, lru);
+                list_del_init(&nsh->lru);
+                for (i=conf->raid_disks; i < newsize; i++)
+                        if (nsh->dev[i].page == NULL) {
+                                struct page *p = alloc_page(GFP_NOIO);
+                                nsh->dev[i].page = p;
+                                if (!p)
+                                        err = -ENOMEM;
+                        }
+                release_stripe(nsh);
+        }
+        /* critical section pass, GFP_NOIO no longer needed */
+
+        conf->slab_cache = sc;
+        conf->active_name = 1-conf->active_name;
+        conf->pool_size = newsize;
+        return err;
+}
+#endif
+
 static int drop_one_stripe(raid5_conf_t *conf)
 {
         struct stripe_head *sh;
@@ -339,7 +467,7 @@ static int drop_one_stripe(raid5_conf_t *conf)
                 return 0;
         if (atomic_read(&sh->count))
                 BUG();
-        shrink_buffers(sh, conf->raid_disks);
+        shrink_buffers(sh, conf->pool_size);
         kmem_cache_free(conf->slab_cache, sh);
         atomic_dec(&conf->active_stripes);
         return 1;
@@ -360,7 +488,7 @@ static int raid5_end_read_request(struct bio * bi, unsigned int bytes_done,
 {
         struct stripe_head *sh = bi->bi_private;
         raid5_conf_t *conf = sh->raid_conf;
-        int disks = conf->raid_disks, i;
+        int disks = sh->disks, i;
         int uptodate = test_bit(BIO_UPTODATE, &bi->bi_flags);
 
         if (bi->bi_size)
@@ -458,7 +586,7 @@ static int raid5_end_write_request (struct bio *bi, unsigned int bytes_done,
 {
         struct stripe_head *sh = bi->bi_private;
         raid5_conf_t *conf = sh->raid_conf;
-        int disks = conf->raid_disks, i;
+        int disks = sh->disks, i;
         unsigned long flags;
         int uptodate = test_bit(BIO_UPTODATE, &bi->bi_flags);
 
@@ -612,7 +740,7 @@ static sector_t raid5_compute_sector(sector_t r_sector, unsigned int raid_disks,
 static sector_t compute_blocknr(struct stripe_head *sh, int i)
 {
         raid5_conf_t *conf = sh->raid_conf;
-        int raid_disks = conf->raid_disks, data_disks = raid_disks - 1;
+        int raid_disks = sh->disks, data_disks = raid_disks - 1;
         sector_t new_sector = sh->sector, check;
         int sectors_per_chunk = conf->chunk_size >> 9;
         sector_t stripe;
@@ -713,8 +841,7 @@ static void copy_data(int frombio, struct bio *bio,
 
 static void compute_block(struct stripe_head *sh, int dd_idx)
 {
-        raid5_conf_t *conf = sh->raid_conf;
-        int i, count, disks = conf->raid_disks;
+        int i, count, disks = sh->disks;
         void *ptr[MAX_XOR_BLOCKS], *p;
 
         PRINTK("compute_block, stripe %llu, idx %d\n", 
@@ -744,7 +871,7 @@ static void compute_block(struct stripe_head *sh, int dd_idx)
 static void compute_parity(struct stripe_head *sh, int method)
 {
         raid5_conf_t *conf = sh->raid_conf;
-        int i, pd_idx = sh->pd_idx, disks = conf->raid_disks, count;
+        int i, pd_idx = sh->pd_idx, disks = sh->disks, count;
         void *ptr[MAX_XOR_BLOCKS];
         struct bio *chosen;
 
@@ -910,6 +1037,20 @@ static int add_stripe_bio(struct stripe_head *sh, struct bio *bi, int dd_idx, in
         return 0;
 }
 
+static void end_reshape(raid5_conf_t *conf);
+
+static int stripe_to_pdidx(sector_t stripe, raid5_conf_t *conf, int disks)
+{
+        int sectors_per_chunk = conf->chunk_size >> 9;
+        sector_t x = stripe;
+        int pd_idx, dd_idx;
+        int chunk_offset = sector_div(x, sectors_per_chunk);
+        stripe = x;
+        raid5_compute_sector(stripe*(disks-1)*sectors_per_chunk
+                             + chunk_offset, disks, disks-1, &dd_idx, &pd_idx, conf);
+        return pd_idx;
+}
+
 
 /*
  * handle_stripe - do things to a stripe.
@@ -932,11 +1073,11 @@ static int add_stripe_bio(struct stripe_head *sh, struct bio *bi, int dd_idx, in
 static void handle_stripe(struct stripe_head *sh)
 {
         raid5_conf_t *conf = sh->raid_conf;
-        int disks = conf->raid_disks;
+        int disks = sh->disks;
         struct bio *return_bi= NULL;
         struct bio *bi;
         int i;
-        int syncing;
+        int syncing, expanding, expanded;
         int locked=0, uptodate=0, to_read=0, to_write=0, failed=0, written=0;
         int non_overwrite = 0;
         int failed_num=0;
@@ -951,6 +1092,8 @@ static void handle_stripe(struct stripe_head *sh)
         clear_bit(STRIPE_DELAYED, &sh->state);
 
         syncing = test_bit(STRIPE_SYNCING, &sh->state);
+        expanding = test_bit(STRIPE_EXPAND_SOURCE, &sh->state);
+        expanded = test_bit(STRIPE_EXPAND_READY, &sh->state);
         /* Now to look around and see what can be done */
 
         rcu_read_lock();
@@ -1143,13 +1286,14 @@ static void handle_stripe(struct stripe_head *sh)
          * parity, or to satisfy requests
          * or to load a block that is being partially written.
          */
-        if (to_read || non_overwrite || (syncing && (uptodate < disks))) {
+        if (to_read || non_overwrite || (syncing && (uptodate < disks)) || expanding) {
                 for (i=disks; i--;) {
                         dev = &sh->dev[i];
                         if (!test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) &&
                             (dev->toread ||
                              (dev->towrite && !test_bit(R5_OVERWRITE, &dev->flags)) ||
                              syncing ||
+                             expanding ||
                              (failed && (sh->dev[failed_num].toread ||
                                          (sh->dev[failed_num].towrite && !test_bit(R5_OVERWRITE, &sh->dev[failed_num].flags))))
                                     )
@@ -1339,13 +1483,77 @@ static void handle_stripe(struct stripe_head *sh)
                         set_bit(R5_Wantwrite, &dev->flags);
                         set_bit(R5_ReWrite, &dev->flags);
                         set_bit(R5_LOCKED, &dev->flags);
+                        locked++;
                 } else {
                         /* let's read it back */
                         set_bit(R5_Wantread, &dev->flags);
                         set_bit(R5_LOCKED, &dev->flags);
+                        locked++;
                 }
         }
 
+        if (expanded && test_bit(STRIPE_EXPANDING, &sh->state)) {
+                /* Need to write out all blocks after computing parity */
+                sh->disks = conf->raid_disks;
+                sh->pd_idx = stripe_to_pdidx(sh->sector, conf, conf->raid_disks);
+                compute_parity(sh, RECONSTRUCT_WRITE);
+                for (i= conf->raid_disks; i--;) {
+                        set_bit(R5_LOCKED, &sh->dev[i].flags);
+                        locked++;
+                        set_bit(R5_Wantwrite, &sh->dev[i].flags);
+                }
+                clear_bit(STRIPE_EXPANDING, &sh->state);
+        } else if (expanded) {
+                clear_bit(STRIPE_EXPAND_READY, &sh->state);
+                atomic_dec(&conf->reshape_stripes);
+                wake_up(&conf->wait_for_overlap);
+                md_done_sync(conf->mddev, STRIPE_SECTORS, 1);
+        }
+
+        if (expanding && locked == 0) {
+                /* We have read all the blocks in this stripe and now we need to
+                 * copy some of them into a target stripe for expand.
+                 */
+                clear_bit(STRIPE_EXPAND_SOURCE, &sh->state);
+                for (i=0; i< sh->disks; i++)
+                        if (i != sh->pd_idx) {
+                                int dd_idx, pd_idx, j;
+                                struct stripe_head *sh2;
+
+                                sector_t bn = compute_blocknr(sh, i);
+                                sector_t s = raid5_compute_sector(bn, conf->raid_disks,
+                                                                  conf->raid_disks-1,
+                                                                  &dd_idx, &pd_idx, conf);
+                                sh2 = get_active_stripe(conf, s, conf->raid_disks, pd_idx, 1);
+                                if (sh2 == NULL)
+                                        /* so far only the early blocks of this stripe
+                                         * have been requested.  When later blocks
+                                         * get requested, we will try again
+                                         */
+                                        continue;
+                                if(!test_bit(STRIPE_EXPANDING, &sh2->state) ||
+                                   test_bit(R5_Expanded, &sh2->dev[dd_idx].flags)) {
+                                        /* must have already done this block */
+                                        release_stripe(sh2);
+                                        continue;
+                                }
+                                memcpy(page_address(sh2->dev[dd_idx].page),
+                                       page_address(sh->dev[i].page),
+                                       STRIPE_SIZE);
+                                set_bit(R5_Expanded, &sh2->dev[dd_idx].flags);
+                                set_bit(R5_UPTODATE, &sh2->dev[dd_idx].flags);
+                                for (j=0; j<conf->raid_disks; j++)
+                                        if (j != sh2->pd_idx &&
+                                            !test_bit(R5_Expanded, &sh2->dev[j].flags))
+                                                break;
+                                if (j == conf->raid_disks) {
+                                        set_bit(STRIPE_EXPAND_READY, &sh2->state);
+                                        set_bit(STRIPE_HANDLE, &sh2->state);
+                                }
+                                release_stripe(sh2);
+                        }
+        }
+
         spin_unlock(&sh->lock);
 
         while ((bi=return_bi)) {
@@ -1384,7 +1592,7 @@ static void handle_stripe(struct stripe_head *sh)
                 rcu_read_unlock();
  
                 if (rdev) {
-                        if (syncing)
+                        if (syncing || expanding || expanded)
                                 md_sync_acct(rdev->bdev, STRIPE_SECTORS);
 
                         bi->bi_bdev = rdev->bdev;
@@ -1526,17 +1734,16 @@ static inline void raid5_plug_device(raid5_conf_t *conf)
         spin_unlock_irq(&conf->device_lock);
 }
 
-static int make_request (request_queue_t *q, struct bio * bi)
+static int make_request(request_queue_t *q, struct bio * bi)
 {
         mddev_t *mddev = q->queuedata;
         raid5_conf_t *conf = mddev_to_conf(mddev);
-        const unsigned int raid_disks = conf->raid_disks;
-        const unsigned int data_disks = raid_disks - 1;
         unsigned int dd_idx, pd_idx;
         sector_t new_sector;
         sector_t logical_sector, last_sector;
         struct stripe_head *sh;
         const int rw = bio_data_dir(bi);
+        int remaining;
 
         if (unlikely(bio_barrier(bi))) {
                 bio_endio(bi, bi->bi_size, -EOPNOTSUPP);
@@ -1555,20 +1762,77 @@ static int make_request (request_queue_t *q, struct bio * bi)
 
         for (;logical_sector < last_sector; logical_sector += STRIPE_SECTORS) {
                 DEFINE_WAIT(w);
-                
-                new_sector = raid5_compute_sector(logical_sector,
-                                                  raid_disks, data_disks, &dd_idx, &pd_idx, conf);
+                int disks;
 
+        retry:
+                prepare_to_wait(&conf->wait_for_overlap, &w, TASK_UNINTERRUPTIBLE);
+                if (likely(conf->expand_progress == MaxSector))
+                        disks = conf->raid_disks;
+                else {
+                        /* spinlock is needed as expand_progress may be
+                         * 64bit on a 32bit platform, and so it might be
+                         * possible to see a half-updated value
+                         * Ofcourse expand_progress could change after
+                         * the lock is dropped, so once we get a reference
+                         * to the stripe that we think it is, we will have
+                         * to check again.
+                         */
+                        spin_lock_irq(&conf->device_lock);
+                        disks = conf->raid_disks;
+                        if (logical_sector >= conf->expand_progress)
+                                disks = conf->previous_raid_disks;
+                        else {
+                                if (logical_sector >= conf->expand_lo) {
+                                        spin_unlock_irq(&conf->device_lock);
+                                        schedule();
+                                        goto retry;
+                                }
+                        }
+                        spin_unlock_irq(&conf->device_lock);
+                }
+                new_sector = raid5_compute_sector(logical_sector, disks, disks - 1,
+                                                  &dd_idx, &pd_idx, conf);
                 PRINTK("raid5: make_request, sector %llu logical %llu\n",
                         (unsigned long long)new_sector, 
                         (unsigned long long)logical_sector);
 
-        retry:
-                prepare_to_wait(&conf->wait_for_overlap, &w, TASK_UNINTERRUPTIBLE);
-                sh = get_active_stripe(conf, new_sector, pd_idx, (bi->bi_rw&RWA_MASK));
+                sh = get_active_stripe(conf, new_sector, disks, pd_idx, (bi->bi_rw&RWA_MASK));
                 if (sh) {
-                        if (!add_stripe_bio(sh, bi, dd_idx, (bi->bi_rw&RW_MASK))) {
-                                /* Add failed due to overlap.  Flush everything
+                        if (unlikely(conf->expand_progress != MaxSector)) {
+                                /* expansion might have moved on while waiting for a
+                                 * stripe, so we must do the range check again.
+                                 * Expansion could still move past after this
+                                 * test, but as we are holding a reference to
+                                 * 'sh', we know that if that happens,
+                                 *  STRIPE_EXPANDING will get set and the expansion
+                                 * won't proceed until we finish with the stripe.
+                                 */
+                                int must_retry = 0;
+                                spin_lock_irq(&conf->device_lock);
+                                if (logical_sector <  conf->expand_progress &&
+                                    disks == conf->previous_raid_disks)
+                                        /* mismatch, need to try again */
+                                        must_retry = 1;
+                                spin_unlock_irq(&conf->device_lock);
+                                if (must_retry) {
+                                        release_stripe(sh);
+                                        goto retry;
+                                }
+                        }
+                        /* FIXME what if we get a false positive because these
+                         * are being updated.
+                         */
+                        if (logical_sector >= mddev->suspend_lo &&
+                            logical_sector < mddev->suspend_hi) {
+                                release_stripe(sh);
+                                schedule();
+                                goto retry;
+                        }
+
+                        if (test_bit(STRIPE_EXPANDING, &sh->state) ||
+                            !add_stripe_bio(sh, bi, dd_idx, (bi->bi_rw&RW_MASK))) {
+                                /* Stripe is busy expanding or
+                                 * add failed due to overlap.  Flush everything
                                  * and wait a while
                                  */
                                 raid5_unplug_device(mddev->queue);
@@ -1580,7 +1844,6 @@ static int make_request (request_queue_t *q, struct bio * bi)
                         raid5_plug_device(conf);
                         handle_stripe(sh);
                         release_stripe(sh);
-
                 } else {
                         /* cannot get stripe for read-ahead, just give-up */
                         clear_bit(BIO_UPTODATE, &bi->bi_flags);
@@ -1590,7 +1853,9 @@ static int make_request (request_queue_t *q, struct bio * bi)
                         
         }
         spin_lock_irq(&conf->device_lock);
-        if (--bi->bi_phys_segments == 0) {
+        remaining = --bi->bi_phys_segments;
+        spin_unlock_irq(&conf->device_lock);
+        if (remaining == 0) {
                 int bytes = bi->bi_size;
 
                 if ( bio_data_dir(bi) == WRITE )
@@ -1598,7 +1863,6 @@ static int make_request (request_queue_t *q, struct bio * bi)
                 bi->bi_size = 0;
                 bi->bi_end_io(bi, bytes, 0);
         }
-        spin_unlock_irq(&conf->device_lock);
         return 0;
 }
 
@@ -1607,12 +1871,8 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
 {
         raid5_conf_t *conf = (raid5_conf_t *) mddev->private;
         struct stripe_head *sh;
-        int sectors_per_chunk = conf->chunk_size >> 9;
-        sector_t x;
-        unsigned long stripe;
-        int chunk_offset;
-        int dd_idx, pd_idx;
-        sector_t first_sector;
+        int pd_idx;
+        sector_t first_sector, last_sector;
         int raid_disks = conf->raid_disks;
         int data_disks = raid_disks-1;
         sector_t max_sector = mddev->size << 1;
@@ -1621,6 +1881,10 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
         if (sector_nr >= max_sector) {
                 /* just being told to finish up .. nothing much to do */
                 unplug_slaves(mddev);
+                if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
+                        end_reshape(conf);
+                        return 0;
+                }
 
                 if (mddev->curr_resync < max_sector) /* aborted */
                         bitmap_end_sync(mddev->bitmap, mddev->curr_resync,
@@ -1631,6 +1895,123 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
 
                 return 0;
         }
+
+        if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
+                /* reshaping is quite different to recovery/resync so it is
+                 * handled quite separately ... here.
+                 *
+                 * On each call to sync_request, we gather one chunk worth of
+                 * destination stripes and flag them as expanding.
+                 * Then we find all the source stripes and request reads.
+                 * As the reads complete, handle_stripe will copy the data
+                 * into the destination stripe and release that stripe.
+                 */
+                int i;
+                int dd_idx;
+                sector_t writepos, safepos, gap;
+
+                if (sector_nr == 0 &&
+                    conf->expand_progress != 0) {
+                        /* restarting in the middle, skip the initial sectors */
+                        sector_nr = conf->expand_progress;
+                        sector_div(sector_nr, conf->raid_disks-1);
+                        *skipped = 1;
+                        return sector_nr;
+                }
+
+                /* we update the metadata when there is more than 3Meg
+                 * in the block range (that is rather arbitrary, should
+                 * probably be time based) or when the data about to be
+                 * copied would over-write the source of the data at
+                 * the front of the range.
+                 * i.e. one new_stripe forward from expand_progress new_maps
+                 * to after where expand_lo old_maps to
+                 */
+                writepos = conf->expand_progress +
+                        conf->chunk_size/512*(conf->raid_disks-1);
+                sector_div(writepos, conf->raid_disks-1);
+                safepos = conf->expand_lo;
+                sector_div(safepos, conf->previous_raid_disks-1);
+                gap = conf->expand_progress - conf->expand_lo;
+
+                if (writepos >= safepos ||
+                    gap > (conf->raid_disks-1)*3000*2 /*3Meg*/) {
+                        /* Cannot proceed until we've updated the superblock... */
+                        wait_event(conf->wait_for_overlap,
+                                   atomic_read(&conf->reshape_stripes)==0);
+                        mddev->reshape_position = conf->expand_progress;
+                        mddev->sb_dirty = 1;
+                        md_wakeup_thread(mddev->thread);
+                        wait_event(mddev->sb_wait, mddev->sb_dirty == 0 ||
+                                   kthread_should_stop());
+                        spin_lock_irq(&conf->device_lock);
+                        conf->expand_lo = mddev->reshape_position;
+                        spin_unlock_irq(&conf->device_lock);
+                        wake_up(&conf->wait_for_overlap);
+                }
+
+                for (i=0; i < conf->chunk_size/512; i+= STRIPE_SECTORS) {
+                        int j;
+                        int skipped = 0;
+                        pd_idx = stripe_to_pdidx(sector_nr+i, conf, conf->raid_disks);
+                        sh = get_active_stripe(conf, sector_nr+i,
+                                               conf->raid_disks, pd_idx, 0);
+                        set_bit(STRIPE_EXPANDING, &sh->state);
+                        atomic_inc(&conf->reshape_stripes);
+                        /* If any of this stripe is beyond the end of the old
+                         * array, then we need to zero those blocks
+                         */
+                        for (j=sh->disks; j--;) {
+                                sector_t s;
+                                if (j == sh->pd_idx)
+                                        continue;
+                                s = compute_blocknr(sh, j);
+                                if (s < (mddev->array_size<<1)) {
+                                        skipped = 1;
+                                        continue;
+                                }
+                                memset(page_address(sh->dev[j].page), 0, STRIPE_SIZE);
+                                set_bit(R5_Expanded, &sh->dev[j].flags);
+                                set_bit(R5_UPTODATE, &sh->dev[j].flags);
+                        }
+                        if (!skipped) {
+                                set_bit(STRIPE_EXPAND_READY, &sh->state);
+                                set_bit(STRIPE_HANDLE, &sh->state);
+                        }
+                        release_stripe(sh);
+                }
+                spin_lock_irq(&conf->device_lock);
+                conf->expand_progress = (sector_nr + i)*(conf->raid_disks-1);
+                spin_unlock_irq(&conf->device_lock);
+                /* Ok, those stripe are ready. We can start scheduling
+                 * reads on the source stripes.
+                 * The source stripes are determined by mapping the first and last
+                 * block on the destination stripes.
+                 */
+                raid_disks = conf->previous_raid_disks;
+                data_disks = raid_disks - 1;
+                first_sector =
+                        raid5_compute_sector(sector_nr*(conf->raid_disks-1),
+                                             raid_disks, data_disks,
+                                             &dd_idx, &pd_idx, conf);
+                last_sector =
+                        raid5_compute_sector((sector_nr+conf->chunk_size/512)
+                                               *(conf->raid_disks-1) -1,
+                                             raid_disks, data_disks,
+                                             &dd_idx, &pd_idx, conf);
+                if (last_sector >= (mddev->size<<1))
+                        last_sector = (mddev->size<<1)-1;
+                while (first_sector <= last_sector) {
+                        pd_idx = stripe_to_pdidx(first_sector, conf, conf->previous_raid_disks);
+                        sh = get_active_stripe(conf, first_sector,
+                                               conf->previous_raid_disks, pd_idx, 0);
+                        set_bit(STRIPE_EXPAND_SOURCE, &sh->state);
+                        set_bit(STRIPE_HANDLE, &sh->state);
+                        release_stripe(sh);
+                        first_sector += STRIPE_SECTORS;
+                }
+                return conf->chunk_size>>9;
+        }
         /* if there is 1 or more failed drives and we are trying
          * to resync, then assert that we are finished, because there is
          * nothing we can do.
@@ -1649,16 +2030,10 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
                 return sync_blocks * STRIPE_SECTORS; /* keep things rounded to whole stripes */
         }
 
-        x = sector_nr;
-        chunk_offset = sector_div(x, sectors_per_chunk);
-        stripe = x;
-        BUG_ON(x != stripe);
-
-        first_sector = raid5_compute_sector((sector_t)stripe*data_disks*sectors_per_chunk
-                + chunk_offset, raid_disks, data_disks, &dd_idx, &pd_idx, conf);
-        sh = get_active_stripe(conf, sector_nr, pd_idx, 1);
+        pd_idx = stripe_to_pdidx(sector_nr, conf, raid_disks);
+        sh = get_active_stripe(conf, sector_nr, raid_disks, pd_idx, 1);
         if (sh == NULL) {
-                sh = get_active_stripe(conf, sector_nr, pd_idx, 0);
+                sh = get_active_stripe(conf, sector_nr, raid_disks, pd_idx, 0);
                 /* make sure we don't swamp the stripe cache if someone else
                  * is trying to get access 
                  */
@@ -1822,11 +2197,64 @@ static int run(mddev_t *mddev)
                 return -EIO;
         }
 
-        mddev->private = kzalloc(sizeof (raid5_conf_t)
-                                 + mddev->raid_disks * sizeof(struct disk_info),
-                                 GFP_KERNEL);
+        if (mddev->reshape_position != MaxSector) {
+                /* Check that we can continue the reshape.
+                 * Currently only disks can change, it must
+                 * increase, and we must be past the point where
+                 * a stripe over-writes itself
+                 */
+                sector_t here_new, here_old;
+                int old_disks;
+
+                if (mddev->new_level != mddev->level ||
+                    mddev->new_layout != mddev->layout ||
+                    mddev->new_chunk != mddev->chunk_size) {
+                        printk(KERN_ERR "raid5: %s: unsupported reshape required - aborting.\n",
+                               mdname(mddev));
+                        return -EINVAL;
+                }
+                if (mddev->delta_disks <= 0) {
+                        printk(KERN_ERR "raid5: %s: unsupported reshape (reduce disks) required - aborting.\n",
+                               mdname(mddev));
+                        return -EINVAL;
+                }
+                old_disks = mddev->raid_disks - mddev->delta_disks;
+                /* reshape_position must be on a new-stripe boundary, and one
+                 * further up in new geometry must map after here in old geometry.
+                 */
+                here_new = mddev->reshape_position;
+                if (sector_div(here_new, (mddev->chunk_size>>9)*(mddev->raid_disks-1))) {
+                        printk(KERN_ERR "raid5: reshape_position not on a stripe boundary\n");
+                        return -EINVAL;
+                }
+                /* here_new is the stripe we will write to */
+                here_old = mddev->reshape_position;
+                sector_div(here_old, (mddev->chunk_size>>9)*(old_disks-1));
+                /* here_old is the first stripe that we might need to read from */
+                if (here_new >= here_old) {
+                        /* Reading from the same stripe as writing to - bad */
+                        printk(KERN_ERR "raid5: reshape_position too early for auto-recovery - aborting.\n");
+                        return -EINVAL;
+                }
+                printk(KERN_INFO "raid5: reshape will continue\n");
+                /* OK, we should be able to continue; */
+        }
+
+
+        mddev->private = kzalloc(sizeof (raid5_conf_t), GFP_KERNEL);
         if ((conf = mddev->private) == NULL)
                 goto abort;
+        if (mddev->reshape_position == MaxSector) {
+                conf->previous_raid_disks = conf->raid_disks = mddev->raid_disks;
+        } else {
+                conf->raid_disks = mddev->raid_disks;
+                conf->previous_raid_disks = mddev->raid_disks - mddev->delta_disks;
+        }
+
+        conf->disks = kzalloc(conf->raid_disks * sizeof(struct disk_info),
+                              GFP_KERNEL);
+        if (!conf->disks)
+                goto abort;
 
         conf->mddev = mddev;
 
@@ -1847,7 +2275,7 @@ static int run(mddev_t *mddev)
 
         ITERATE_RDEV(mddev,rdev,tmp) {
                 raid_disk = rdev->raid_disk;
-                if (raid_disk >= mddev->raid_disks
+                if (raid_disk >= conf->raid_disks
                     || raid_disk < 0)
                         continue;
                 disk = conf->disks + raid_disk;
@@ -1863,7 +2291,6 @@ static int run(mddev_t *mddev)
                 }
         }
 
-        conf->raid_disks = mddev->raid_disks;
         /*
          * 0 for a fully functional array, 1 for a degraded array.
          */
@@ -1873,6 +2300,7 @@ static int run(mddev_t *mddev)
         conf->level = mddev->level;
         conf->algorithm = mddev->layout;
         conf->max_nr_stripes = NR_STRIPES;
+        conf->expand_progress = mddev->reshape_position;
 
         /* device size must be a multiple of chunk size */
         mddev->size &= ~(mddev->chunk_size/1024 -1);
@@ -1945,6 +2373,21 @@ static int run(mddev_t *mddev)
 
         print_raid5_conf(conf);
 
+        if (conf->expand_progress != MaxSector) {
+                printk("...ok start reshape thread\n");
+                conf->expand_lo = conf->expand_progress;
+                atomic_set(&conf->reshape_stripes, 0);
+                clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
+                clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
+                set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
+                set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
+                mddev->sync_thread = md_register_thread(md_do_sync, mddev,
+                                                        "%s_reshape");
+                /* FIXME if md_register_thread fails?? */
+                md_wakeup_thread(mddev->sync_thread);
+
+        }
+
         /* read-ahead size must cover two whole stripes, which is
          * 2 * (n-1) * chunksize where 'n' is the number of raid devices
          */
@@ -1960,12 +2403,13 @@ static int run(mddev_t *mddev)
 
         mddev->queue->unplug_fn = raid5_unplug_device;
         mddev->queue->issue_flush_fn = raid5_issue_flush;
+        mddev->array_size =  mddev->size * (conf->previous_raid_disks - 1);
 
-        mddev->array_size =  mddev->size * (mddev->raid_disks - 1);
         return 0;
 abort:
         if (conf) {
                 print_raid5_conf(conf);
+                kfree(conf->disks);
                 kfree(conf->stripe_hashtbl);
                 kfree(conf);
         }
@@ -1986,6 +2430,7 @@ static int stop(mddev_t *mddev)
         kfree(conf->stripe_hashtbl);
         blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
         sysfs_remove_group(&mddev->kobj, &raid5_attrs_group);
+        kfree(conf->disks);
         kfree(conf);
         mddev->private = NULL;
         return 0;
@@ -2001,7 +2446,7 @@ static void print_sh (struct stripe_head *sh)
         printk("sh %llu,  count %d.\n",
                 (unsigned long long)sh->sector, atomic_read(&sh->count));
         printk("sh %llu, ", (unsigned long long)sh->sector);
-        for (i = 0; i < sh->raid_conf->raid_disks; i++) {
+        for (i = 0; i < sh->disks; i++) {
                 printk("(cache%d: %p %ld) ", 
                         i, sh->dev[i].page, sh->dev[i].flags);
         }
@@ -2132,7 +2577,7 @@ static int raid5_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
         /*
          * find the disk ...
          */
-        for (disk=0; disk < mddev->raid_disks; disk++)
+        for (disk=0; disk < conf->raid_disks; disk++)
                 if ((p=conf->disks + disk)->rdev == NULL) {
                         clear_bit(In_sync, &rdev->flags);
                         rdev->raid_disk = disk;
@@ -2168,11 +2613,146 @@ static int raid5_resize(mddev_t *mddev, sector_t sectors)
         return 0;
 }
 
+#ifdef CONFIG_MD_RAID5_RESHAPE
+static int raid5_check_reshape(mddev_t *mddev)
+{
+        raid5_conf_t *conf = mddev_to_conf(mddev);
+        int err;
+
+        if (mddev->delta_disks < 0 ||
+            mddev->new_level != mddev->level)
+                return -EINVAL; /* Cannot shrink array or change level yet */
+        if (mddev->delta_disks == 0)
+                return 0; /* nothing to do */
+
+        /* Can only proceed if there are plenty of stripe_heads.
+         * We need a minimum of one full stripe,, and for sensible progress
+         * it is best to have about 4 times that.
+         * If we require 4 times, then the default 256 4K stripe_heads will
+         * allow for chunk sizes up to 256K, which is probably OK.
+         * If the chunk size is greater, user-space should request more
+         * stripe_heads first.
+         */
+        if ((mddev->chunk_size / STRIPE_SIZE) * 4 > conf->max_nr_stripes ||
+            (mddev->new_chunk / STRIPE_SIZE) * 4 > conf->max_nr_stripes) {
+                printk(KERN_WARNING "raid5: reshape: not enough stripes.  Needed %lu\n",
+                       (mddev->chunk_size / STRIPE_SIZE)*4);
+                return -ENOSPC;
+        }
+
+        err = resize_stripes(conf, conf->raid_disks + mddev->delta_disks);
+        if (err)
+                return err;
+
+        /* looks like we might be able to manage this */
+        return 0;
+}
+
+static int raid5_start_reshape(mddev_t *mddev)
+{
+        raid5_conf_t *conf = mddev_to_conf(mddev);
+        mdk_rdev_t *rdev;
+        struct list_head *rtmp;
+        int spares = 0;
+        int added_devices = 0;
+
+        if (mddev->degraded ||
+            test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
+                return -EBUSY;
+
+        ITERATE_RDEV(mddev, rdev, rtmp)
+                if (rdev->raid_disk < 0 &&
+                    !test_bit(Faulty, &rdev->flags))
+                        spares++;
+
+        if (spares < mddev->delta_disks-1)
+                /* Not enough devices even to make a degraded array
+                 * of that size
+                 */
+                return -EINVAL;
+
+        atomic_set(&conf->reshape_stripes, 0);
+        spin_lock_irq(&conf->device_lock);
+        conf->previous_raid_disks = conf->raid_disks;
+        conf->raid_disks += mddev->delta_disks;
+        conf->expand_progress = 0;
+        conf->expand_lo = 0;
+        spin_unlock_irq(&conf->device_lock);
+
+        /* Add some new drives, as many as will fit.
+         * We know there are enough to make the newly sized array work.
+         */
+        ITERATE_RDEV(mddev, rdev, rtmp)
+                if (rdev->raid_disk < 0 &&
+                    !test_bit(Faulty, &rdev->flags)) {
+                        if (raid5_add_disk(mddev, rdev)) {
+                                char nm[20];
+                                set_bit(In_sync, &rdev->flags);
+                                conf->working_disks++;
+                                added_devices++;
+                                sprintf(nm, "rd%d", rdev->raid_disk);
+                                sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
+                        } else
+                                break;
+                }
+
+        mddev->degraded = (conf->raid_disks - conf->previous_raid_disks) - added_devices;
+        mddev->raid_disks = conf->raid_disks;
+        mddev->reshape_position = 0;
+        mddev->sb_dirty = 1;
+
+        clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
+        clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
+        set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
+        set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
+        mddev->sync_thread = md_register_thread(md_do_sync, mddev,
+                                                "%s_reshape");
+        if (!mddev->sync_thread) {
+                mddev->recovery = 0;
+                spin_lock_irq(&conf->device_lock);
+                mddev->raid_disks = conf->raid_disks = conf->previous_raid_disks;
+                conf->expand_progress = MaxSector;
+                spin_unlock_irq(&conf->device_lock);
+                return -EAGAIN;
+        }
+        md_wakeup_thread(mddev->sync_thread);
+        md_new_event(mddev);
+        return 0;
+}
+#endif
+
+static void end_reshape(raid5_conf_t *conf)
+{
+        struct block_device *bdev;
+
+        if (!test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery)) {
+                conf->mddev->array_size = conf->mddev->size * (conf->raid_disks-1);
+                set_capacity(conf->mddev->gendisk, conf->mddev->array_size << 1);
+                conf->mddev->changed = 1;
+
+                bdev = bdget_disk(conf->mddev->gendisk, 0);
+                if (bdev) {
+                        mutex_lock(&bdev->bd_inode->i_mutex);
+                        i_size_write(bdev->bd_inode, conf->mddev->array_size << 10);
+                        mutex_unlock(&bdev->bd_inode->i_mutex);
+                        bdput(bdev);
+                }
+                spin_lock_irq(&conf->device_lock);
+                conf->expand_progress = MaxSector;
+                spin_unlock_irq(&conf->device_lock);
+                conf->mddev->reshape_position = MaxSector;
+        }
+}
+
 static void raid5_quiesce(mddev_t *mddev, int state)
 {
         raid5_conf_t *conf = mddev_to_conf(mddev);
 
         switch(state) {
+        case 2: /* resume for a suspend */
+                wake_up(&conf->wait_for_overlap);
+                break;
+
         case 1: /* stop all writes */
                 spin_lock_irq(&conf->device_lock);
                 conf->quiesce = 1;
@@ -2186,6 +2766,7 @@ static void raid5_quiesce(mddev_t *mddev, int state)
                 spin_lock_irq(&conf->device_lock);
                 conf->quiesce = 0;
                 wake_up(&conf->wait_for_stripe);
+                wake_up(&conf->wait_for_overlap);
                 spin_unlock_irq(&conf->device_lock);
                 break;
         }
@@ -2206,6 +2787,10 @@ static struct mdk_personality raid5_personality =
         .spare_active   = raid5_spare_active,
         .sync_request   = sync_request,
         .resize         = raid5_resize,
+#ifdef CONFIG_MD_RAID5_RESHAPE
+        .check_reshape  = raid5_check_reshape,
+        .start_reshape  = raid5_start_reshape,
+#endif
         .quiesce        = raid5_quiesce,
 };
 
diff --git a/drivers/md/raid6main.c b/drivers/md/raid6main.c
index cd477ebf2ee4..6df4930fddec 100644
--- a/drivers/md/raid6main.c
+++ b/drivers/md/raid6main.c
@@ -331,9 +331,9 @@ static int grow_stripes(raid6_conf_t *conf, int num)
         kmem_cache_t *sc;
         int devs = conf->raid_disks;
 
-        sprintf(conf->cache_name, "raid6/%s", mdname(conf->mddev));
+        sprintf(conf->cache_name[0], "raid6/%s", mdname(conf->mddev));
 
-        sc = kmem_cache_create(conf->cache_name,
+        sc = kmem_cache_create(conf->cache_name[0],
                                sizeof(struct stripe_head)+(devs-1)*sizeof(struct r5dev),
                                0, 0, NULL, NULL);
         if (!sc)
@@ -2006,11 +2006,14 @@ static int run(mddev_t *mddev)
                 return -EIO;
         }
 
-        mddev->private = kzalloc(sizeof (raid6_conf_t)
-                                 + mddev->raid_disks * sizeof(struct disk_info),
-                                 GFP_KERNEL);
+        mddev->private = kzalloc(sizeof (raid6_conf_t), GFP_KERNEL);
         if ((conf = mddev->private) == NULL)
                 goto abort;
+        conf->disks = kzalloc(mddev->raid_disks * sizeof(struct disk_info),
+                                 GFP_KERNEL);
+        if (!conf->disks)
+                goto abort;
+
         conf->mddev = mddev;
 
         if ((conf->stripe_hashtbl = kzalloc(PAGE_SIZE, GFP_KERNEL)) == NULL)
@@ -2158,6 +2161,7 @@ abort:
                 print_raid6_conf(conf);
                 safe_put_page(conf->spare_page);
                 kfree(conf->stripe_hashtbl);
+                kfree(conf->disks);
                 kfree(conf);
         }
         mddev->private = NULL;
diff --git a/drivers/media/dvb/dvb-core/dvbdev.c b/drivers/media/dvb/dvb-core/dvbdev.c
index 54f8b95717b0..96fe0ecae250 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/drivers/media/dvb/dvb-core/dvbdev.c
@@ -86,7 +86,7 @@ static int dvb_device_open(struct inode *inode, struct file *file)
 
         if (dvbdev && dvbdev->fops) {
                 int err = 0;
-                struct file_operations *old_fops;
+                const struct file_operations *old_fops;
 
                 file->private_data = dvbdev;
                 old_fops = file->f_op;
diff --git a/drivers/media/video/videodev.c b/drivers/media/video/videodev.c
index 75e3d41382f2..5f87dd5f1d0b 100644
--- a/drivers/media/video/videodev.c
+++ b/drivers/media/video/videodev.c
@@ -97,7 +97,7 @@ static int video_open(struct inode *inode, struct file *file)
         unsigned int minor = iminor(inode);
         int err = 0;
         struct video_device *vfl;
-        struct file_operations *old_fops;
+        const struct file_operations *old_fops;
 
         if(minor>=VIDEO_NUM_DEVICES)
                 return -ENODEV;
diff --git a/drivers/message/i2o/i2o_proc.c b/drivers/message/i2o/i2o_proc.c
index 2a0c42b8cda5..3d2e76eea93e 100644
--- a/drivers/message/i2o/i2o_proc.c
+++ b/drivers/message/i2o/i2o_proc.c
@@ -56,7 +56,7 @@
 typedef struct _i2o_proc_entry_t {
         char *name;             /* entry name */
         mode_t mode;            /* mode */
-        struct file_operations *fops;   /* open function */
+        const struct file_operations *fops;     /* open function */
 } i2o_proc_entry;
 
 /* global I2O /proc/i2o entry */
diff --git a/drivers/misc/ibmasm/heartbeat.c b/drivers/misc/ibmasm/heartbeat.c
index f295401fac21..7fd7a43e38de 100644
--- a/drivers/misc/ibmasm/heartbeat.c
+++ b/drivers/misc/ibmasm/heartbeat.c
@@ -52,12 +52,13 @@ static struct notifier_block panic_notifier = { panic_happened, NULL, 1 };
 
 void ibmasm_register_panic_notifier(void)
 {
-        notifier_chain_register(&panic_notifier_list, &panic_notifier);
+        atomic_notifier_chain_register(&panic_notifier_list, &panic_notifier);
 }
 
 void ibmasm_unregister_panic_notifier(void)
 {
-        notifier_chain_unregister(&panic_notifier_list, &panic_notifier);
+        atomic_notifier_chain_unregister(&panic_notifier_list,
+                        &panic_notifier);
 }
 
 
diff --git a/drivers/misc/ibmasm/ibmasmfs.c b/drivers/misc/ibmasm/ibmasmfs.c
index 5c550fcac2c4..26a230b6ff80 100644
--- a/drivers/misc/ibmasm/ibmasmfs.c
+++ b/drivers/misc/ibmasm/ibmasmfs.c
@@ -101,7 +101,7 @@ static struct super_operations ibmasmfs_s_ops = {
         .drop_inode     = generic_delete_inode,
 };
 
-static struct file_operations *ibmasmfs_dir_ops = &simple_dir_operations;
+static const struct file_operations *ibmasmfs_dir_ops = &simple_dir_operations;
 
 static struct file_system_type ibmasmfs_type = {
         .owner          = THIS_MODULE,
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 2d0ac169a86c..f13a539dc169 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -3159,7 +3159,7 @@ static int bond_slave_netdev_event(unsigned long event, struct net_device *slave
  * bond_netdev_event: handle netdev notifier chain events.
  *
  * This function receives events for the netdev chain.  The caller (an
- * ioctl handler calling notifier_call_chain) holds the necessary
+ * ioctl handler calling blocking_notifier_call_chain) holds the necessary
  * locks for us to safely manipulate the slave devices (RTNL lock,
  * dev_probe_lock).
  */
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index e7fc28b07e5a..7627a75f4f7c 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -134,6 +134,7 @@
 #include <linux/random.h>
 #include <linux/init.h>
 #include <linux/if_vlan.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/irq.h>
 #include <asm/io.h>
@@ -2932,7 +2933,7 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
         if (id->driver_data & DEV_HAS_HIGH_DMA) {
                 /* packet format 3: supports 40-bit addressing */
                 np->desc_ver = DESC_VER_3;
-                if (pci_set_dma_mask(pci_dev, 0x0000007fffffffffULL)) {
+                if (pci_set_dma_mask(pci_dev, DMA_39BIT_MASK)) {
                         printk(KERN_INFO "forcedeth: 64-bit DMA failed, using 32-bit addressing for device %s.\n",
                                         pci_name(pci_dev));
                 } else {
diff --git a/drivers/net/ioc3-eth.c b/drivers/net/ioc3-eth.c
index 9b8295ee06ef..ae71ed57c12d 100644
--- a/drivers/net/ioc3-eth.c
+++ b/drivers/net/ioc3-eth.c
@@ -44,6 +44,7 @@
 #include <linux/ip.h>
 #include <linux/tcp.h>
 #include <linux/udp.h>
+#include <linux/dma-mapping.h>
 
 #ifdef CONFIG_SERIAL_8250
 #include <linux/serial_core.h>
@@ -1195,17 +1196,17 @@ static int ioc3_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         int err, pci_using_dac;
 
         /* Configure DMA attributes. */
-        err = pci_set_dma_mask(pdev, 0xffffffffffffffffULL);
+        err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
         if (!err) {
                 pci_using_dac = 1;
-                err = pci_set_consistent_dma_mask(pdev, 0xffffffffffffffffULL);
+                err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
                 if (err < 0) {
                         printk(KERN_ERR "%s: Unable to obtain 64 bit DMA "
                                "for consistent allocations\n", pci_name(pdev));
                         goto out;
                 }
         } else {
-                err = pci_set_dma_mask(pdev, 0xffffffffULL);
+                err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 if (err) {
                         printk(KERN_ERR "%s: No usable DMA configuration, "
                                "aborting.\n", pci_name(pdev));
diff --git a/drivers/net/irda/nsc-ircc.c b/drivers/net/irda/nsc-ircc.c
index 83141a3ff546..cc7ff8f00e42 100644
--- a/drivers/net/irda/nsc-ircc.c
+++ b/drivers/net/irda/nsc-ircc.c
@@ -207,7 +207,7 @@ static int __init nsc_ircc_init(void)
         /* Register with PnP subsystem to detect disable ports */
         ret = pnp_register_driver(&nsc_ircc_pnp_driver);
 
-        if (ret >= 0)
+        if (!ret)
                 pnp_registered = 1;
 
         ret = -ENODEV;
@@ -812,7 +812,7 @@ static int nsc_ircc_init_39x(nsc_chip_t *chip, chipio_t *info)
         int cfg_base = info->cfg_base;
         int enabled;
 
-        /* User is shure about his config... accept it. */
+        /* User is sure about his config... accept it. */
         IRDA_DEBUG(2, "%s(): nsc_ircc_init_39x (user settings): "
                    "io=0x%04x, irq=%d, dma=%d\n", 
                    __FUNCTION__, info->fir_base, info->irq, info->dma);
diff --git a/drivers/net/loopback.c b/drivers/net/loopback.c
index 0c13795dca38..b79d6e8d3045 100644
--- a/drivers/net/loopback.c
+++ b/drivers/net/loopback.c
@@ -172,7 +172,7 @@ static struct net_device_stats *get_stats(struct net_device *dev)
 
         memset(stats, 0, sizeof(struct net_device_stats));
 
-        for_each_cpu(i) {
+        for_each_possible_cpu(i) {
                 struct net_device_stats *lb_stats;
 
                 lb_stats = &per_cpu(loopback_stats, i);
diff --git a/drivers/net/ns83820.c b/drivers/net/ns83820.c
index 0fede50abd3e..8e9b1a537dee 100644
--- a/drivers/net/ns83820.c
+++ b/drivers/net/ns83820.c
@@ -1828,10 +1828,10 @@ static int __devinit ns83820_init_one(struct pci_dev *pci_dev, const struct pci_
         int using_dac = 0;
 
         /* See if we can set the dma mask early on; failure is fatal. */
-        if (sizeof(dma_addr_t) == 8 && 
-                !pci_set_dma_mask(pci_dev, 0xffffffffffffffffULL)) {
+        if (sizeof(dma_addr_t) == 8 &&
+                !pci_set_dma_mask(pci_dev, DMA_64BIT_MASK)) {
                 using_dac = 1;
-        } else if (!pci_set_dma_mask(pci_dev, 0xffffffff)) {
+        } else if (!pci_set_dma_mask(pci_dev, DMA_32BIT_MASK)) {
                 using_dac = 0;
         } else {
                 printk(KERN_WARNING "ns83820.c: pci_set_dma_mask failed!\n");
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index 8429ceb01389..b82191d2bee1 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -2283,7 +2283,7 @@ static void set_rx_mode(struct net_device *net_dev)
         int i, table_entries;
         u32 rx_mode;
 
-        /* 635 Hash Table entires = 256(2^16) */
+        /* 635 Hash Table entries = 256(2^16) */
         if((sis_priv->chipset_rev >= SIS635A_900_REV) ||
                         (sis_priv->chipset_rev == SIS900B_900_REV))
                 table_entries = 16;
diff --git a/drivers/net/tulip/de4x5.c b/drivers/net/tulip/de4x5.c
index 46d087c5467b..f56094102042 100644
--- a/drivers/net/tulip/de4x5.c
+++ b/drivers/net/tulip/de4x5.c
@@ -513,7 +513,7 @@ struct mii_phy {
     u_char  *rst;           /* Start of reset sequence in SROM           */
     u_int mc;               /* Media Capabilities                        */
     u_int ana;              /* NWay Advertisement                        */
-    u_int fdx;              /* Full DupleX capabilites for each media    */
+    u_int fdx;              /* Full DupleX capabilities for each media   */
     u_int ttm;              /* Transmit Threshold Mode for each media    */
     u_int mci;              /* 21142 MII Connector Interrupt info        */
 };
diff --git a/drivers/net/tulip/pnic2.c b/drivers/net/tulip/pnic2.c
index 55f4a9a631bc..ab985023fcca 100644
--- a/drivers/net/tulip/pnic2.c
+++ b/drivers/net/tulip/pnic2.c
@@ -199,7 +199,7 @@ void pnic2_lnk_change(struct net_device *dev, int csr5)
                        /* negotiation ended successfully */
 
                        /* get the link partners reply and mask out all but
-                        * bits 24-21 which show the partners capabilites
+                        * bits 24-21 which show the partners capabilities
                         * and match those to what we advertised
                         *
                         * then begin to interpret the results of the negotiation.
diff --git a/drivers/net/typhoon.c b/drivers/net/typhoon.c
index cde35dd87906..c1ce87a5f8d3 100644
--- a/drivers/net/typhoon.c
+++ b/drivers/net/typhoon.c
@@ -208,7 +208,7 @@ static const struct typhoon_card_info typhoon_card_info[] __devinitdata = {
 };
 
 /* Notes on the new subsystem numbering scheme:
- * bits 0-1 indicate crypto capabilites: (0) variable, (1) DES, or (2) 3DES
+ * bits 0-1 indicate crypto capabilities: (0) variable, (1) DES, or (2) 3DES
  * bit 4 indicates if this card has secured firmware (we don't support it)
  * bit 8 indicates if this is a (0) copper or (1) fiber card
  * bits 12-16 indicate card type: (0) client and (1) server
@@ -788,7 +788,7 @@ typhoon_start_tx(struct sk_buff *skb, struct net_device *dev)
         /* we have two rings to choose from, but we only use txLo for now
          * If we start using the Hi ring as well, we'll need to update
          * typhoon_stop_runtime(), typhoon_interrupt(), typhoon_num_free_tx(),
-         * and TXHI_ENTIRES to match, as well as update the TSO code below
+         * and TXHI_ENTRIES to match, as well as update the TSO code below
          * to get the right DMA address
          */
         txRing = &tp->txLoRing;
diff --git a/drivers/net/wan/wanxl.c b/drivers/net/wan/wanxl.c
index 9d3b51c3ef54..29a756dd979b 100644
--- a/drivers/net/wan/wanxl.c
+++ b/drivers/net/wan/wanxl.c
@@ -577,8 +577,8 @@ static int __devinit wanxl_pci_init_one(struct pci_dev *pdev,
            We set both dma_mask and consistent_dma_mask to 28 bits
            and pray pci_alloc_consistent() will use this info. It should
            work on most platforms */
-        if (pci_set_consistent_dma_mask(pdev, 0x0FFFFFFF) ||
-            pci_set_dma_mask(pdev, 0x0FFFFFFF)) {
+        if (pci_set_consistent_dma_mask(pdev, DMA_28BIT_MASK) ||
+            pci_set_dma_mask(pdev, DMA_28BIT_MASK)) {
                 printk(KERN_ERR "wanXL: No usable DMA configuration\n");
                 return -EIO;
         }
diff --git a/drivers/net/wireless/orinoco.c b/drivers/net/wireless/orinoco.c
index 6fd0bf736830..8dfdfbd5966c 100644
--- a/drivers/net/wireless/orinoco.c
+++ b/drivers/net/wireless/orinoco.c
@@ -3858,7 +3858,7 @@ static int orinoco_ioctl_setscan(struct net_device *dev,
         unsigned long flags;
 
         /* Note : you may have realised that, as this is a SET operation,
-         * this is priviledged and therefore a normal user can't
+         * this is privileged and therefore a normal user can't
          * perform scanning.
          * This is not an error, while the device perform scanning,
          * traffic doesn't flow, so it's a perfect DoS...
diff --git a/drivers/net/wireless/prism54/isl_ioctl.c b/drivers/net/wireless/prism54/isl_ioctl.c
index e5bb9f5ae429..989599ad33ef 100644
--- a/drivers/net/wireless/prism54/isl_ioctl.c
+++ b/drivers/net/wireless/prism54/isl_ioctl.c
@@ -747,7 +747,7 @@ prism54_get_essid(struct net_device *ndev, struct iw_request_info *info,
 
         if (essid->length) {
                 dwrq->flags = 1;        /* set ESSID to ON for Wireless Extensions */
-                /* if it is to big, trunk it */
+                /* if it is too big, trunk it */
                 dwrq->length = min((u8)IW_ESSID_MAX_SIZE, essid->length);
         } else {
                 dwrq->flags = 0;
diff --git a/drivers/net/wireless/prism54/islpci_hotplug.c b/drivers/net/wireless/prism54/islpci_hotplug.c
index b41d666fea3c..bfa0cc319a09 100644
--- a/drivers/net/wireless/prism54/islpci_hotplug.c
+++ b/drivers/net/wireless/prism54/islpci_hotplug.c
@@ -22,6 +22,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/init.h> /* For __init, __exit */
+#include <linux/dma-mapping.h>
 
 #include "prismcompat.h"
 #include "islpci_dev.h"
@@ -124,7 +125,7 @@ prism54_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         }
 
         /* enable PCI DMA */
-        if (pci_set_dma_mask(pdev, 0xffffffff)) {
+        if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
                 printk(KERN_ERR "%s: 32-bit PCI DMA not supported", DRV_NAME);
                 goto do_pci_disable_device;
         }
diff --git a/drivers/oprofile/cpu_buffer.c b/drivers/oprofile/cpu_buffer.c
index 330d3869b41e..fc4bc9b94c74 100644
--- a/drivers/oprofile/cpu_buffer.c
+++ b/drivers/oprofile/cpu_buffer.c
@@ -217,11 +217,10 @@ static void oprofile_end_trace(struct oprofile_cpu_buffer * cpu_buf)
         cpu_buf->tracing = 0;
 }
 
-void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
+void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
+                                unsigned long event, int is_kernel)
 {
         struct oprofile_cpu_buffer * cpu_buf = &cpu_buffer[smp_processor_id()];
-        unsigned long pc = profile_pc(regs);
-        int is_kernel = !user_mode(regs);
 
         if (!backtrace_depth) {
                 log_sample(cpu_buf, pc, is_kernel, event);
@@ -238,6 +237,14 @@ void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
         oprofile_end_trace(cpu_buf);
 }
 
+void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
+{
+        int is_kernel = !user_mode(regs);
+        unsigned long pc = profile_pc(regs);
+
+        oprofile_add_ext_sample(pc, regs, event, is_kernel);
+}
+
 void oprofile_add_pc(unsigned long pc, int is_kernel, unsigned long event)
 {
         struct oprofile_cpu_buffer * cpu_buf = &cpu_buffer[smp_processor_id()];
diff --git a/drivers/oprofile/oprofile_stats.c b/drivers/oprofile/oprofile_stats.c
index e94b1e4a2a84..f0acb661c253 100644
--- a/drivers/oprofile/oprofile_stats.c
+++ b/drivers/oprofile/oprofile_stats.c
@@ -22,7 +22,7 @@ void oprofile_reset_stats(void)
         struct oprofile_cpu_buffer * cpu_buf; 
         int i;
  
-        for_each_cpu(i) {
+        for_each_possible_cpu(i) {
                 cpu_buf = &cpu_buffer[i]; 
                 cpu_buf->sample_received = 0;
                 cpu_buf->sample_lost_overflow = 0;
@@ -46,7 +46,7 @@ void oprofile_create_stats_files(struct super_block * sb, struct dentry * root)
         if (!dir)
                 return;
 
-        for_each_cpu(i) {
+        for_each_possible_cpu(i) {
                 cpu_buf = &cpu_buffer[i]; 
                 snprintf(buf, 10, "cpu%d", i);
                 cpudir = oprofilefs_mkdir(sb, dir, buf);
diff --git a/drivers/oprofile/oprofilefs.c b/drivers/oprofile/oprofilefs.c
index d6bae699749a..b62da9b0cbf0 100644
--- a/drivers/oprofile/oprofilefs.c
+++ b/drivers/oprofile/oprofilefs.c
@@ -130,7 +130,7 @@ static struct file_operations ulong_ro_fops = {
 
 
 static struct dentry * __oprofilefs_create_file(struct super_block * sb,
-        struct dentry * root, char const * name, struct file_operations * fops,
+        struct dentry * root, char const * name, const struct file_operations * fops,
         int perm)
 {
         struct dentry * dentry;
@@ -203,7 +203,7 @@ int oprofilefs_create_ro_atomic(struct super_block * sb, struct dentry * root,
 
  
 int oprofilefs_create_file(struct super_block * sb, struct dentry * root,
-        char const * name, struct file_operations * fops)
+        char const * name, const struct file_operations * fops)
 {
         if (!__oprofilefs_create_file(sb, root, name, fops, 0644))
                 return -EFAULT;
@@ -212,7 +212,7 @@ int oprofilefs_create_file(struct super_block * sb, struct dentry * root,
 
 
 int oprofilefs_create_file_perm(struct super_block * sb, struct dentry * root,
-        char const * name, struct file_operations * fops, int perm)
+        char const * name, const struct file_operations * fops, int perm)
 {
         if (!__oprofilefs_create_file(sb, root, name, fops, perm))
                 return -EFAULT;
diff --git a/drivers/parisc/led.c b/drivers/parisc/led.c
index 3627a2d7f79f..298f2ddb2c17 100644
--- a/drivers/parisc/led.c
+++ b/drivers/parisc/led.c
@@ -499,11 +499,16 @@ static int led_halt(struct notifier_block *, unsigned long, void *);
 static struct notifier_block led_notifier = {
         .notifier_call = led_halt,
 };
+static int notifier_disabled = 0;
 
 static int led_halt(struct notifier_block *nb, unsigned long event, void *buf) 
 {
         char *txt;
-        
+
+        if (notifier_disabled)
+                return NOTIFY_OK;
+
+        notifier_disabled = 1;
         switch (event) {
         case SYS_RESTART:       txt = "SYSTEM RESTART";
                                 break;
@@ -527,7 +532,6 @@ static int led_halt(struct notifier_block *nb, unsigned long event, void *buf)
                 if (led_func_ptr)
                         led_func_ptr(0xff); /* turn all LEDs ON */
         
-        unregister_reboot_notifier(&led_notifier);
         return NOTIFY_OK;
 }
 
@@ -758,6 +762,12 @@ not_found:
         return 1;
 }
 
+static void __exit led_exit(void)
+{
+        unregister_reboot_notifier(&led_notifier);
+        return;
+}
+
 #ifdef CONFIG_PROC_FS
 module_init(led_create_procfs)
 #endif
diff --git a/drivers/parisc/power.c b/drivers/parisc/power.c
index 54b2b7f20b96..0bcab83b4080 100644
--- a/drivers/parisc/power.c
+++ b/drivers/parisc/power.c
@@ -251,7 +251,8 @@ static int __init power_init(void)
         }
 
         /* Register a call for panic conditions. */
-        notifier_chain_register(&panic_notifier_list, &parisc_panic_block);
+        atomic_notifier_chain_register(&panic_notifier_list,
+                        &parisc_panic_block);
 
         tasklet_enable(&power_tasklet);
 
@@ -264,7 +265,8 @@ static void __exit power_exit(void)
                 return;
 
         tasklet_disable(&power_tasklet);
-        notifier_chain_unregister(&panic_notifier_list, &parisc_panic_block);
+        atomic_notifier_chain_unregister(&panic_notifier_list,
+                        &parisc_panic_block);
         power_tasklet.func = NULL;
         pdc_soft_power_button(0);
 }
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index 9302b8fd7461..d5890027f8af 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -3126,9 +3126,9 @@ parport_pc_find_isa_ports (int autoirq, int autodma)
  * autoirq is PARPORT_IRQ_NONE, PARPORT_IRQ_AUTO, or PARPORT_IRQ_PROBEONLY
  * autodma is PARPORT_DMA_NONE or PARPORT_DMA_AUTO
  */
-static int __init parport_pc_find_ports (int autoirq, int autodma)
+static void __init parport_pc_find_ports (int autoirq, int autodma)
 {
-        int count = 0, r;
+        int count = 0, err;
 
 #ifdef CONFIG_PARPORT_PC_SUPERIO
         detect_and_report_winbond ();
@@ -3140,23 +3140,17 @@ static int __init parport_pc_find_ports (int autoirq, int autodma)
 
         /* PnP ports, skip detection if SuperIO already found them */
         if (!count) {
-                r = pnp_register_driver (&parport_pc_pnp_driver);
-                if (r >= 0) {
+                err = pnp_register_driver (&parport_pc_pnp_driver);
+                if (!err)
                         pnp_registered_parport = 1;
-                        count += r;
-                }
         }
 
         /* ISA ports and whatever (see asm/parport.h). */
-        count += parport_pc_find_nonpci_ports (autoirq, autodma);
-
-        r = pci_register_driver (&parport_pc_pci_driver);
-        if (r)
-                return r;
-        pci_registered_parport = 1;
-        count += 1;
+        parport_pc_find_nonpci_ports (autoirq, autodma);
 
-        return count;
+        err = pci_register_driver (&parport_pc_pci_driver);
+        if (!err)
+                pci_registered_parport = 1;
 }
 
 /*
@@ -3381,8 +3375,6 @@ __setup("parport_init_mode=",parport_init_mode_setup);
 
 static int __init parport_pc_init(void)
 {
-        int count = 0;
-
         if (parse_parport_params())
                 return -EINVAL;
 
@@ -3395,12 +3387,11 @@ static int __init parport_pc_init(void)
                                 break;
                         if ((io_hi[i]) == PARPORT_IOHI_AUTO)
                                io_hi[i] = 0x400 + io[i];
-                        if (parport_pc_probe_port(io[i], io_hi[i],
-                                                  irqval[i], dmaval[i], NULL))
-                                count++;
+                        parport_pc_probe_port(io[i], io_hi[i],
+                                                  irqval[i], dmaval[i], NULL);
                 }
         } else
-                count += parport_pc_find_ports (irqval[0], dmaval[0]);
+                parport_pc_find_ports (irqval[0], dmaval[0]);
 
         return 0;
 }
diff --git a/drivers/pnp/card.c b/drivers/pnp/card.c
index b68eef251614..bb19c64073c6 100644
--- a/drivers/pnp/card.c
+++ b/drivers/pnp/card.c
@@ -47,7 +47,7 @@ static void card_remove(struct pnp_dev * dev)
 {
         dev->card_link = NULL;
 }
- 
+
 static void card_remove_first(struct pnp_dev * dev)
 {
         struct pnp_card_driver * drv = to_pnp_card_driver(dev->driver);
@@ -361,7 +361,7 @@ static int card_resume(struct pnp_dev *dev)
 
 int pnp_register_card_driver(struct pnp_card_driver * drv)
 {
-        int count;
+        int error;
         struct list_head *pos, *temp;
 
         drv->link.name = drv->name;
@@ -372,21 +372,19 @@ int pnp_register_card_driver(struct pnp_card_driver * drv)
         drv->link.suspend = drv->suspend ? card_suspend : NULL;
         drv->link.resume = drv->resume ? card_resume : NULL;
 
-        count = pnp_register_driver(&drv->link);
-        if (count < 0)
-                return count;
+        error = pnp_register_driver(&drv->link);
+        if (error < 0)
+                return error;
 
         spin_lock(&pnp_lock);
         list_add_tail(&drv->global_list, &pnp_card_drivers);
         spin_unlock(&pnp_lock);
 
-        count = 0;
-
         list_for_each_safe(pos,temp,&pnp_cards){
                 struct pnp_card *card = list_entry(pos, struct pnp_card, global_list);
-                count += card_probe(card,drv);
+                card_probe(card,drv);
         }
-        return count;
+        return 0;
 }
 
 /**
diff --git a/drivers/pnp/driver.c b/drivers/pnp/driver.c
index 7cafacdd12b0..e54c15383193 100644
--- a/drivers/pnp/driver.c
+++ b/drivers/pnp/driver.c
@@ -201,31 +201,14 @@ struct bus_type pnp_bus_type = {
         .resume = pnp_bus_resume,
 };
 
-
-static int count_devices(struct device * dev, void * c)
-{
-        int * count = c;
-        (*count)++;
-        return 0;
-}
-
 int pnp_register_driver(struct pnp_driver *drv)
 {
-        int count;
-
         pnp_dbg("the driver '%s' has been registered", drv->name);
 
         drv->driver.name = drv->name;
         drv->driver.bus = &pnp_bus_type;
 
-        count = driver_register(&drv->driver);
-
-        /* get the number of initial matches */
-        if (count >= 0){
-                count = 0;
-                driver_for_each_device(&drv->driver, NULL, &count, count_devices);
-        }
-        return count;
+        return driver_register(&drv->driver);
 }
 
 void pnp_unregister_driver(struct pnp_driver *drv)
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
new file mode 100644
index 000000000000..929dd8090578
--- /dev/null
+++ b/drivers/rtc/Kconfig
@@ -0,0 +1,165 @@
+\#
+# RTC class/drivers configuration
+#
+
+menu "Real Time Clock"
+
+config RTC_LIB
+        tristate
+
+config RTC_CLASS
+        tristate "RTC class"
+        depends on EXPERIMENTAL
+        default n
+        select RTC_LIB
+        help
+          Generic RTC class support. If you say yes here, you will
+          be allowed to plug one or more RTCs to your system. You will
+          probably want to enable one of more of the interfaces below.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-class.
+
+config RTC_HCTOSYS
+        bool "Set system time from RTC on startup"
+        depends on RTC_CLASS = y
+        default y
+        help
+          If you say yes here, the system time will be set using
+          the value read from the specified RTC device. This is useful
+          in order to avoid unnecessary fschk runs.
+
+config RTC_HCTOSYS_DEVICE
+        string "The RTC to read the time from"
+        depends on RTC_HCTOSYS = y
+        default "rtc0"
+        help
+          The RTC device that will be used as the source for
+          the system time, usually rtc0.
+
+comment "RTC interfaces"
+        depends on RTC_CLASS
+
+config RTC_INTF_SYSFS
+        tristate "sysfs"
+        depends on RTC_CLASS && SYSFS
+        default RTC_CLASS
+        help
+          Say yes here if you want to use your RTC using the sysfs
+          interface, /sys/class/rtc/rtcX .
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-sysfs.
+
+config RTC_INTF_PROC
+        tristate "proc"
+        depends on RTC_CLASS && PROC_FS
+        default RTC_CLASS
+        help
+          Say yes here if you want to use your RTC using the proc
+          interface, /proc/driver/rtc .
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-proc.
+
+config RTC_INTF_DEV
+        tristate "dev"
+        depends on RTC_CLASS
+        default RTC_CLASS
+        help
+          Say yes here if you want to use your RTC using the dev
+          interface, /dev/rtc .
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-dev.
+
+comment "RTC drivers"
+        depends on RTC_CLASS
+
+config RTC_DRV_X1205
+        tristate "Xicor/Intersil X1205"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for the
+          Xicor/Intersil X1205 RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-x1205.
+
+config RTC_DRV_DS1672
+        tristate "Dallas/Maxim DS1672"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for the
+          Dallas/Maxim DS1672 timekeeping chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds1672.
+
+config RTC_DRV_PCF8563
+        tristate "Philips PCF8563/Epson RTC8564"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for the
+          Philips PCF8563 RTC chip. The Epson RTC8564
+          should work as well.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-pcf8563.
+
+config RTC_DRV_RS5C372
+        tristate "Ricoh RS5C372A/B"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for the
+          Ricoh RS5C372A and RS5C372B RTC chips.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-rs5c372.
+
+config RTC_DRV_M48T86
+        tristate "ST M48T86/Dallas DS12887"
+        depends on RTC_CLASS
+        help
+          If you say Y here you will get support for the
+          ST M48T86 and Dallas DS12887 RTC chips.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-m48t86.
+
+config RTC_DRV_EP93XX
+        tristate "Cirrus Logic EP93XX"
+        depends on RTC_CLASS && ARCH_EP93XX
+        help
+          If you say yes here you get support for the
+          RTC embedded in the Cirrus Logic EP93XX processors.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ep93xx.
+
+config RTC_DRV_SA1100
+        tristate "SA11x0/PXA2xx"
+        depends on RTC_CLASS && (ARCH_SA1100 || ARCH_PXA)
+        help
+          If you say Y here you will get access to the real time clock
+          built into your SA11x0 or PXA2xx CPU.
+
+          To compile this driver as a module, choose M here: the
+          module will be called rtc-sa1100.
+
+config RTC_DRV_TEST
+        tristate "Test driver/device"
+        depends on RTC_CLASS
+        help
+          If you say yes here you get support for the
+          RTC test driver. It's a software RTC which can be
+          used to test the RTC subsystem APIs. It gets
+          the time from the system clock.
+          You want this driver only if you are doing development
+          on the RTC subsystem. Please read the source code
+          for further details.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-test.
+
+endmenu
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
new file mode 100644
index 000000000000..8d4c7fe88d58
--- /dev/null
+++ b/drivers/rtc/Makefile
@@ -0,0 +1,21 @@
+#
+# Makefile for RTC class/drivers.
+#
+
+obj-$(CONFIG_RTC_LIB)           += rtc-lib.o
+obj-$(CONFIG_RTC_HCTOSYS)       += hctosys.o
+obj-$(CONFIG_RTC_CLASS)         += rtc-core.o
+rtc-core-y                      := class.o interface.o
+
+obj-$(CONFIG_RTC_INTF_SYSFS)    += rtc-sysfs.o
+obj-$(CONFIG_RTC_INTF_PROC)     += rtc-proc.o
+obj-$(CONFIG_RTC_INTF_DEV)      += rtc-dev.o
+
+obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
+obj-$(CONFIG_RTC_DRV_TEST)      += rtc-test.o
+obj-$(CONFIG_RTC_DRV_DS1672)    += rtc-ds1672.o
+obj-$(CONFIG_RTC_DRV_PCF8563)   += rtc-pcf8563.o
+obj-$(CONFIG_RTC_DRV_RS5C372)   += rtc-rs5c372.o
+obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
+obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
+obj-$(CONFIG_RTC_DRV_SA1100)    += rtc-sa1100.o
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
new file mode 100644
index 000000000000..8533936d50d8
--- /dev/null
+++ b/drivers/rtc/class.c
@@ -0,0 +1,145 @@
+/*
+ * RTC subsystem, base class
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * class skeleton from drivers/hwmon/hwmon.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.
+*/
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/kdev_t.h>
+#include <linux/idr.h>
+
+static DEFINE_IDR(rtc_idr);
+static DEFINE_MUTEX(idr_lock);
+struct class *rtc_class;
+
+static void rtc_device_release(struct class_device *class_dev)
+{
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+        mutex_lock(&idr_lock);
+        idr_remove(&rtc_idr, rtc->id);
+        mutex_unlock(&idr_lock);
+        kfree(rtc);
+}
+
+/**
+ * rtc_device_register - register w/ RTC class
+ * @dev: the device to register
+ *
+ * rtc_device_unregister() must be called when the class device is no
+ * longer needed.
+ *
+ * Returns the pointer to the new struct class device.
+ */
+struct rtc_device *rtc_device_register(const char *name, struct device *dev,
+                                        struct rtc_class_ops *ops,
+                                        struct module *owner)
+{
+        struct rtc_device *rtc;
+        int id, err;
+
+        if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+
+        mutex_lock(&idr_lock);
+        err = idr_get_new(&rtc_idr, NULL, &id);
+        mutex_unlock(&idr_lock);
+
+        if (err < 0)
+                goto exit;
+
+        id = id & MAX_ID_MASK;
+
+        rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);
+        if (rtc == NULL) {
+                err = -ENOMEM;
+                goto exit_idr;
+        }
+
+        rtc->id = id;
+        rtc->ops = ops;
+        rtc->owner = owner;
+        rtc->class_dev.dev = dev;
+        rtc->class_dev.class = rtc_class;
+        rtc->class_dev.release = rtc_device_release;
+
+        mutex_init(&rtc->ops_lock);
+        spin_lock_init(&rtc->irq_lock);
+        spin_lock_init(&rtc->irq_task_lock);
+
+        strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
+        snprintf(rtc->class_dev.class_id, BUS_ID_SIZE, "rtc%d", id);
+
+        err = class_device_register(&rtc->class_dev);
+        if (err)
+                goto exit_kfree;
+
+        dev_info(dev, "rtc core: registered %s as %s\n",
+                        rtc->name, rtc->class_dev.class_id);
+
+        return rtc;
+
+exit_kfree:
+        kfree(rtc);
+
+exit_idr:
+        idr_remove(&rtc_idr, id);
+
+exit:
+        return ERR_PTR(err);
+}
+EXPORT_SYMBOL_GPL(rtc_device_register);
+
+
+/**
+ * rtc_device_unregister - removes the previously registered RTC class device
+ *
+ * @rtc: the RTC class device to destroy
+ */
+void rtc_device_unregister(struct rtc_device *rtc)
+{
+        mutex_lock(&rtc->ops_lock);
+        rtc->ops = NULL;
+        mutex_unlock(&rtc->ops_lock);
+        class_device_unregister(&rtc->class_dev);
+}
+EXPORT_SYMBOL_GPL(rtc_device_unregister);
+
+int rtc_interface_register(struct class_interface *intf)
+{
+        intf->class = rtc_class;
+        return class_interface_register(intf);
+}
+EXPORT_SYMBOL_GPL(rtc_interface_register);
+
+static int __init rtc_init(void)
+{
+        rtc_class = class_create(THIS_MODULE, "rtc");
+        if (IS_ERR(rtc_class)) {
+                printk(KERN_ERR "%s: couldn't create class\n", __FILE__);
+                return PTR_ERR(rtc_class);
+        }
+        return 0;
+}
+
+static void __exit rtc_exit(void)
+{
+        class_destroy(rtc_class);
+}
+
+module_init(rtc_init);
+module_exit(rtc_exit);
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towerteh.it>");
+MODULE_DESCRIPTION("RTC class support");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/hctosys.c b/drivers/rtc/hctosys.c
new file mode 100644
index 000000000000..d02fe9a0001f
--- /dev/null
+++ b/drivers/rtc/hctosys.c
@@ -0,0 +1,69 @@
+/*
+ * RTC subsystem, initialize system time on startup
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * 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/rtc.h>
+
+/* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
+ * whether it stores the most close value or the value with partial
+ * seconds truncated. However, it is important that we use it to store
+ * the truncated value. This is because otherwise it is necessary,
+ * in an rtc sync function, to read both xtime.tv_sec and
+ * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
+ * of >32bits is not possible. So storing the most close value would
+ * slow down the sync API. So here we have the truncated value and
+ * the best guess is to add 0.5s.
+ */
+
+static int __init rtc_hctosys(void)
+{
+        int err;
+        struct rtc_time tm;
+        struct class_device *class_dev = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
+
+        if (class_dev == NULL) {
+                printk("%s: unable to open rtc device (%s)\n",
+                        __FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
+                return -ENODEV;
+        }
+
+        err = rtc_read_time(class_dev, &tm);
+        if (err == 0) {
+                err = rtc_valid_tm(&tm);
+                if (err == 0) {
+                        struct timespec tv;
+
+                        tv.tv_nsec = NSEC_PER_SEC >> 1;
+
+                        rtc_tm_to_time(&tm, &tv.tv_sec);
+
+                        do_settimeofday(&tv);
+
+                        dev_info(class_dev->dev,
+                                "setting the system clock to "
+                                "%d-%02d-%02d %02d:%02d:%02d (%u)\n",
+                                tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                                tm.tm_hour, tm.tm_min, tm.tm_sec,
+                                (unsigned int) tv.tv_sec);
+                }
+                else
+                        dev_err(class_dev->dev,
+                                "hctosys: invalid date/time\n");
+        }
+        else
+                dev_err(class_dev->dev,
+                        "hctosys: unable to read the hardware clock\n");
+
+        rtc_class_close(class_dev);
+
+        return 0;
+}
+
+late_initcall(rtc_hctosys);
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
new file mode 100644
index 000000000000..56e490709b87
--- /dev/null
+++ b/drivers/rtc/interface.c
@@ -0,0 +1,277 @@
+/*
+ * RTC subsystem, interface functions
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * based on arch/arm/common/rtctime.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.
+*/
+
+#include <linux/rtc.h>
+
+int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->read_time)
+                err = -EINVAL;
+        else {
+                memset(tm, 0, sizeof(struct rtc_time));
+                err = rtc->ops->read_time(class_dev->dev, tm);
+        }
+
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_read_time);
+
+int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = rtc_valid_tm(tm);
+        if (err != 0)
+                return err;
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->set_time)
+                err = -EINVAL;
+        else
+                err = rtc->ops->set_time(class_dev->dev, tm);
+
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_set_time);
+
+int rtc_set_mmss(struct class_device *class_dev, unsigned long secs)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (rtc->ops->set_mmss)
+                err = rtc->ops->set_mmss(class_dev->dev, secs);
+        else if (rtc->ops->read_time && rtc->ops->set_time) {
+                struct rtc_time new, old;
+
+                err = rtc->ops->read_time(class_dev->dev, &old);
+                if (err == 0) {
+                        rtc_time_to_tm(secs, &new);
+
+                        /*
+                         * avoid writing when we're going to change the day of
+                         * the month. We will retry in the next minute. This
+                         * basically means that if the RTC must not drift
+                         * by more than 1 minute in 11 minutes.
+                         */
+                        if (!((old.tm_hour == 23 && old.tm_min == 59) ||
+                                (new.tm_hour == 23 && new.tm_min == 59)))
+                                err = rtc->ops->set_time(class_dev->dev, &new);
+                }
+        }
+        else
+                err = -EINVAL;
+
+        mutex_unlock(&rtc->ops_lock);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_set_mmss);
+
+int rtc_read_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (rtc->ops == NULL)
+                err = -ENODEV;
+        else if (!rtc->ops->read_alarm)
+                err = -EINVAL;
+        else {
+                memset(alarm, 0, sizeof(struct rtc_wkalrm));
+                err = rtc->ops->read_alarm(class_dev->dev, alarm);
+        }
+
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_read_alarm);
+
+int rtc_set_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
+{
+        int err;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return -EBUSY;
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->set_alarm)
+                err = -EINVAL;
+        else
+                err = rtc->ops->set_alarm(class_dev->dev, alarm);
+
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_set_alarm);
+
+void rtc_update_irq(struct class_device *class_dev,
+                unsigned long num, unsigned long events)
+{
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        spin_lock(&rtc->irq_lock);
+        rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
+        spin_unlock(&rtc->irq_lock);
+
+        spin_lock(&rtc->irq_task_lock);
+        if (rtc->irq_task)
+                rtc->irq_task->func(rtc->irq_task->private_data);
+        spin_unlock(&rtc->irq_task_lock);
+
+        wake_up_interruptible(&rtc->irq_queue);
+        kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
+}
+EXPORT_SYMBOL_GPL(rtc_update_irq);
+
+struct class_device *rtc_class_open(char *name)
+{
+        struct class_device *class_dev = NULL,
+                                *class_dev_tmp;
+
+        down(&rtc_class->sem);
+        list_for_each_entry(class_dev_tmp, &rtc_class->children, node) {
+                if (strncmp(class_dev_tmp->class_id, name, BUS_ID_SIZE) == 0) {
+                        class_dev = class_dev_tmp;
+                        break;
+                }
+        }
+
+        if (class_dev) {
+                if (!try_module_get(to_rtc_device(class_dev)->owner))
+                        class_dev = NULL;
+        }
+        up(&rtc_class->sem);
+
+        return class_dev;
+}
+EXPORT_SYMBOL_GPL(rtc_class_open);
+
+void rtc_class_close(struct class_device *class_dev)
+{
+        module_put(to_rtc_device(class_dev)->owner);
+}
+EXPORT_SYMBOL_GPL(rtc_class_close);
+
+int rtc_irq_register(struct class_device *class_dev, struct rtc_task *task)
+{
+        int retval = -EBUSY;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        if (task == NULL || task->func == NULL)
+                return -EINVAL;
+
+        spin_lock(&rtc->irq_task_lock);
+        if (rtc->irq_task == NULL) {
+                rtc->irq_task = task;
+                retval = 0;
+        }
+        spin_unlock(&rtc->irq_task_lock);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(rtc_irq_register);
+
+void rtc_irq_unregister(struct class_device *class_dev, struct rtc_task *task)
+{
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        spin_lock(&rtc->irq_task_lock);
+        if (rtc->irq_task == task)
+                rtc->irq_task = NULL;
+        spin_unlock(&rtc->irq_task_lock);
+}
+EXPORT_SYMBOL_GPL(rtc_irq_unregister);
+
+int rtc_irq_set_state(struct class_device *class_dev, struct rtc_task *task, int enabled)
+{
+        int err = 0;
+        unsigned long flags;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        spin_lock_irqsave(&rtc->irq_task_lock, flags);
+        if (rtc->irq_task != task)
+                err = -ENXIO;
+        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
+
+        if (err == 0)
+                err = rtc->ops->irq_set_state(class_dev->dev, enabled);
+
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_irq_set_state);
+
+int rtc_irq_set_freq(struct class_device *class_dev, struct rtc_task *task, int freq)
+{
+        int err = 0, tmp = 0;
+        unsigned long flags;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        /* allowed range is 2-8192 */
+        if (freq < 2 || freq > 8192)
+                return -EINVAL;
+/*
+        FIXME: this does not belong here, will move where appropriate
+        at a later stage. It cannot hurt right now, trust me :)
+        if ((freq > rtc_max_user_freq) && (!capable(CAP_SYS_RESOURCE)))
+                return -EACCES;
+*/
+        /* check if freq is a power of 2 */
+        while (freq > (1 << tmp))
+                tmp++;
+
+        if (freq != (1 << tmp))
+                return -EINVAL;
+
+        spin_lock_irqsave(&rtc->irq_task_lock, flags);
+        if (rtc->irq_task != task)
+                err = -ENXIO;
+        spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
+
+        if (err == 0) {
+                err = rtc->ops->irq_set_freq(class_dev->dev, freq);
+                if (err == 0)
+                        rtc->irq_freq = freq;
+        }
+        return err;
+}
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
new file mode 100644
index 000000000000..b1e3e6179e56
--- /dev/null
+++ b/drivers/rtc/rtc-dev.c
@@ -0,0 +1,382 @@
+/*
+ * RTC subsystem, dev interface
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * based on arch/arm/common/rtctime.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.
+*/
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+
+static struct class *rtc_dev_class;
+static dev_t rtc_devt;
+
+#define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */
+
+static int rtc_dev_open(struct inode *inode, struct file *file)
+{
+        int err;
+        struct rtc_device *rtc = container_of(inode->i_cdev,
+                                        struct rtc_device, char_dev);
+        struct rtc_class_ops *ops = rtc->ops;
+
+        /* We keep the lock as long as the device is in use
+         * and return immediately if busy
+         */
+        if (!(mutex_trylock(&rtc->char_lock)))
+                return -EBUSY;
+
+        file->private_data = &rtc->class_dev;
+
+        err = ops->open ? ops->open(rtc->class_dev.dev) : 0;
+        if (err == 0) {
+                spin_lock_irq(&rtc->irq_lock);
+                rtc->irq_data = 0;
+                spin_unlock_irq(&rtc->irq_lock);
+
+                return 0;
+        }
+
+        /* something has gone wrong, release the lock */
+        mutex_unlock(&rtc->char_lock);
+        return err;
+}
+
+
+static ssize_t
+rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
+{
+        struct rtc_device *rtc = to_rtc_device(file->private_data);
+
+        DECLARE_WAITQUEUE(wait, current);
+        unsigned long data;
+        ssize_t ret;
+
+        if (count < sizeof(unsigned long))
+                return -EINVAL;
+
+        add_wait_queue(&rtc->irq_queue, &wait);
+        do {
+                __set_current_state(TASK_INTERRUPTIBLE);
+
+                spin_lock_irq(&rtc->irq_lock);
+                data = rtc->irq_data;
+                rtc->irq_data = 0;
+                spin_unlock_irq(&rtc->irq_lock);
+
+                if (data != 0) {
+                        ret = 0;
+                        break;
+                }
+                if (file->f_flags & O_NONBLOCK) {
+                        ret = -EAGAIN;
+                        break;
+                }
+                if (signal_pending(current)) {
+                        ret = -ERESTARTSYS;
+                        break;
+                }
+                schedule();
+        } while (1);
+        set_current_state(TASK_RUNNING);
+        remove_wait_queue(&rtc->irq_queue, &wait);
+
+        if (ret == 0) {
+                /* Check for any data updates */
+                if (rtc->ops->read_callback)
+                        data = rtc->ops->read_callback(rtc->class_dev.dev, data);
+
+                ret = put_user(data, (unsigned long __user *)buf);
+                if (ret == 0)
+                        ret = sizeof(unsigned long);
+        }
+        return ret;
+}
+
+static unsigned int rtc_dev_poll(struct file *file, poll_table *wait)
+{
+        struct rtc_device *rtc = to_rtc_device(file->private_data);
+        unsigned long data;
+
+        poll_wait(file, &rtc->irq_queue, wait);
+
+        data = rtc->irq_data;
+
+        return (data != 0) ? (POLLIN | POLLRDNORM) : 0;
+}
+
+static int rtc_dev_ioctl(struct inode *inode, struct file *file,
+                unsigned int cmd, unsigned long arg)
+{
+        int err = 0;
+        struct class_device *class_dev = file->private_data;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+        struct rtc_class_ops *ops = rtc->ops;
+        struct rtc_time tm;
+        struct rtc_wkalrm alarm;
+        void __user *uarg = (void __user *) arg;
+
+        /* avoid conflicting IRQ users */
+        if (cmd == RTC_PIE_ON || cmd == RTC_PIE_OFF || cmd == RTC_IRQP_SET) {
+                spin_lock(&rtc->irq_task_lock);
+                if (rtc->irq_task)
+                        err = -EBUSY;
+                spin_unlock(&rtc->irq_task_lock);
+
+                if (err < 0)
+                        return err;
+        }
+
+        /* try the driver's ioctl interface */
+        if (ops->ioctl) {
+                err = ops->ioctl(class_dev->dev, cmd, arg);
+                if (err != -EINVAL)
+                        return err;
+        }
+
+        /* if the driver does not provide the ioctl interface
+         * or if that particular ioctl was not implemented
+         * (-EINVAL), we will try to emulate here.
+         */
+
+        switch (cmd) {
+        case RTC_ALM_READ:
+                err = rtc_read_alarm(class_dev, &alarm);
+                if (err < 0)
+                        return err;
+
+                if (copy_to_user(uarg, &alarm.time, sizeof(tm)))
+                        return -EFAULT;
+                break;
+
+        case RTC_ALM_SET:
+                if (copy_from_user(&alarm.time, uarg, sizeof(tm)))
+                        return -EFAULT;
+
+                alarm.enabled = 0;
+                alarm.pending = 0;
+                alarm.time.tm_mday = -1;
+                alarm.time.tm_mon = -1;
+                alarm.time.tm_year = -1;
+                alarm.time.tm_wday = -1;
+                alarm.time.tm_yday = -1;
+                alarm.time.tm_isdst = -1;
+                err = rtc_set_alarm(class_dev, &alarm);
+                break;
+
+        case RTC_RD_TIME:
+                err = rtc_read_time(class_dev, &tm);
+                if (err < 0)
+                        return err;
+
+                if (copy_to_user(uarg, &tm, sizeof(tm)))
+                        return -EFAULT;
+                break;
+
+        case RTC_SET_TIME:
+                if (!capable(CAP_SYS_TIME))
+                        return -EACCES;
+
+                if (copy_from_user(&tm, uarg, sizeof(tm)))
+                        return -EFAULT;
+
+                err = rtc_set_time(class_dev, &tm);
+                break;
+#if 0
+        case RTC_EPOCH_SET:
+#ifndef rtc_epoch
+                /*
+                 * There were no RTC clocks before 1900.
+                 */
+                if (arg < 1900) {
+                        err = -EINVAL;
+                        break;
+                }
+                if (!capable(CAP_SYS_TIME)) {
+                        err = -EACCES;
+                        break;
+                }
+                rtc_epoch = arg;
+                err = 0;
+#endif
+                break;
+
+        case RTC_EPOCH_READ:
+                err = put_user(rtc_epoch, (unsigned long __user *)uarg);
+                break;
+#endif
+        case RTC_WKALM_SET:
+                if (copy_from_user(&alarm, uarg, sizeof(alarm)))
+                        return -EFAULT;
+
+                err = rtc_set_alarm(class_dev, &alarm);
+                break;
+
+        case RTC_WKALM_RD:
+                err = rtc_read_alarm(class_dev, &alarm);
+                if (err < 0)
+                        return err;
+
+                if (copy_to_user(uarg, &alarm, sizeof(alarm)))
+                        return -EFAULT;
+                break;
+
+        default:
+                err = -EINVAL;
+                break;
+        }
+
+        return err;
+}
+
+static int rtc_dev_release(struct inode *inode, struct file *file)
+{
+        struct rtc_device *rtc = to_rtc_device(file->private_data);
+
+        if (rtc->ops->release)
+                rtc->ops->release(rtc->class_dev.dev);
+
+        mutex_unlock(&rtc->char_lock);
+        return 0;
+}
+
+static int rtc_dev_fasync(int fd, struct file *file, int on)
+{
+        struct rtc_device *rtc = to_rtc_device(file->private_data);
+        return fasync_helper(fd, file, on, &rtc->async_queue);
+}
+
+static struct file_operations rtc_dev_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .read           = rtc_dev_read,
+        .poll           = rtc_dev_poll,
+        .ioctl          = rtc_dev_ioctl,
+        .open           = rtc_dev_open,
+        .release        = rtc_dev_release,
+        .fasync         = rtc_dev_fasync,
+};
+
+/* insertion/removal hooks */
+
+static int rtc_dev_add_device(struct class_device *class_dev,
+                                struct class_interface *class_intf)
+{
+        int err = 0;
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        if (rtc->id >= RTC_DEV_MAX) {
+                dev_err(class_dev->dev, "too many RTCs\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&rtc->char_lock);
+        spin_lock_init(&rtc->irq_lock);
+        init_waitqueue_head(&rtc->irq_queue);
+
+        cdev_init(&rtc->char_dev, &rtc_dev_fops);
+        rtc->char_dev.owner = rtc->owner;
+
+        if (cdev_add(&rtc->char_dev, MKDEV(MAJOR(rtc_devt), rtc->id), 1)) {
+                cdev_del(&rtc->char_dev);
+                dev_err(class_dev->dev,
+                        "failed to add char device %d:%d\n",
+                        MAJOR(rtc_devt), rtc->id);
+                return -ENODEV;
+        }
+
+        rtc->rtc_dev = class_device_create(rtc_dev_class, NULL,
+                                                MKDEV(MAJOR(rtc_devt), rtc->id),
+                                                class_dev->dev, "rtc%d", rtc->id);
+        if (IS_ERR(rtc->rtc_dev)) {
+                dev_err(class_dev->dev, "cannot create rtc_dev device\n");
+                err = PTR_ERR(rtc->rtc_dev);
+                goto err_cdev_del;
+        }
+
+        dev_info(class_dev->dev, "rtc intf: dev (%d:%d)\n",
+                MAJOR(rtc->rtc_dev->devt),
+                MINOR(rtc->rtc_dev->devt));
+
+        return 0;
+
+err_cdev_del:
+
+        cdev_del(&rtc->char_dev);
+        return err;
+}
+
+static void rtc_dev_remove_device(struct class_device *class_dev,
+                                        struct class_interface *class_intf)
+{
+        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        if (rtc->rtc_dev) {
+                dev_dbg(class_dev->dev, "removing char %d:%d\n",
+                        MAJOR(rtc->rtc_dev->devt),
+                        MINOR(rtc->rtc_dev->devt));
+
+                class_device_unregister(rtc->rtc_dev);
+                cdev_del(&rtc->char_dev);
+        }
+}
+
+/* interface registration */
+
+static struct class_interface rtc_dev_interface = {
+        .add = &rtc_dev_add_device,
+        .remove = &rtc_dev_remove_device,
+};
+
+static int __init rtc_dev_init(void)
+{
+        int err;
+
+        rtc_dev_class = class_create(THIS_MODULE, "rtc-dev");
+        if (IS_ERR(rtc_dev_class))
+                return PTR_ERR(rtc_dev_class);
+
+        err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");
+        if (err < 0) {
+                printk(KERN_ERR "%s: failed to allocate char dev region\n",
+                        __FILE__);
+                goto err_destroy_class;
+        }
+
+        err = rtc_interface_register(&rtc_dev_interface);
+        if (err < 0) {
+                printk(KERN_ERR "%s: failed to register the interface\n",
+                        __FILE__);
+                goto err_unregister_chrdev;
+        }
+
+        return 0;
+
+err_unregister_chrdev:
+        unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
+
+err_destroy_class:
+        class_destroy(rtc_dev_class);
+
+        return err;
+}
+
+static void __exit rtc_dev_exit(void)
+{
+        class_interface_unregister(&rtc_dev_interface);
+        class_destroy(rtc_dev_class);
+        unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
+}
+
+module_init(rtc_dev_init);
+module_exit(rtc_dev_exit);
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("RTC class dev interface");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
new file mode 100644
index 000000000000..358695a416f3
--- /dev/null
+++ b/drivers/rtc/rtc-ds1672.c
@@ -0,0 +1,233 @@
+/*
+ * An rtc/i2c driver for the Dallas DS1672
+ * Copyright 2005 Alessandro Zummo
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/rtc.h>
+
+#define DRV_VERSION "0.2"
+
+/* Addresses to scan: none. This chip cannot be detected. */
+static unsigned short normal_i2c[] = { I2C_CLIENT_END };
+
+/* Insmod parameters */
+I2C_CLIENT_INSMOD;
+
+/* Registers */
+
+#define DS1672_REG_CNT_BASE     0
+#define DS1672_REG_CONTROL      4
+#define DS1672_REG_TRICKLE      5
+
+
+/* Prototypes */
+static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind);
+
+/*
+ * In the routines that deal directly with the ds1672 hardware, we use
+ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
+ * Epoch is initialized as 2000. Time is set to UTC.
+ */
+static int ds1672_get_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned long time;
+        unsigned char addr = DS1672_REG_CNT_BASE;
+        unsigned char buf[4];
+
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 1, &addr },          /* setup read ptr */
+                { client->addr, I2C_M_RD, 4, buf },     /* read date */
+        };
+
+        /* read date registers */
+        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        dev_dbg(&client->dev,
+                "%s: raw read data - counters=%02x,%02x,%02x,%02x\n"
+                __FUNCTION__,
+                buf[0], buf[1], buf[2], buf[3]);
+
+        time = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
+
+        rtc_time_to_tm(time, tm);
+
+        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        return 0;
+}
+
+static int ds1672_set_mmss(struct i2c_client *client, unsigned long secs)
+{
+        int xfer;
+        unsigned char buf[5];
+
+        buf[0] = DS1672_REG_CNT_BASE;
+        buf[1] = secs & 0x000000FF;
+        buf[2] = (secs & 0x0000FF00) >> 8;
+        buf[3] = (secs & 0x00FF0000) >> 16;
+        buf[4] = (secs & 0xFF000000) >> 24;
+
+        xfer = i2c_master_send(client, buf, 5);
+        if (xfer != 5) {
+                dev_err(&client->dev, "%s: send: %d\n", __FUNCTION__, xfer);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int ds1672_set_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned long secs;
+
+        dev_dbg(&client->dev,
+                "%s: secs=%d, mins=%d, hours=%d, ",
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        rtc_tm_to_time(tm, &secs);
+
+        return ds1672_set_mmss(client, secs);
+}
+
+static int ds1672_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return ds1672_get_datetime(to_i2c_client(dev), tm);
+}
+
+static int ds1672_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return ds1672_set_datetime(to_i2c_client(dev), tm);
+}
+
+static int ds1672_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        return ds1672_set_mmss(to_i2c_client(dev), secs);
+}
+
+static struct rtc_class_ops ds1672_rtc_ops = {
+        .read_time      = ds1672_rtc_read_time,
+        .set_time       = ds1672_rtc_set_time,
+        .set_mmss       = ds1672_rtc_set_mmss,
+};
+
+static int ds1672_attach(struct i2c_adapter *adapter)
+{
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        return i2c_probe(adapter, &addr_data, ds1672_probe);
+}
+
+static int ds1672_detach(struct i2c_client *client)
+{
+        int err;
+        struct rtc_device *rtc = i2c_get_clientdata(client);
+
+        dev_dbg(&client->dev, "%s\n", __FUNCTION__);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        if ((err = i2c_detach_client(client)))
+                return err;
+
+        kfree(client);
+
+        return 0;
+}
+
+static struct i2c_driver ds1672_driver = {
+        .driver         = {
+                .name   = "ds1672",
+        },
+        .id             = I2C_DRIVERID_DS1672,
+        .attach_adapter = &ds1672_attach,
+        .detach_client  = &ds1672_detach,
+};
+
+static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind)
+{
+        int err = 0;
+        struct i2c_client *client;
+        struct rtc_device *rtc;
+
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+                err = -ENODEV;
+                goto exit;
+        }
+
+        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        /* I2C client */
+        client->addr = address;
+        client->driver = &ds1672_driver;
+        client->adapter = adapter;
+
+        strlcpy(client->name, ds1672_driver.driver.name, I2C_NAME_SIZE);
+
+        /* Inform the i2c layer */
+        if ((err = i2c_attach_client(client)))
+                goto exit_kfree;
+
+        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+
+        rtc = rtc_device_register(ds1672_driver.driver.name, &client->dev,
+                                &ds1672_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&client->dev,
+                        "unable to register the class device\n");
+                goto exit_detach;
+        }
+
+        i2c_set_clientdata(client, rtc);
+
+        return 0;
+
+exit_detach:
+        i2c_detach_client(client);
+
+exit_kfree:
+        kfree(client);
+
+exit:
+        return err;
+}
+
+static int __init ds1672_init(void)
+{
+        return i2c_add_driver(&ds1672_driver);
+}
+
+static void __exit ds1672_exit(void)
+{
+        i2c_del_driver(&ds1672_driver);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("Dallas/Maxim DS1672 timekeeper driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(ds1672_init);
+module_exit(ds1672_exit);
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
new file mode 100644
index 000000000000..0dd80ea686a9
--- /dev/null
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -0,0 +1,162 @@
+/*
+ * A driver for the RTC embedded in the Cirrus Logic EP93XX processors
+ * Copyright (c) 2006 Tower Technologies
+ *
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * 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/rtc.h>
+#include <linux/platform_device.h>
+#include <asm/hardware.h>
+
+#define EP93XX_RTC_REG(x)       (EP93XX_RTC_BASE + (x))
+#define EP93XX_RTC_DATA         EP93XX_RTC_REG(0x0000)
+#define EP93XX_RTC_LOAD         EP93XX_RTC_REG(0x000C)
+#define EP93XX_RTC_SWCOMP       EP93XX_RTC_REG(0x0108)
+
+#define DRV_VERSION "0.2"
+
+static int ep93xx_get_swcomp(struct device *dev, unsigned short *preload,
+                                unsigned short *delete)
+{
+        unsigned short comp = __raw_readl(EP93XX_RTC_SWCOMP);
+
+        if (preload)
+                *preload = comp & 0xffff;
+
+        if (delete)
+                *delete = (comp >> 16) & 0x1f;
+
+        return 0;
+}
+
+static int ep93xx_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long time = __raw_readl(EP93XX_RTC_DATA);
+
+        rtc_time_to_tm(time, tm);
+        return 0;
+}
+
+static int ep93xx_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        __raw_writel(secs + 1, EP93XX_RTC_LOAD);
+        return 0;
+}
+
+static int ep93xx_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        int err;
+        unsigned long secs;
+
+        err = rtc_tm_to_time(tm, &secs);
+        if (err != 0)
+                return err;
+
+        return ep93xx_rtc_set_mmss(dev, secs);
+}
+
+static int ep93xx_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        unsigned short preload, delete;
+
+        ep93xx_get_swcomp(dev, &preload, &delete);
+
+        seq_printf(seq, "24hr\t\t: yes\n");
+        seq_printf(seq, "preload\t\t: %d\n", preload);
+        seq_printf(seq, "delete\t\t: %d\n", delete);
+
+        return 0;
+}
+
+static struct rtc_class_ops ep93xx_rtc_ops = {
+        .read_time      = ep93xx_rtc_read_time,
+        .set_time       = ep93xx_rtc_set_time,
+        .set_mmss       = ep93xx_rtc_set_mmss,
+        .proc           = ep93xx_rtc_proc,
+};
+
+static ssize_t ep93xx_sysfs_show_comp_preload(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        unsigned short preload;
+
+        ep93xx_get_swcomp(dev, &preload, NULL);
+
+        return sprintf(buf, "%d\n", preload);
+}
+static DEVICE_ATTR(comp_preload, S_IRUGO, ep93xx_sysfs_show_comp_preload, NULL);
+
+static ssize_t ep93xx_sysfs_show_comp_delete(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        unsigned short delete;
+
+        ep93xx_get_swcomp(dev, NULL, &delete);
+
+        return sprintf(buf, "%d\n", delete);
+}
+static DEVICE_ATTR(comp_delete, S_IRUGO, ep93xx_sysfs_show_comp_delete, NULL);
+
+
+static int __devinit ep93xx_rtc_probe(struct platform_device *dev)
+{
+        struct rtc_device *rtc = rtc_device_register("ep93xx",
+                                &dev->dev, &ep93xx_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                dev_err(&dev->dev, "unable to register\n");
+                return PTR_ERR(rtc);
+        }
+
+        platform_set_drvdata(dev, rtc);
+
+        device_create_file(&dev->dev, &dev_attr_comp_preload);
+        device_create_file(&dev->dev, &dev_attr_comp_delete);
+
+        return 0;
+}
+
+static int __devexit ep93xx_rtc_remove(struct platform_device *dev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(dev);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        platform_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver ep93xx_rtc_platform_driver = {
+        .driver         = {
+                .name   = "ep93xx-rtc",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ep93xx_rtc_probe,
+        .remove         = __devexit_p(ep93xx_rtc_remove),
+};
+
+static int __init ep93xx_rtc_init(void)
+{
+        return platform_driver_register(&ep93xx_rtc_platform_driver);
+}
+
+static void __exit ep93xx_rtc_exit(void)
+{
+        platform_driver_unregister(&ep93xx_rtc_platform_driver);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("EP93XX RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(ep93xx_rtc_init);
+module_exit(ep93xx_rtc_exit);
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
new file mode 100644
index 000000000000..cfedc1d28ee1
--- /dev/null
+++ b/drivers/rtc/rtc-lib.c
@@ -0,0 +1,101 @@
+/*
+ * rtc and date/time utility functions
+ *
+ * Copyright (C) 2005-06 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * based on arch/arm/common/rtctime.c and other bits
+ *
+ * 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/rtc.h>
+
+static const unsigned char rtc_days_in_month[] = {
+        31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
+};
+
+#define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400)
+#define LEAP_YEAR(year) ((!(year % 4) && (year % 100)) || !(year % 400))
+
+int rtc_month_days(unsigned int month, unsigned int year)
+{
+        return rtc_days_in_month[month] + (LEAP_YEAR(year) && month == 1);
+}
+EXPORT_SYMBOL(rtc_month_days);
+
+/*
+ * Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
+ */
+void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
+{
+        register int days, month, year;
+
+        days = time / 86400;
+        time -= days * 86400;
+
+        /* day of the week, 1970-01-01 was a Thursday */
+        tm->tm_wday = (days + 4) % 7;
+
+        year = 1970 + days / 365;
+        days -= (year - 1970) * 365
+                + LEAPS_THRU_END_OF(year - 1)
+                - LEAPS_THRU_END_OF(1970 - 1);
+        if (days < 0) {
+                year -= 1;
+                days += 365 + LEAP_YEAR(year);
+        }
+        tm->tm_year = year - 1900;
+        tm->tm_yday = days + 1;
+
+        for (month = 0; month < 11; month++) {
+                int newdays;
+
+                newdays = days - rtc_month_days(month, year);
+                if (newdays < 0)
+                        break;
+                days = newdays;
+        }
+        tm->tm_mon = month;
+        tm->tm_mday = days + 1;
+
+        tm->tm_hour = time / 3600;
+        time -= tm->tm_hour * 3600;
+        tm->tm_min = time / 60;
+        tm->tm_sec = time - tm->tm_min * 60;
+}
+EXPORT_SYMBOL(rtc_time_to_tm);
+
+/*
+ * Does the rtc_time represent a valid date/time?
+ */
+int rtc_valid_tm(struct rtc_time *tm)
+{
+        if (tm->tm_year < 70
+                || tm->tm_mon >= 12
+                || tm->tm_mday < 1
+                || tm->tm_mday > rtc_month_days(tm->tm_mon, tm->tm_year + 1900)
+                || tm->tm_hour >= 24
+                || tm->tm_min >= 60
+                || tm->tm_sec >= 60)
+                return -EINVAL;
+
+        return 0;
+}
+EXPORT_SYMBOL(rtc_valid_tm);
+
+/*
+ * Convert Gregorian date to seconds since 01-01-1970 00:00:00.
+ */
+int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
+{
+        *time = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+                        tm->tm_hour, tm->tm_min, tm->tm_sec);
+        return 0;
+}
+EXPORT_SYMBOL(rtc_tm_to_time);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-m48t86.c b/drivers/rtc/rtc-m48t86.c
new file mode 100644
index 000000000000..db445c872b1b
--- /dev/null
+++ b/drivers/rtc/rtc-m48t86.c
@@ -0,0 +1,209 @@
+/*
+ * ST M48T86 / Dallas DS12887 RTC driver
+ * Copyright (c) 2006 Tower Technologies
+ *
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This drivers only supports the clock running in BCD and 24H mode.
+ * If it will be ever adapted to binary and 12H mode, care must be taken
+ * to not introduce bugs.
+ */
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/m48t86.h>
+#include <linux/bcd.h>
+
+#define M48T86_REG_SEC          0x00
+#define M48T86_REG_SECALRM      0x01
+#define M48T86_REG_MIN          0x02
+#define M48T86_REG_MINALRM      0x03
+#define M48T86_REG_HOUR 0x04
+#define M48T86_REG_HOURALRM     0x05
+#define M48T86_REG_DOW          0x06 /* 1 = sunday */
+#define M48T86_REG_DOM          0x07
+#define M48T86_REG_MONTH        0x08 /* 1 - 12 */
+#define M48T86_REG_YEAR         0x09 /* 0 - 99 */
+#define M48T86_REG_A            0x0A
+#define M48T86_REG_B            0x0B
+#define M48T86_REG_C            0x0C
+#define M48T86_REG_D            0x0D
+
+#define M48T86_REG_B_H24        (1 << 1)
+#define M48T86_REG_B_DM         (1 << 2)
+#define M48T86_REG_B_SET        (1 << 7)
+#define M48T86_REG_D_VRT        (1 << 7)
+
+#define DRV_VERSION "0.1"
+
+
+static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned char reg;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct m48t86_ops *ops = pdev->dev.platform_data;
+
+        reg = ops->readb(M48T86_REG_B);
+
+        if (reg & M48T86_REG_B_DM) {
+                /* data (binary) mode */
+                tm->tm_sec      = ops->readb(M48T86_REG_SEC);
+                tm->tm_min      = ops->readb(M48T86_REG_MIN);
+                tm->tm_hour     = ops->readb(M48T86_REG_HOUR) & 0x3F;
+                tm->tm_mday     = ops->readb(M48T86_REG_DOM);
+                /* tm_mon is 0-11 */
+                tm->tm_mon      = ops->readb(M48T86_REG_MONTH) - 1;
+                tm->tm_year     = ops->readb(M48T86_REG_YEAR) + 100;
+                tm->tm_wday     = ops->readb(M48T86_REG_DOW);
+        } else {
+                /* bcd mode */
+                tm->tm_sec      = BCD2BIN(ops->readb(M48T86_REG_SEC));
+                tm->tm_min      = BCD2BIN(ops->readb(M48T86_REG_MIN));
+                tm->tm_hour     = BCD2BIN(ops->readb(M48T86_REG_HOUR) & 0x3F);
+                tm->tm_mday     = BCD2BIN(ops->readb(M48T86_REG_DOM));
+                /* tm_mon is 0-11 */
+                tm->tm_mon      = BCD2BIN(ops->readb(M48T86_REG_MONTH)) - 1;
+                tm->tm_year     = BCD2BIN(ops->readb(M48T86_REG_YEAR)) + 100;
+                tm->tm_wday     = BCD2BIN(ops->readb(M48T86_REG_DOW));
+        }
+
+        /* correct the hour if the clock is in 12h mode */
+        if (!(reg & M48T86_REG_B_H24))
+                if (ops->readb(M48T86_REG_HOUR) & 0x80)
+                        tm->tm_hour += 12;
+
+        return 0;
+}
+
+static int m48t86_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned char reg;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct m48t86_ops *ops = pdev->dev.platform_data;
+
+        reg = ops->readb(M48T86_REG_B);
+
+        /* update flag and 24h mode */
+        reg |= M48T86_REG_B_SET | M48T86_REG_B_H24;
+        ops->writeb(reg, M48T86_REG_B);
+
+        if (reg & M48T86_REG_B_DM) {
+                /* data (binary) mode */
+                ops->writeb(tm->tm_sec, M48T86_REG_SEC);
+                ops->writeb(tm->tm_min, M48T86_REG_MIN);
+                ops->writeb(tm->tm_hour, M48T86_REG_HOUR);
+                ops->writeb(tm->tm_mday, M48T86_REG_DOM);
+                ops->writeb(tm->tm_mon + 1, M48T86_REG_MONTH);
+                ops->writeb(tm->tm_year % 100, M48T86_REG_YEAR);
+                ops->writeb(tm->tm_wday, M48T86_REG_DOW);
+        } else {
+                /* bcd mode */
+                ops->writeb(BIN2BCD(tm->tm_sec), M48T86_REG_SEC);
+                ops->writeb(BIN2BCD(tm->tm_min), M48T86_REG_MIN);
+                ops->writeb(BIN2BCD(tm->tm_hour), M48T86_REG_HOUR);
+                ops->writeb(BIN2BCD(tm->tm_mday), M48T86_REG_DOM);
+                ops->writeb(BIN2BCD(tm->tm_mon + 1), M48T86_REG_MONTH);
+                ops->writeb(BIN2BCD(tm->tm_year % 100), M48T86_REG_YEAR);
+                ops->writeb(BIN2BCD(tm->tm_wday), M48T86_REG_DOW);
+        }
+
+        /* update ended */
+        reg &= ~M48T86_REG_B_SET;
+        ops->writeb(reg, M48T86_REG_B);
+
+        return 0;
+}
+
+static int m48t86_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        unsigned char reg;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct m48t86_ops *ops = pdev->dev.platform_data;
+
+        reg = ops->readb(M48T86_REG_B);
+
+        seq_printf(seq, "24hr\t\t: %s\n",
+                 (reg & M48T86_REG_B_H24) ? "yes" : "no");
+
+        seq_printf(seq, "mode\t\t: %s\n",
+                 (reg & M48T86_REG_B_DM) ? "binary" : "bcd");
+
+        reg = ops->readb(M48T86_REG_D);
+
+        seq_printf(seq, "battery\t\t: %s\n",
+                 (reg & M48T86_REG_D_VRT) ? "ok" : "exhausted");
+
+        return 0;
+}
+
+static struct rtc_class_ops m48t86_rtc_ops = {
+        .read_time      = m48t86_rtc_read_time,
+        .set_time       = m48t86_rtc_set_time,
+        .proc           = m48t86_rtc_proc,
+};
+
+static int __devinit m48t86_rtc_probe(struct platform_device *dev)
+{
+        unsigned char reg;
+        struct m48t86_ops *ops = dev->dev.platform_data;
+        struct rtc_device *rtc = rtc_device_register("m48t86",
+                                &dev->dev, &m48t86_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                dev_err(&dev->dev, "unable to register\n");
+                return PTR_ERR(rtc);
+        }
+
+        platform_set_drvdata(dev, rtc);
+
+        /* read battery status */
+        reg = ops->readb(M48T86_REG_D);
+        dev_info(&dev->dev, "battery %s\n",
+                (reg & M48T86_REG_D_VRT) ? "ok" : "exhausted");
+
+        return 0;
+}
+
+static int __devexit m48t86_rtc_remove(struct platform_device *dev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(dev);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        platform_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver m48t86_rtc_platform_driver = {
+        .driver         = {
+                .name   = "rtc-m48t86",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = m48t86_rtc_probe,
+        .remove         = __devexit_p(m48t86_rtc_remove),
+};
+
+static int __init m48t86_rtc_init(void)
+{
+        return platform_driver_register(&m48t86_rtc_platform_driver);
+}
+
+static void __exit m48t86_rtc_exit(void)
+{
+        platform_driver_unregister(&m48t86_rtc_platform_driver);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("M48T86 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(m48t86_rtc_init);
+module_exit(m48t86_rtc_exit);
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
new file mode 100644
index 000000000000..d857d45bdbe8
--- /dev/null
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -0,0 +1,353 @@
+/*
+ * An I2C driver for the Philips PCF8563 RTC
+ * Copyright 2005-06 Tower Technologies
+ *
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ * Maintainers: http://www.nslu2-linux.org/
+ *
+ * based on the other drivers in this same directory.
+ *
+ * http://www.semiconductors.philips.com/acrobat/datasheets/PCF8563-04.pdf
+ *
+ * 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/i2c.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+
+#define DRV_VERSION "0.4.2"
+
+/* Addresses to scan: none
+ * This chip cannot be reliably autodetected. An empty eeprom
+ * located at 0x51 will pass the validation routine due to
+ * the way the registers are implemented.
+ */
+static unsigned short normal_i2c[] = { I2C_CLIENT_END };
+
+/* Module parameters */
+I2C_CLIENT_INSMOD;
+
+#define PCF8563_REG_ST1         0x00 /* status */
+#define PCF8563_REG_ST2         0x01
+
+#define PCF8563_REG_SC          0x02 /* datetime */
+#define PCF8563_REG_MN          0x03
+#define PCF8563_REG_HR          0x04
+#define PCF8563_REG_DM          0x05
+#define PCF8563_REG_DW          0x06
+#define PCF8563_REG_MO          0x07
+#define PCF8563_REG_YR          0x08
+
+#define PCF8563_REG_AMN         0x09 /* alarm */
+#define PCF8563_REG_AHR         0x0A
+#define PCF8563_REG_ADM         0x0B
+#define PCF8563_REG_ADW         0x0C
+
+#define PCF8563_REG_CLKO        0x0D /* clock out */
+#define PCF8563_REG_TMRC        0x0E /* timer control */
+#define PCF8563_REG_TMR         0x0F /* timer */
+
+#define PCF8563_SC_LV           0x80 /* low voltage */
+#define PCF8563_MO_C            0x80 /* century */
+
+static int pcf8563_probe(struct i2c_adapter *adapter, int address, int kind);
+static int pcf8563_detach(struct i2c_client *client);
+
+/*
+ * In the routines that deal directly with the pcf8563 hardware, we use
+ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
+ */
+static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned char buf[13] = { PCF8563_REG_ST1 };
+
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 1, buf },    /* setup read ptr */
+                { client->addr, I2C_M_RD, 13, buf },    /* read status + date */
+        };
+
+        /* read registers */
+        if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        if (buf[PCF8563_REG_SC] & PCF8563_SC_LV)
+                dev_info(&client->dev,
+                        "low voltage detected, date/time is not reliable.\n");
+
+        dev_dbg(&client->dev,
+                "%s: raw data is st1=%02x, st2=%02x, sec=%02x, min=%02x, hr=%02x, "
+                "mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
+                __FUNCTION__,
+                buf[0], buf[1], buf[2], buf[3],
+                buf[4], buf[5], buf[6], buf[7],
+                buf[8]);
+
+
+        tm->tm_sec = BCD2BIN(buf[PCF8563_REG_SC] & 0x7F);
+        tm->tm_min = BCD2BIN(buf[PCF8563_REG_MN] & 0x7F);
+        tm->tm_hour = BCD2BIN(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */
+        tm->tm_mday = BCD2BIN(buf[PCF8563_REG_DM] & 0x3F);
+        tm->tm_wday = buf[PCF8563_REG_DW] & 0x07;
+        tm->tm_mon = BCD2BIN(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
+        tm->tm_year = BCD2BIN(buf[PCF8563_REG_YR])
+                + (buf[PCF8563_REG_MO] & PCF8563_MO_C ? 100 : 0);
+
+        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        /* the clock can give out invalid datetime, but we cannot return
+         * -EINVAL otherwise hwclock will refuse to set the time on bootup.
+         */
+        if (rtc_valid_tm(tm) < 0)
+                dev_err(&client->dev, "retrieved date/time is not valid.\n");
+
+        return 0;
+}
+
+static int pcf8563_set_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        int i, err;
+        unsigned char buf[9];
+
+        dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        /* hours, minutes and seconds */
+        buf[PCF8563_REG_SC] = BIN2BCD(tm->tm_sec);
+        buf[PCF8563_REG_MN] = BIN2BCD(tm->tm_min);
+        buf[PCF8563_REG_HR] = BIN2BCD(tm->tm_hour);
+
+        buf[PCF8563_REG_DM] = BIN2BCD(tm->tm_mday);
+
+        /* month, 1 - 12 */
+        buf[PCF8563_REG_MO] = BIN2BCD(tm->tm_mon + 1);
+
+        /* year and century */
+        buf[PCF8563_REG_YR] = BIN2BCD(tm->tm_year % 100);
+        if (tm->tm_year / 100)
+                buf[PCF8563_REG_MO] |= PCF8563_MO_C;
+
+        buf[PCF8563_REG_DW] = tm->tm_wday & 0x07;
+
+        /* write register's data */
+        for (i = 0; i < 7; i++) {
+                unsigned char data[2] = { PCF8563_REG_SC + i,
+                                                buf[PCF8563_REG_SC + i] };
+
+                err = i2c_master_send(client, data, sizeof(data));
+                if (err != sizeof(data)) {
+                        dev_err(&client->dev,
+                                "%s: err=%d addr=%02x, data=%02x\n",
+                                __FUNCTION__, err, data[0], data[1]);
+                        return -EIO;
+                }
+        };
+
+        return 0;
+}
+
+struct pcf8563_limit
+{
+        unsigned char reg;
+        unsigned char mask;
+        unsigned char min;
+        unsigned char max;
+};
+
+static int pcf8563_validate_client(struct i2c_client *client)
+{
+        int i;
+
+        static const struct pcf8563_limit pattern[] = {
+                /* register, mask, min, max */
+                { PCF8563_REG_SC,       0x7F,   0,      59      },
+                { PCF8563_REG_MN,       0x7F,   0,      59      },
+                { PCF8563_REG_HR,       0x3F,   0,      23      },
+                { PCF8563_REG_DM,       0x3F,   0,      31      },
+                { PCF8563_REG_MO,       0x1F,   0,      12      },
+        };
+
+        /* check limits (only registers with bcd values) */
+        for (i = 0; i < ARRAY_SIZE(pattern); i++) {
+                int xfer;
+                unsigned char value;
+                unsigned char buf = pattern[i].reg;
+
+                struct i2c_msg msgs[] = {
+                        { client->addr, 0, 1, &buf },
+                        { client->addr, I2C_M_RD, 1, &buf },
+                };
+
+                xfer = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+
+                if (xfer != ARRAY_SIZE(msgs)) {
+                        dev_err(&client->adapter->dev,
+                                "%s: could not read register 0x%02X\n",
+                                __FUNCTION__, pattern[i].reg);
+
+                        return -EIO;
+                }
+
+                value = BCD2BIN(buf & pattern[i].mask);
+
+                if (value > pattern[i].max ||
+                        value < pattern[i].min) {
+                        dev_dbg(&client->adapter->dev,
+                                "%s: pattern=%d, reg=%x, mask=0x%02x, min=%d, "
+                                "max=%d, value=%d, raw=0x%02X\n",
+                                __FUNCTION__, i, pattern[i].reg, pattern[i].mask,
+                                pattern[i].min, pattern[i].max,
+                                value, buf);
+
+                        return -ENODEV;
+                }
+        }
+
+        return 0;
+}
+
+static int pcf8563_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return pcf8563_get_datetime(to_i2c_client(dev), tm);
+}
+
+static int pcf8563_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return pcf8563_set_datetime(to_i2c_client(dev), tm);
+}
+
+static int pcf8563_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        seq_printf(seq, "24hr\t\t: yes\n");
+        return 0;
+}
+
+static struct rtc_class_ops pcf8563_rtc_ops = {
+        .proc           = pcf8563_rtc_proc,
+        .read_time      = pcf8563_rtc_read_time,
+        .set_time       = pcf8563_rtc_set_time,
+};
+
+static int pcf8563_attach(struct i2c_adapter *adapter)
+{
+        return i2c_probe(adapter, &addr_data, pcf8563_probe);
+}
+
+static struct i2c_driver pcf8563_driver = {
+        .driver         = {
+                .name   = "pcf8563",
+        },
+        .id             = I2C_DRIVERID_PCF8563,
+        .attach_adapter = &pcf8563_attach,
+        .detach_client  = &pcf8563_detach,
+};
+
+static int pcf8563_probe(struct i2c_adapter *adapter, int address, int kind)
+{
+        struct i2c_client *client;
+        struct rtc_device *rtc;
+
+        int err = 0;
+
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+                err = -ENODEV;
+                goto exit;
+        }
+
+        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        client->addr = address;
+        client->driver = &pcf8563_driver;
+        client->adapter = adapter;
+
+        strlcpy(client->name, pcf8563_driver.driver.name, I2C_NAME_SIZE);
+
+        /* Verify the chip is really an PCF8563 */
+        if (kind < 0) {
+                if (pcf8563_validate_client(client) < 0) {
+                        err = -ENODEV;
+                        goto exit_kfree;
+                }
+        }
+
+        /* Inform the i2c layer */
+        if ((err = i2c_attach_client(client)))
+                goto exit_kfree;
+
+        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+
+        rtc = rtc_device_register(pcf8563_driver.driver.name, &client->dev,
+                                &pcf8563_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&client->dev,
+                        "unable to register the class device\n");
+                goto exit_detach;
+        }
+
+        i2c_set_clientdata(client, rtc);
+
+        return 0;
+
+exit_detach:
+        i2c_detach_client(client);
+
+exit_kfree:
+        kfree(client);
+
+exit:
+        return err;
+}
+
+static int pcf8563_detach(struct i2c_client *client)
+{
+        int err;
+        struct rtc_device *rtc = i2c_get_clientdata(client);
+
+        dev_dbg(&client->dev, "%s\n", __FUNCTION__);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        if ((err = i2c_detach_client(client)))
+                return err;
+
+        kfree(client);
+
+        return 0;
+}
+
+static int __init pcf8563_init(void)
+{
+        return i2c_add_driver(&pcf8563_driver);
+}
+
+static void __exit pcf8563_exit(void)
+{
+        i2c_del_driver(&pcf8563_driver);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("Philips PCF8563/Epson RTC8564 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(pcf8563_init);
+module_exit(pcf8563_exit);
diff --git a/drivers/rtc/rtc-proc.c b/drivers/rtc/rtc-proc.c
new file mode 100644
index 000000000000..90b8a97a0919
--- /dev/null
+++ b/drivers/rtc/rtc-proc.c
@@ -0,0 +1,162 @@
+/*
+ * RTC subsystem, proc interface
+ *
+ * Copyright (C) 2005-06 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * based on arch/arm/common/rtctime.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.
+*/
+
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+
+static struct class_device *rtc_dev = NULL;
+static DEFINE_MUTEX(rtc_lock);
+
+static int rtc_proc_show(struct seq_file *seq, void *offset)
+{
+        int err;
+        struct class_device *class_dev = seq->private;
+        struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops;
+        struct rtc_wkalrm alrm;
+        struct rtc_time tm;
+
+        err = rtc_read_time(class_dev, &tm);
+        if (err == 0) {
+                seq_printf(seq,
+                        "rtc_time\t: %02d:%02d:%02d\n"
+                        "rtc_date\t: %04d-%02d-%02d\n",
+                        tm.tm_hour, tm.tm_min, tm.tm_sec,
+                        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
+        }
+
+        err = rtc_read_alarm(class_dev, &alrm);
+        if (err == 0) {
+                seq_printf(seq, "alrm_time\t: ");
+                if ((unsigned int)alrm.time.tm_hour <= 24)
+                        seq_printf(seq, "%02d:", alrm.time.tm_hour);
+                else
+                        seq_printf(seq, "**:");
+                if ((unsigned int)alrm.time.tm_min <= 59)
+                        seq_printf(seq, "%02d:", alrm.time.tm_min);
+                else
+                        seq_printf(seq, "**:");
+                if ((unsigned int)alrm.time.tm_sec <= 59)
+                        seq_printf(seq, "%02d\n", alrm.time.tm_sec);
+                else
+                        seq_printf(seq, "**\n");
+
+                seq_printf(seq, "alrm_date\t: ");
+                if ((unsigned int)alrm.time.tm_year <= 200)
+                        seq_printf(seq, "%04d-", alrm.time.tm_year + 1900);
+                else
+                        seq_printf(seq, "****-");
+                if ((unsigned int)alrm.time.tm_mon <= 11)
+                        seq_printf(seq, "%02d-", alrm.time.tm_mon + 1);
+                else
+                        seq_printf(seq, "**-");
+                if ((unsigned int)alrm.time.tm_mday <= 31)
+                        seq_printf(seq, "%02d\n", alrm.time.tm_mday);
+                else
+                        seq_printf(seq, "**\n");
+                seq_printf(seq, "alrm_wakeup\t: %s\n",
+                                alrm.enabled ? "yes" : "no");
+                seq_printf(seq, "alrm_pending\t: %s\n",
+                                alrm.pending ? "yes" : "no");
+        }
+
+        if (ops->proc)
+                ops->proc(class_dev->dev, seq);
+
+        return 0;
+}
+
+static int rtc_proc_open(struct inode *inode, struct file *file)
+{
+        struct class_device *class_dev = PDE(inode)->data;
+
+        if (!try_module_get(THIS_MODULE))
+                return -ENODEV;
+
+        return single_open(file, rtc_proc_show, class_dev);
+}
+
+static int rtc_proc_release(struct inode *inode, struct file *file)
+{
+        int res = single_release(inode, file);
+        module_put(THIS_MODULE);
+        return res;
+}
+
+static struct file_operations rtc_proc_fops = {
+        .open           = rtc_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = rtc_proc_release,
+};
+
+static int rtc_proc_add_device(struct class_device *class_dev,
+                                        struct class_interface *class_intf)
+{
+        mutex_lock(&rtc_lock);
+        if (rtc_dev == NULL) {
+                struct proc_dir_entry *ent;
+
+                rtc_dev = class_dev;
+
+                ent = create_proc_entry("driver/rtc", 0, NULL);
+                if (ent) {
+                        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+                        ent->proc_fops = &rtc_proc_fops;
+                        ent->owner = rtc->owner;
+                        ent->data = class_dev;
+
+                        dev_info(class_dev->dev, "rtc intf: proc\n");
+                }
+                else
+                        rtc_dev = NULL;
+        }
+        mutex_unlock(&rtc_lock);
+
+        return 0;
+}
+
+static void rtc_proc_remove_device(struct class_device *class_dev,
+                                        struct class_interface *class_intf)
+{
+        mutex_lock(&rtc_lock);
+        if (rtc_dev == class_dev) {
+                remove_proc_entry("driver/rtc", NULL);
+                rtc_dev = NULL;
+        }
+        mutex_unlock(&rtc_lock);
+}
+
+static struct class_interface rtc_proc_interface = {
+        .add = &rtc_proc_add_device,
+        .remove = &rtc_proc_remove_device,
+};
+
+static int __init rtc_proc_init(void)
+{
+        return rtc_interface_register(&rtc_proc_interface);
+}
+
+static void __exit rtc_proc_exit(void)
+{
+        class_interface_unregister(&rtc_proc_interface);
+}
+
+module_init(rtc_proc_init);
+module_exit(rtc_proc_exit);
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("RTC class proc interface");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
new file mode 100644
index 000000000000..396c8681f66c
--- /dev/null
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -0,0 +1,294 @@
+/*
+ * An I2C driver for the Ricoh RS5C372 RTC
+ *
+ * Copyright (C) 2005 Pavel Mironchik <pmironchik@optifacio.net>
+ * Copyright (C) 2006 Tower Technologies
+ *
+ * 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/i2c.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+
+#define DRV_VERSION "0.2"
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { /* 0x32,*/ I2C_CLIENT_END };
+
+/* Insmod parameters */
+I2C_CLIENT_INSMOD;
+
+#define RS5C372_REG_SECS        0
+#define RS5C372_REG_MINS        1
+#define RS5C372_REG_HOURS       2
+#define RS5C372_REG_WDAY        3
+#define RS5C372_REG_DAY         4
+#define RS5C372_REG_MONTH       5
+#define RS5C372_REG_YEAR        6
+#define RS5C372_REG_TRIM        7
+
+#define RS5C372_TRIM_XSL        0x80
+#define RS5C372_TRIM_MASK       0x7F
+
+#define RS5C372_REG_BASE        0
+
+static int rs5c372_attach(struct i2c_adapter *adapter);
+static int rs5c372_detach(struct i2c_client *client);
+static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind);
+
+static struct i2c_driver rs5c372_driver = {
+        .driver         = {
+                .name   = "rs5c372",
+        },
+        .attach_adapter = &rs5c372_attach,
+        .detach_client  = &rs5c372_detach,
+};
+
+static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned char buf[7] = { RS5C372_REG_BASE };
+
+        /* this implements the 1st reading method, according
+         * to the datasheet. buf[0] is initialized with
+         * address ptr and transmission format register.
+         */
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 1, buf },
+                { client->addr, I2C_M_RD, 7, buf },
+        };
+
+        if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        tm->tm_sec = BCD2BIN(buf[RS5C372_REG_SECS] & 0x7f);
+        tm->tm_min = BCD2BIN(buf[RS5C372_REG_MINS] & 0x7f);
+        tm->tm_hour = BCD2BIN(buf[RS5C372_REG_HOURS] & 0x3f);
+        tm->tm_wday = BCD2BIN(buf[RS5C372_REG_WDAY] & 0x07);
+        tm->tm_mday = BCD2BIN(buf[RS5C372_REG_DAY] & 0x3f);
+
+        /* tm->tm_mon is zero-based */
+        tm->tm_mon = BCD2BIN(buf[RS5C372_REG_MONTH] & 0x1f) - 1;
+
+        /* year is 1900 + tm->tm_year */
+        tm->tm_year = BCD2BIN(buf[RS5C372_REG_YEAR]) + 100;
+
+        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__,
+                tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        return 0;
+}
+
+static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
+        unsigned char buf[8] = { RS5C372_REG_BASE };
+
+        dev_dbg(&client->dev,
+                "%s: secs=%d, mins=%d, hours=%d ",
+                "mday=%d, mon=%d, year=%d, wday=%d\n",
+                __FUNCTION__, tm->tm_sec, tm->tm_min, tm->tm_hour,
+                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
+        buf[1] = BIN2BCD(tm->tm_sec);
+        buf[2] = BIN2BCD(tm->tm_min);
+        buf[3] = BIN2BCD(tm->tm_hour);
+        buf[4] = BIN2BCD(tm->tm_wday);
+        buf[5] = BIN2BCD(tm->tm_mday);
+        buf[6] = BIN2BCD(tm->tm_mon + 1);
+        buf[7] = BIN2BCD(tm->tm_year - 100);
+
+        if ((i2c_master_send(client, buf, 8)) != 8) {
+                dev_err(&client->dev, "%s: write error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
+{
+        unsigned char buf = RS5C372_REG_TRIM;
+
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 1, &buf },
+                { client->addr, I2C_M_RD, 1, &buf },
+        };
+
+        if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        dev_dbg(&client->dev, "%s: raw trim=%x\n", __FUNCTION__, trim);
+
+        if (osc)
+                *osc = (buf & RS5C372_TRIM_XSL) ? 32000 : 32768;
+
+        if (trim)
+                *trim = buf & RS5C372_TRIM_MASK;
+
+        return 0;
+}
+
+static int rs5c372_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return rs5c372_get_datetime(to_i2c_client(dev), tm);
+}
+
+static int rs5c372_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return rs5c372_set_datetime(to_i2c_client(dev), tm);
+}
+
+static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        int err, osc, trim;
+
+        seq_printf(seq, "24hr\t\t: yes\n");
+
+        if ((err = rs5c372_get_trim(to_i2c_client(dev), &osc, &trim)) == 0) {
+                seq_printf(seq, "%d.%03d KHz\n", osc / 1000, osc % 1000);
+                seq_printf(seq, "trim\t: %d\n", trim);
+        }
+
+        return 0;
+}
+
+static struct rtc_class_ops rs5c372_rtc_ops = {
+        .proc           = rs5c372_rtc_proc,
+        .read_time      = rs5c372_rtc_read_time,
+        .set_time       = rs5c372_rtc_set_time,
+};
+
+static ssize_t rs5c372_sysfs_show_trim(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int trim;
+
+        if (rs5c372_get_trim(to_i2c_client(dev), NULL, &trim) == 0)
+                return sprintf(buf, "0x%2x\n", trim);
+
+        return 0;
+}
+static DEVICE_ATTR(trim, S_IRUGO, rs5c372_sysfs_show_trim, NULL);
+
+static ssize_t rs5c372_sysfs_show_osc(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int osc;
+
+        if (rs5c372_get_trim(to_i2c_client(dev), &osc, NULL) == 0)
+                return sprintf(buf, "%d.%03d KHz\n", osc / 1000, osc % 1000);
+
+        return 0;
+}
+static DEVICE_ATTR(osc, S_IRUGO, rs5c372_sysfs_show_osc, NULL);
+
+static int rs5c372_attach(struct i2c_adapter *adapter)
+{
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        return i2c_probe(adapter, &addr_data, rs5c372_probe);
+}
+
+static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind)
+{
+        int err = 0;
+        struct i2c_client *client;
+        struct rtc_device *rtc;
+
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+                err = -ENODEV;
+                goto exit;
+        }
+
+        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        /* I2C client */
+        client->addr = address;
+        client->driver = &rs5c372_driver;
+        client->adapter = adapter;
+
+        strlcpy(client->name, rs5c372_driver.driver.name, I2C_NAME_SIZE);
+
+        /* Inform the i2c layer */
+        if ((err = i2c_attach_client(client)))
+                goto exit_kfree;
+
+        dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+
+        rtc = rtc_device_register(rs5c372_driver.driver.name, &client->dev,
+                                &rs5c372_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&client->dev,
+                        "unable to register the class device\n");
+                goto exit_detach;
+        }
+
+        i2c_set_clientdata(client, rtc);
+
+        device_create_file(&client->dev, &dev_attr_trim);
+        device_create_file(&client->dev, &dev_attr_osc);
+
+        return 0;
+
+exit_detach:
+        i2c_detach_client(client);
+
+exit_kfree:
+        kfree(client);
+
+exit:
+        return err;
+}
+
+static int rs5c372_detach(struct i2c_client *client)
+{
+        int err;
+        struct rtc_device *rtc = i2c_get_clientdata(client);
+
+        dev_dbg(&client->dev, "%s\n", __FUNCTION__);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        if ((err = i2c_detach_client(client)))
+                return err;
+
+        kfree(client);
+
+        return 0;
+}
+
+static __init int rs5c372_init(void)
+{
+        return i2c_add_driver(&rs5c372_driver);
+}
+
+static __exit void rs5c372_exit(void)
+{
+        i2c_del_driver(&rs5c372_driver);
+}
+
+module_init(rs5c372_init);
+module_exit(rs5c372_exit);
+
+MODULE_AUTHOR(
+                "Pavel Mironchik <pmironchik@optifacio.net>, "
+                "Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("Ricoh RS5C372 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
new file mode 100644
index 000000000000..83b2bb480a16
--- /dev/null
+++ b/drivers/rtc/rtc-sa1100.c
@@ -0,0 +1,388 @@
+/*
+ * Real Time Clock interface for StrongARM SA1x00 and XScale PXA2xx
+ *
+ * Copyright (c) 2000 Nils Faerber
+ *
+ * Based on rtc.c by Paul Gortmaker
+ *
+ * Original Driver by Nils Faerber <nils@kernelconcepts.de>
+ *
+ * Modifications from:
+ *   CIH <cih@coventive.com>
+ *   Nicolas Pitre <nico@cam.org>
+ *   Andrew Christian <andrew.christian@hp.com>
+ *
+ * Converted to the RTC subsystem and Driver Model
+ *   by Richard Purdie <rpurdie@rpsys.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/interrupt.h>
+#include <linux/string.h>
+#include <linux/pm.h>
+
+#include <asm/bitops.h>
+#include <asm/hardware.h>
+#include <asm/irq.h>
+#include <asm/rtc.h>
+
+#ifdef CONFIG_ARCH_PXA
+#include <asm/arch/pxa-regs.h>
+#endif
+
+#define TIMER_FREQ              CLOCK_TICK_RATE
+#define RTC_DEF_DIVIDER         32768 - 1
+#define RTC_DEF_TRIM            0
+
+static unsigned long rtc_freq = 1024;
+static struct rtc_time rtc_alarm;
+static spinlock_t sa1100_rtc_lock = SPIN_LOCK_UNLOCKED;
+
+static int rtc_update_alarm(struct rtc_time *alrm)
+{
+        struct rtc_time alarm_tm, now_tm;
+        unsigned long now, time;
+        int ret;
+
+        do {
+                now = RCNR;
+                rtc_time_to_tm(now, &now_tm);
+                rtc_next_alarm_time(&alarm_tm, &now_tm, alrm);
+                ret = rtc_tm_to_time(&alarm_tm, &time);
+                if (ret != 0)
+                        break;
+
+                RTSR = RTSR & (RTSR_HZE|RTSR_ALE|RTSR_AL);
+                RTAR = time;
+        } while (now != RCNR);
+
+        return ret;
+}
+
+static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id,
+                struct pt_regs *regs)
+{
+        struct platform_device *pdev = to_platform_device(dev_id);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        unsigned int rtsr;
+        unsigned long events = 0;
+
+        spin_lock(&sa1100_rtc_lock);
+
+        rtsr = RTSR;
+        /* clear interrupt sources */
+        RTSR = 0;
+        RTSR = (RTSR_AL | RTSR_HZ) & (rtsr >> 2);
+
+        /* clear alarm interrupt if it has occurred */
+        if (rtsr & RTSR_AL)
+                rtsr &= ~RTSR_ALE;
+        RTSR = rtsr & (RTSR_ALE | RTSR_HZE);
+
+        /* update irq data & counter */
+        if (rtsr & RTSR_AL)
+                events |= RTC_AF | RTC_IRQF;
+        if (rtsr & RTSR_HZ)
+                events |= RTC_UF | RTC_IRQF;
+
+        rtc_update_irq(&rtc->class_dev, 1, events);
+
+        if (rtsr & RTSR_AL && rtc_periodic_alarm(&rtc_alarm))
+                rtc_update_alarm(&rtc_alarm);
+
+        spin_unlock(&sa1100_rtc_lock);
+
+        return IRQ_HANDLED;
+}
+
+static int rtc_timer1_count;
+
+static irqreturn_t timer1_interrupt(int irq, void *dev_id,
+                struct pt_regs *regs)
+{
+        struct platform_device *pdev = to_platform_device(dev_id);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+
+        /*
+         * If we match for the first time, rtc_timer1_count will be 1.
+         * Otherwise, we wrapped around (very unlikely but
+         * still possible) so compute the amount of missed periods.
+         * The match reg is updated only when the data is actually retrieved
+         * to avoid unnecessary interrupts.
+         */
+        OSSR = OSSR_M1; /* clear match on timer1 */
+
+        rtc_update_irq(&rtc->class_dev, rtc_timer1_count, RTC_PF | RTC_IRQF);
+
+        if (rtc_timer1_count == 1)
+                rtc_timer1_count = (rtc_freq * ((1<<30)/(TIMER_FREQ>>2)));
+
+        return IRQ_HANDLED;
+}
+
+static int sa1100_rtc_read_callback(struct device *dev, int data)
+{
+        if (data & RTC_PF) {
+                /* interpolate missed periods and set match for the next */
+                unsigned long period = TIMER_FREQ/rtc_freq;
+                unsigned long oscr = OSCR;
+                unsigned long osmr1 = OSMR1;
+                unsigned long missed = (oscr - osmr1)/period;
+                data += missed << 8;
+                OSSR = OSSR_M1; /* clear match on timer 1 */
+                OSMR1 = osmr1 + (missed + 1)*period;
+                /* Ensure we didn't miss another match in the mean time.
+                 * Here we compare (match - OSCR) 8 instead of 0 --
+                 * see comment in pxa_timer_interrupt() for explanation.
+                 */
+                while( (signed long)((osmr1 = OSMR1) - OSCR) <= 8 ) {
+                        data += 0x100;
+                        OSSR = OSSR_M1; /* clear match on timer 1 */
+                        OSMR1 = osmr1 + period;
+                }
+        }
+        return data;
+}
+
+static int sa1100_rtc_open(struct device *dev)
+{
+        int ret;
+
+        ret = request_irq(IRQ_RTC1Hz, sa1100_rtc_interrupt, SA_INTERRUPT,
+                                "rtc 1Hz", dev);
+        if (ret) {
+                printk(KERN_ERR "rtc: IRQ%d already in use.\n", IRQ_RTC1Hz);
+                goto fail_ui;
+        }
+        ret = request_irq(IRQ_RTCAlrm, sa1100_rtc_interrupt, SA_INTERRUPT,
+                                "rtc Alrm", dev);
+        if (ret) {
+                printk(KERN_ERR "rtc: IRQ%d already in use.\n", IRQ_RTCAlrm);
+                goto fail_ai;
+        }
+        ret = request_irq(IRQ_OST1, timer1_interrupt, SA_INTERRUPT,
+                                "rtc timer", dev);
+        if (ret) {
+                printk(KERN_ERR "rtc: IRQ%d already in use.\n", IRQ_OST1);
+                goto fail_pi;
+        }
+        return 0;
+
+ fail_pi:
+        free_irq(IRQ_RTCAlrm, NULL);
+ fail_ai:
+        free_irq(IRQ_RTC1Hz, NULL);
+ fail_ui:
+        return ret;
+}
+
+static void sa1100_rtc_release(struct device *dev)
+{
+        spin_lock_irq(&sa1100_rtc_lock);
+        RTSR = 0;
+        OIER &= ~OIER_E1;
+        OSSR = OSSR_M1;
+        spin_unlock_irq(&sa1100_rtc_lock);
+
+        free_irq(IRQ_OST1, dev);
+        free_irq(IRQ_RTCAlrm, dev);
+        free_irq(IRQ_RTC1Hz, dev);
+}
+
+
+static int sa1100_rtc_ioctl(struct device *dev, unsigned int cmd,
+                unsigned long arg)
+{
+        switch(cmd) {
+        case RTC_AIE_OFF:
+                spin_lock_irq(&sa1100_rtc_lock);
+                RTSR &= ~RTSR_ALE;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_AIE_ON:
+                spin_lock_irq(&sa1100_rtc_lock);
+                RTSR |= RTSR_ALE;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_UIE_OFF:
+                spin_lock_irq(&sa1100_rtc_lock);
+                RTSR &= ~RTSR_HZE;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_UIE_ON:
+                spin_lock_irq(&sa1100_rtc_lock);
+                RTSR |= RTSR_HZE;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_PIE_OFF:
+                spin_lock_irq(&sa1100_rtc_lock);
+                OIER &= ~OIER_E1;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_PIE_ON:
+                if ((rtc_freq > 64) && !capable(CAP_SYS_RESOURCE))
+                        return -EACCES;
+                spin_lock_irq(&sa1100_rtc_lock);
+                OSMR1 = TIMER_FREQ/rtc_freq + OSCR;
+                OIER |= OIER_E1;
+                rtc_timer1_count = 1;
+                spin_unlock_irq(&sa1100_rtc_lock);
+                return 0;
+        case RTC_IRQP_READ:
+                return put_user(rtc_freq, (unsigned long *)arg);
+        case RTC_IRQP_SET:
+                if (arg < 1 || arg > TIMER_FREQ)
+                        return -EINVAL;
+                if ((arg > 64) && (!capable(CAP_SYS_RESOURCE)))
+                        return -EACCES;
+                rtc_freq = arg;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+static int sa1100_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        rtc_time_to_tm(RCNR, tm);
+        return 0;
+}
+
+static int sa1100_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long time;
+        int ret;
+
+        ret = rtc_tm_to_time(tm, &time);
+        if (ret == 0)
+                RCNR = time;
+        return ret;
+}
+
+static int sa1100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        memcpy(&alrm->time, &rtc_alarm, sizeof(struct rtc_time));
+        alrm->pending = RTSR & RTSR_AL ? 1 : 0;
+        return 0;
+}
+
+static int sa1100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        int ret;
+
+        spin_lock_irq(&sa1100_rtc_lock);
+        ret = rtc_update_alarm(&alrm->time);
+        if (ret == 0) {
+                memcpy(&rtc_alarm, &alrm->time, sizeof(struct rtc_time));
+
+                if (alrm->enabled)
+                        enable_irq_wake(IRQ_RTCAlrm);
+                else
+                        disable_irq_wake(IRQ_RTCAlrm);
+        }
+        spin_unlock_irq(&sa1100_rtc_lock);
+
+        return ret;
+}
+
+static int sa1100_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        seq_printf(seq, "trim/divider\t: 0x%08x\n", RTTR);
+        seq_printf(seq, "alarm_IRQ\t: %s\n",
+                        (RTSR & RTSR_ALE) ? "yes" : "no" );
+        seq_printf(seq, "update_IRQ\t: %s\n",
+                        (RTSR & RTSR_HZE) ? "yes" : "no");
+        seq_printf(seq, "periodic_IRQ\t: %s\n",
+                        (OIER & OIER_E1) ? "yes" : "no");
+        seq_printf(seq, "periodic_freq\t: %ld\n", rtc_freq);
+
+        return 0;
+}
+
+static struct rtc_class_ops sa1100_rtc_ops = {
+        .open = sa1100_rtc_open,
+        .read_callback = sa1100_rtc_read_callback,
+        .release = sa1100_rtc_release,
+        .ioctl = sa1100_rtc_ioctl,
+        .read_time = sa1100_rtc_read_time,
+        .set_time = sa1100_rtc_set_time,
+        .read_alarm = sa1100_rtc_read_alarm,
+        .set_alarm = sa1100_rtc_set_alarm,
+        .proc = sa1100_rtc_proc,
+};
+
+static int sa1100_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+
+        /*
+         * According to the manual we should be able to let RTTR be zero
+         * and then a default diviser for a 32.768KHz clock is used.
+         * Apparently this doesn't work, at least for my SA1110 rev 5.
+         * If the clock divider is uninitialized then reset it to the
+         * default value to get the 1Hz clock.
+         */
+        if (RTTR == 0) {
+                RTTR = RTC_DEF_DIVIDER + (RTC_DEF_TRIM << 16);
+                printk(KERN_WARNING "rtc: warning: initializing default clock divider/trim value\n");
+                /* The current RTC value probably doesn't make sense either */
+                RCNR = 0;
+        }
+
+        rtc = rtc_device_register(pdev->name, &pdev->dev, &sa1100_rtc_ops,
+                                THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                dev_err(&pdev->dev, "Unable to register the RTC device\n");
+                return PTR_ERR(rtc);
+        }
+
+        platform_set_drvdata(pdev, rtc);
+
+        dev_info(&pdev->dev, "SA11xx/PXA2xx RTC Registered\n");
+
+        return 0;
+}
+
+static int sa1100_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        return 0;
+}
+
+static struct platform_driver sa1100_rtc_driver = {
+        .probe          = sa1100_rtc_probe,
+        .remove         = sa1100_rtc_remove,
+        .driver         = {
+                .name           = "sa1100-rtc",
+        },
+};
+
+static int __init sa1100_rtc_init(void)
+{
+        return platform_driver_register(&sa1100_rtc_driver);
+}
+
+static void __exit sa1100_rtc_exit(void)
+{
+        platform_driver_unregister(&sa1100_rtc_driver);
+}
+
+module_init(sa1100_rtc_init);
+module_exit(sa1100_rtc_exit);
+
+MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
+MODULE_DESCRIPTION("SA11x0/PXA2xx Realtime Clock Driver (RTC)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
new file mode 100644
index 000000000000..7c1f3d2e53c4
--- /dev/null
+++ b/drivers/rtc/rtc-sysfs.c
@@ -0,0 +1,124 @@
+/*
+ * RTC subsystem, sysfs interface
+ *
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * 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/rtc.h>
+
+/* device attributes */
+
+static ssize_t rtc_sysfs_show_name(struct class_device *dev, char *buf)
+{
+        return sprintf(buf, "%s\n", to_rtc_device(dev)->name);
+}
+static CLASS_DEVICE_ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL);
+
+static ssize_t rtc_sysfs_show_date(struct class_device *dev, char *buf)
+{
+        ssize_t retval;
+        struct rtc_time tm;
+
+        retval = rtc_read_time(dev, &tm);
+        if (retval == 0) {
+                retval = sprintf(buf, "%04d-%02d-%02d\n",
+                        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
+        }
+
+        return retval;
+}
+static CLASS_DEVICE_ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL);
+
+static ssize_t rtc_sysfs_show_time(struct class_device *dev, char *buf)
+{
+        ssize_t retval;
+        struct rtc_time tm;
+
+        retval = rtc_read_time(dev, &tm);
+        if (retval == 0) {
+                retval = sprintf(buf, "%02d:%02d:%02d\n",
+                        tm.tm_hour, tm.tm_min, tm.tm_sec);
+        }
+
+        return retval;
+}
+static CLASS_DEVICE_ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL);
+
+static ssize_t rtc_sysfs_show_since_epoch(struct class_device *dev, char *buf)
+{
+        ssize_t retval;
+        struct rtc_time tm;
+
+        retval = rtc_read_time(dev, &tm);
+        if (retval == 0) {
+                unsigned long time;
+                rtc_tm_to_time(&tm, &time);
+                retval = sprintf(buf, "%lu\n", time);
+        }
+
+        return retval;
+}
+static CLASS_DEVICE_ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL);
+
+static struct attribute *rtc_attrs[] = {
+        &class_device_attr_name.attr,
+        &class_device_attr_date.attr,
+        &class_device_attr_time.attr,
+        &class_device_attr_since_epoch.attr,
+        NULL,
+};
+
+static struct attribute_group rtc_attr_group = {
+        .attrs = rtc_attrs,
+};
+
+static int __devinit rtc_sysfs_add_device(struct class_device *class_dev,
+                                        struct class_interface *class_intf)
+{
+        int err;
+
+        dev_info(class_dev->dev, "rtc intf: sysfs\n");
+
+        err = sysfs_create_group(&class_dev->kobj, &rtc_attr_group);
+        if (err)
+                dev_err(class_dev->dev,
+                        "failed to create sysfs attributes\n");
+
+        return err;
+}
+
+static void rtc_sysfs_remove_device(struct class_device *class_dev,
+                                struct class_interface *class_intf)
+{
+        sysfs_remove_group(&class_dev->kobj, &rtc_attr_group);
+}
+
+/* interface registration */
+
+static struct class_interface rtc_sysfs_interface = {
+        .add = &rtc_sysfs_add_device,
+        .remove = &rtc_sysfs_remove_device,
+};
+
+static int __init rtc_sysfs_init(void)
+{
+        return rtc_interface_register(&rtc_sysfs_interface);
+}
+
+static void __exit rtc_sysfs_exit(void)
+{
+        class_interface_unregister(&rtc_sysfs_interface);
+}
+
+module_init(rtc_sysfs_init);
+module_exit(rtc_sysfs_exit);
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("RTC class sysfs interface");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-test.c b/drivers/rtc/rtc-test.c
new file mode 100644
index 000000000000..43d107487820
--- /dev/null
+++ b/drivers/rtc/rtc-test.c
@@ -0,0 +1,204 @@
+/*
+ * An RTC test device/driver
+ * Copyright (C) 2005 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * 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/err.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+
+static struct platform_device *test0 = NULL, *test1 = NULL;
+
+static int test_rtc_read_alarm(struct device *dev,
+        struct rtc_wkalrm *alrm)
+{
+        return 0;
+}
+
+static int test_rtc_set_alarm(struct device *dev,
+        struct rtc_wkalrm *alrm)
+{
+        return 0;
+}
+
+static int test_rtc_read_time(struct device *dev,
+        struct rtc_time *tm)
+{
+        rtc_time_to_tm(get_seconds(), tm);
+        return 0;
+}
+
+static int test_rtc_set_time(struct device *dev,
+        struct rtc_time *tm)
+{
+        return 0;
+}
+
+static int test_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        return 0;
+}
+
+static int test_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        struct platform_device *plat_dev = to_platform_device(dev);
+
+        seq_printf(seq, "24hr\t\t: yes\n");
+        seq_printf(seq, "test\t\t: yes\n");
+        seq_printf(seq, "id\t\t: %d\n", plat_dev->id);
+
+        return 0;
+}
+
+static int test_rtc_ioctl(struct device *dev, unsigned int cmd,
+        unsigned long arg)
+{
+        /* We do support interrupts, they're generated
+         * using the sysfs interface.
+         */
+        switch (cmd) {
+        case RTC_PIE_ON:
+        case RTC_PIE_OFF:
+        case RTC_UIE_ON:
+        case RTC_UIE_OFF:
+        case RTC_AIE_ON:
+        case RTC_AIE_OFF:
+                return 0;
+
+        default:
+                return -EINVAL;
+        }
+}
+
+static struct rtc_class_ops test_rtc_ops = {
+        .proc = test_rtc_proc,
+        .read_time = test_rtc_read_time,
+        .set_time = test_rtc_set_time,
+        .read_alarm = test_rtc_read_alarm,
+        .set_alarm = test_rtc_set_alarm,
+        .set_mmss = test_rtc_set_mmss,
+        .ioctl = test_rtc_ioctl,
+};
+
+static ssize_t test_irq_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "%d\n", 42);
+}
+static ssize_t test_irq_store(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        int retval;
+        struct platform_device *plat_dev = to_platform_device(dev);
+        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
+
+        retval = count;
+        if (strncmp(buf, "tick", 4) == 0)
+                rtc_update_irq(&rtc->class_dev, 1, RTC_PF | RTC_IRQF);
+        else if (strncmp(buf, "alarm", 5) == 0)
+                rtc_update_irq(&rtc->class_dev, 1, RTC_AF | RTC_IRQF);
+        else if (strncmp(buf, "update", 6) == 0)
+                rtc_update_irq(&rtc->class_dev, 1, RTC_UF | RTC_IRQF);
+        else
+                retval = -EINVAL;
+
+        return retval;
+}
+static DEVICE_ATTR(irq, S_IRUGO | S_IWUSR, test_irq_show, test_irq_store);
+
+static int test_probe(struct platform_device *plat_dev)
+{
+        int err;
+        struct rtc_device *rtc = rtc_device_register("test", &plat_dev->dev,
+                                                &test_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&plat_dev->dev,
+                        "unable to register the class device\n");
+                return err;
+        }
+        device_create_file(&plat_dev->dev, &dev_attr_irq);
+
+        platform_set_drvdata(plat_dev, rtc);
+
+        return 0;
+}
+
+static int __devexit test_remove(struct platform_device *plat_dev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(plat_dev);
+
+        rtc_device_unregister(rtc);
+        device_remove_file(&plat_dev->dev, &dev_attr_irq);
+
+        return 0;
+}
+
+static struct platform_driver test_drv = {
+        .probe  = test_probe,
+        .remove = __devexit_p(test_remove),
+        .driver = {
+                .name = "rtc-test",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init test_init(void)
+{
+        int err;
+
+        if ((err = platform_driver_register(&test_drv)))
+                return err;
+
+        if ((test0 = platform_device_alloc("rtc-test", 0)) == NULL) {
+                err = -ENOMEM;
+                goto exit_driver_unregister;
+        }
+
+        if ((test1 = platform_device_alloc("rtc-test", 1)) == NULL) {
+                err = -ENOMEM;
+                goto exit_free_test0;
+        }
+
+        if ((err = platform_device_add(test0)))
+                goto exit_free_test1;
+
+        if ((err = platform_device_add(test1)))
+                goto exit_device_unregister;
+
+        return 0;
+
+exit_device_unregister:
+        platform_device_unregister(test0);
+
+exit_free_test1:
+        platform_device_put(test1);
+
+exit_free_test0:
+        platform_device_put(test0);
+
+exit_driver_unregister:
+        platform_driver_unregister(&test_drv);
+        return err;
+}
+
+static void __exit test_exit(void)
+{
+        platform_device_unregister(test0);
+        platform_device_unregister(test1);
+        platform_driver_unregister(&test_drv);
+}
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("RTC test driver/device");
+MODULE_LICENSE("GPL");
+
+module_init(test_init);
+module_exit(test_exit);
diff --git a/drivers/i2c/chips/x1205.c b/drivers/rtc/rtc-x1205.c
index 245fffa92dbd..621d17afc0d9 100644
--- a/drivers/i2c/chips/x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -1,32 +1,25 @@
 /*
- *  x1205.c - An i2c driver for the Xicor X1205 RTC
- *  Copyright 2004 Karen Spearel
- *  Copyright 2005 Alessandro Zummo
+ * An i2c driver for the Xicor/Intersil X1205 RTC
+ * Copyright 2004 Karen Spearel
+ * Copyright 2005 Alessandro Zummo
  *
- *  please send all reports to:
- *      kas11 at tampabay dot rr dot com
- *      a dot zummo at towertech dot it
+ * please send all reports to:
+ *      Karen Spearel <kas111 at gmail dot com>
+ *      Alessandro Zummo <a.zummo@towertech.it>
  *
- *  based on the other drivers in this same directory.
+ * based on a lot of other RTC drivers.
  *
- *  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 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/slab.h>
 #include <linux/i2c.h>
-#include <linux/string.h>
 #include <linux/bcd.h>
 #include <linux/rtc.h>
-#include <linux/list.h>
+#include <linux/delay.h>
 
-#include <linux/x1205.h>
-
-#define DRV_VERSION "0.9.9"
+#define DRV_VERSION "1.0.6"
 
 /* Addresses to scan: none. This chip is located at
  * 0x6f and uses a two bytes register addressing.
@@ -40,8 +33,6 @@ static unsigned short normal_i2c[] = { I2C_CLIENT_END };
 
 /* Insmod parameters */
 I2C_CLIENT_INSMOD;
-I2C_CLIENT_MODULE_PARM(hctosys,
-        "Set the system time from the hardware clock upon initialization");
 
 /* offsets into CCR area */
 
@@ -101,107 +92,35 @@ I2C_CLIENT_MODULE_PARM(hctosys,
 static int x1205_attach(struct i2c_adapter *adapter);
 static int x1205_detach(struct i2c_client *client);
 static int x1205_probe(struct i2c_adapter *adapter, int address, int kind);
-static int x1205_command(struct i2c_client *client, unsigned int cmd,
-        void *arg);
 
 static struct i2c_driver x1205_driver = {
-        .driver = {
+        .driver         = {
                 .name   = "x1205",
         },
+        .id             = I2C_DRIVERID_X1205,
         .attach_adapter = &x1205_attach,
         .detach_client  = &x1205_detach,
 };
 
-struct x1205_data {
-        struct i2c_client client;
-        struct list_head list;
-        unsigned int epoch;
-};
-
-static const unsigned char days_in_mo[] =
-        { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-static LIST_HEAD(x1205_clients);
-
-/* Workaround until the I2C subsytem will allow to send
- * commands to a specific client. This function will send the command
- * to the first client.
- */
-int x1205_do_command(unsigned int cmd, void *arg)
-{
-        struct list_head *walk;
-        struct list_head *tmp;
-        struct x1205_data *data;
-
-        list_for_each_safe(walk, tmp, &x1205_clients) {
-                data = list_entry(walk, struct x1205_data, list);
-                return x1205_command(&data->client, cmd, arg);
-        }
-
-        return -ENODEV;
-}
-
-#define is_leap(year) \
-        ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
-
-/* make sure the rtc_time values are in bounds */
-static int x1205_validate_tm(struct rtc_time *tm)
-{
-        int year = tm->tm_year + 1900;
-
-        if ((tm->tm_year < 70) || (tm->tm_year > 255))
-                return -EINVAL;
-
-        if ((tm->tm_mon > 11) || (tm->tm_mday == 0))
-                return -EINVAL;
-
-        if (tm->tm_mday > days_in_mo[tm->tm_mon]
-                + ((tm->tm_mon == 1) && is_leap(year)))
-                return -EINVAL;
-
-        if ((tm->tm_hour >= 24) || (tm->tm_min >= 60) || (tm->tm_sec >= 60))
-                return -EINVAL;
-
-        return 0;
-}
-
 /*
  * In the routines that deal directly with the x1205 hardware, we use
  * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
  * Epoch is initialized as 2000. Time is set to UTC.
  */
 static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
-                                u8 reg_base)
+                                unsigned char reg_base)
 {
         unsigned char dt_addr[2] = { 0, reg_base };
-        static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
 
-        unsigned char buf[8], sr;
+        unsigned char buf[8];
 
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 2, sr_addr },        /* setup read ptr */
-                { client->addr, I2C_M_RD, 1, &sr },     /* read status */
                 { client->addr, 0, 2, dt_addr },        /* setup read ptr */
                 { client->addr, I2C_M_RD, 8, buf },     /* read date */
         };
 
-        struct x1205_data *data = i2c_get_clientdata(client);
-
-        /* read status register */
-        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
-                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
-                return -EIO;
-        }
-
-        /* check for battery failure */
-        if (sr & X1205_SR_RTCF) {
-                dev_warn(&client->dev,
-                        "Clock had a power failure, you must set the date.\n");
-                return -EINVAL;
-        }
-
         /* read date registers */
-        if ((i2c_transfer(client->adapter, &msgs[2], 2)) != 2) {
+        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
                 dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
                 return -EIO;
         }
@@ -217,9 +136,9 @@ static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
         tm->tm_min = BCD2BIN(buf[CCR_MIN]);
         tm->tm_hour = BCD2BIN(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
         tm->tm_mday = BCD2BIN(buf[CCR_MDAY]);
-        tm->tm_mon = BCD2BIN(buf[CCR_MONTH]);
-        data->epoch = BCD2BIN(buf[CCR_Y2K]) * 100;
-        tm->tm_year = BCD2BIN(buf[CCR_YEAR]) + data->epoch - 1900;
+        tm->tm_mon = BCD2BIN(buf[CCR_MONTH]) - 1; /* mon is 0-11 */
+        tm->tm_year = BCD2BIN(buf[CCR_YEAR])
+                        + (BCD2BIN(buf[CCR_Y2K]) * 100) - 1900;
         tm->tm_wday = buf[CCR_WDAY];
 
         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
@@ -231,11 +150,28 @@ static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
         return 0;
 }
 
+static int x1205_get_status(struct i2c_client *client, unsigned char *sr)
+{
+        static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
+
+        struct i2c_msg msgs[] = {
+                { client->addr, 0, 2, sr_addr },        /* setup read ptr */
+                { client->addr, I2C_M_RD, 1, sr },      /* read status */
+        };
+
+        /* read status register */
+        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+                dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+                return -EIO;
+        }
+
+        return 0;
+}
+
 static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
                                 int datetoo, u8 reg_base)
 {
-        int i, err, xfer;
-
+        int i, xfer;
         unsigned char buf[8];
 
         static const unsigned char wel[3] = { 0, X1205_REG_SR,
@@ -246,17 +182,10 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
 
         static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 };
 
-        struct x1205_data *data = i2c_get_clientdata(client);
-
-        /* check if all values in the tm struct are correct */
-        if ((err = x1205_validate_tm(tm)) < 0)
-                return err;
-
-        dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
-                "mday=%d, mon=%d, year=%d, wday=%d\n",
+        dev_dbg(&client->dev,
+                "%s: secs=%d, mins=%d, hours=%d\n",
                 __FUNCTION__,
-                tm->tm_sec, tm->tm_min, tm->tm_hour,
-                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+                tm->tm_sec, tm->tm_min, tm->tm_hour);
 
         buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
         buf[CCR_MIN] = BIN2BCD(tm->tm_min);
@@ -266,26 +195,29 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
 
         /* should we also set the date? */
         if (datetoo) {
+                dev_dbg(&client->dev,
+                        "%s: mday=%d, mon=%d, year=%d, wday=%d\n",
+                        __FUNCTION__,
+                        tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+
                 buf[CCR_MDAY] = BIN2BCD(tm->tm_mday);
 
-                /* month, 0 - 11 */
-                buf[CCR_MONTH] = BIN2BCD(tm->tm_mon);
+                /* month, 1 - 12 */
+                buf[CCR_MONTH] = BIN2BCD(tm->tm_mon + 1);
 
-                /* year, since 1900 */
-                buf[CCR_YEAR] = BIN2BCD(tm->tm_year + 1900 - data->epoch);
+                /* year, since the rtc epoch*/
+                buf[CCR_YEAR] = BIN2BCD(tm->tm_year % 100);
                 buf[CCR_WDAY] = tm->tm_wday & 0x07;
-                buf[CCR_Y2K] = BIN2BCD(data->epoch / 100);
+                buf[CCR_Y2K] = BIN2BCD(tm->tm_year / 100);
         }
 
         /* this sequence is required to unlock the chip */
-        xfer = i2c_master_send(client, wel, 3);
-        if (xfer != 3) {
+        if ((xfer = i2c_master_send(client, wel, 3)) != 3) {
                 dev_err(&client->dev, "%s: wel - %d\n", __FUNCTION__, xfer);
                 return -EIO;
         }
 
-        xfer = i2c_master_send(client, rwel, 3);
-        if (xfer != 3) {
+        if ((xfer = i2c_master_send(client, rwel, 3)) != 3) {
                 dev_err(&client->dev, "%s: rwel - %d\n", __FUNCTION__, xfer);
                 return -EIO;
         }
@@ -305,8 +237,7 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
         };
 
         /* disable further writes */
-        xfer = i2c_master_send(client, diswe, 3);
-        if (xfer != 3) {
+        if ((xfer = i2c_master_send(client, diswe, 3)) != 3) {
                 dev_err(&client->dev, "%s: diswe - %d\n", __FUNCTION__, xfer);
                 return -EIO;
         }
@@ -314,6 +245,20 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
         return 0;
 }
 
+static int x1205_fix_osc(struct i2c_client *client)
+{
+        int err;
+        struct rtc_time tm;
+
+        tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
+
+        if ((err = x1205_set_datetime(client, &tm, 0, X1205_CCR_BASE)) < 0)
+                dev_err(&client->dev,
+                        "unable to restart the oscillator\n");
+
+        return err;
+}
+
 static int x1205_get_dtrim(struct i2c_client *client, int *trim)
 {
         unsigned char dtr;
@@ -380,60 +325,9 @@ static int x1205_get_atrim(struct i2c_client *client, int *trim)
         return 0;
 }
 
-static int x1205_hctosys(struct i2c_client *client)
-{
-        int err;
-
-        struct rtc_time tm;
-        struct timespec tv;
-
-        err = x1205_command(client, X1205_CMD_GETDATETIME, &tm);
-
-        if (err) {
-                dev_err(&client->dev,
-                        "Unable to set the system clock\n");
-                return err;
-        }
-
-        /* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
-         * whether it stores the most close value or the value with partial
-         * seconds truncated. However, it is important that we use it to store
-         * the truncated value. This is because otherwise it is necessary,
-         * in an rtc sync function, to read both xtime.tv_sec and
-         * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
-         * of >32bits is not possible. So storing the most close value would
-         * slow down the sync API. So here we have the truncated value and
-         * the best guess is to add 0.5s.
-         */
-
-        tv.tv_nsec = NSEC_PER_SEC >> 1;
-
-        /* WARNING: this is not the C library 'mktime' call, it is a built in
-         * inline function from include/linux/time.h.  It expects (requires)
-         * the month to be in the range 1-12
-         */
-
-        tv.tv_sec  = mktime(tm.tm_year + 1900, tm.tm_mon + 1,
-                                tm.tm_mday, tm.tm_hour,
-                                tm.tm_min, tm.tm_sec);
-
-        do_settimeofday(&tv);
-
-        dev_info(&client->dev,
-                "setting the system clock to %d-%d-%d %d:%d:%d\n",
-                tm.tm_year + 1900, tm.tm_mon + 1,
-                tm.tm_mday, tm.tm_hour, tm.tm_min,
-                tm.tm_sec);
-
-        return 0;
-}
-
 struct x1205_limit
 {
-        unsigned char reg;
-        unsigned char mask;
-        unsigned char min;
-        unsigned char max;
+        unsigned char reg, mask, min, max;
 };
 
 static int x1205_validate_client(struct i2c_client *client)
@@ -477,11 +371,10 @@ static int x1205_validate_client(struct i2c_client *client)
                         { client->addr, I2C_M_RD, 1, &buf },
                 };
 
-                xfer = i2c_transfer(client->adapter, msgs, 2);
-                if (xfer != 2) {
+                if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
                         dev_err(&client->adapter->dev,
                                 "%s: could not read register %x\n",
-                                __FUNCTION__, addr[1]);
+                                __FUNCTION__, probe_zero_pattern[i]);
 
                         return -EIO;
                 }
@@ -489,7 +382,7 @@ static int x1205_validate_client(struct i2c_client *client)
                 if ((buf & probe_zero_pattern[i+1]) != 0) {
                         dev_err(&client->adapter->dev,
                                 "%s: register=%02x, zero pattern=%d, value=%x\n",
-                                __FUNCTION__, addr[1], i, buf);
+                                __FUNCTION__, probe_zero_pattern[i], i, buf);
 
                         return -ENODEV;
                 }
@@ -506,12 +399,10 @@ static int x1205_validate_client(struct i2c_client *client)
                         { client->addr, I2C_M_RD, 1, &reg },
                 };
 
-                xfer = i2c_transfer(client->adapter, msgs, 2);
-
-                if (xfer != 2) {
+                if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
                         dev_err(&client->adapter->dev,
                                 "%s: could not read register %x\n",
-                                __FUNCTION__, addr[1]);
+                                __FUNCTION__, probe_limits_pattern[i].reg);
 
                         return -EIO;
                 }
@@ -522,7 +413,8 @@ static int x1205_validate_client(struct i2c_client *client)
                         value < probe_limits_pattern[i].min) {
                         dev_dbg(&client->adapter->dev,
                                 "%s: register=%x, lim pattern=%d, value=%d\n",
-                                __FUNCTION__, addr[1], i, value);
+                                __FUNCTION__, probe_limits_pattern[i].reg,
+                                i, value);
 
                         return -ENODEV;
                 }
@@ -531,37 +423,89 @@ static int x1205_validate_client(struct i2c_client *client)
         return 0;
 }
 
-static int x1205_attach(struct i2c_adapter *adapter)
+static int x1205_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 {
-        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        return x1205_get_datetime(to_i2c_client(dev),
+                &alrm->time, X1205_ALM0_BASE);
+}
 
-        return i2c_probe(adapter, &addr_data, x1205_probe);
+static int x1205_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        return x1205_set_datetime(to_i2c_client(dev),
+                &alrm->time, 1, X1205_ALM0_BASE);
 }
 
-int x1205_direct_attach(int adapter_id,
-        struct i2c_client_address_data *address_data)
+static int x1205_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        int err;
-        struct i2c_adapter *adapter = i2c_get_adapter(adapter_id);
+        return x1205_get_datetime(to_i2c_client(dev),
+                tm, X1205_CCR_BASE);
+}
 
-        if (adapter) {
-                err = i2c_probe(adapter,
-                        address_data, x1205_probe);
+static int x1205_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return x1205_set_datetime(to_i2c_client(dev),
+                tm, 1, X1205_CCR_BASE);
+}
 
-                i2c_put_adapter(adapter);
+static int x1205_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        int err, dtrim, atrim;
 
-                return err;
-        }
+        seq_printf(seq, "24hr\t\t: yes\n");
 
-        return -ENODEV;
+        if ((err = x1205_get_dtrim(to_i2c_client(dev), &dtrim)) == 0)
+                seq_printf(seq, "digital_trim\t: %d ppm\n", dtrim);
+
+        if ((err = x1205_get_atrim(to_i2c_client(dev), &atrim)) == 0)
+                seq_printf(seq, "analog_trim\t: %d.%02d pF\n",
+                        atrim / 1000, atrim % 1000);
+        return 0;
 }
 
-static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
+static struct rtc_class_ops x1205_rtc_ops = {
+        .proc           = x1205_rtc_proc,
+        .read_time      = x1205_rtc_read_time,
+        .set_time       = x1205_rtc_set_time,
+        .read_alarm     = x1205_rtc_read_alarm,
+        .set_alarm      = x1205_rtc_set_alarm,
+};
+
+static ssize_t x1205_sysfs_show_atrim(struct device *dev,
+                                struct device_attribute *attr, char *buf)
 {
-        struct i2c_client *client;
-        struct x1205_data *data;
+        int atrim;
+
+        if (x1205_get_atrim(to_i2c_client(dev), &atrim) == 0)
+                return sprintf(buf, "%d.%02d pF\n",
+                        atrim / 1000, atrim % 1000);
+        return 0;
+}
+static DEVICE_ATTR(atrim, S_IRUGO, x1205_sysfs_show_atrim, NULL);
+
+static ssize_t x1205_sysfs_show_dtrim(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        int dtrim;
+
+        if (x1205_get_dtrim(to_i2c_client(dev), &dtrim) == 0)
+                return sprintf(buf, "%d ppm\n", dtrim);
+
+        return 0;
+}
+static DEVICE_ATTR(dtrim, S_IRUGO, x1205_sysfs_show_dtrim, NULL);
 
+static int x1205_attach(struct i2c_adapter *adapter)
+{
+        dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+        return i2c_probe(adapter, &addr_data, x1205_probe);
+}
+
+static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
+{
         int err = 0;
+        unsigned char sr;
+        struct i2c_client *client;
+        struct rtc_device *rtc;
 
         dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
 
@@ -570,22 +514,17 @@ static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
                 goto exit;
         }
 
-        if (!(data = kzalloc(sizeof(struct x1205_data), GFP_KERNEL))) {
+        if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
                 err = -ENOMEM;
                 goto exit;
         }
 
-        /* Initialize our structures */
-        data->epoch = 2000;
-
-        client = &data->client;
+        /* I2C client */
         client->addr = address;
         client->driver = &x1205_driver;
         client->adapter = adapter;
 
-        strlcpy(client->name, "x1205", I2C_NAME_SIZE);
-
-        i2c_set_clientdata(client, data);
+        strlcpy(client->name, x1205_driver.driver.name, I2C_NAME_SIZE);
 
         /* Verify the chip is really an X1205 */
         if (kind < 0) {
@@ -599,18 +538,43 @@ static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
         if ((err = i2c_attach_client(client)))
                 goto exit_kfree;
 
-        list_add(&data->list, &x1205_clients);
-
         dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
 
-        /* If requested, set the system time */
-        if (hctosys)
-                x1205_hctosys(client);
+        rtc = rtc_device_register(x1205_driver.driver.name, &client->dev,
+                                &x1205_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                dev_err(&client->dev,
+                        "unable to register the class device\n");
+                goto exit_detach;
+        }
+
+        i2c_set_clientdata(client, rtc);
+
+        /* Check for power failures and eventualy enable the osc */
+        if ((err = x1205_get_status(client, &sr)) == 0) {
+                if (sr & X1205_SR_RTCF) {
+                        dev_err(&client->dev,
+                                "power failure detected, "
+                                "please set the clock\n");
+                        udelay(50);
+                        x1205_fix_osc(client);
+                }
+        }
+        else
+                dev_err(&client->dev, "couldn't read status\n");
+
+        device_create_file(&client->dev, &dev_attr_atrim);
+        device_create_file(&client->dev, &dev_attr_dtrim);
 
         return 0;
 
+exit_detach:
+        i2c_detach_client(client);
+
 exit_kfree:
-        kfree(data);
+        kfree(client);
 
 exit:
         return err;
@@ -619,61 +583,21 @@ exit:
 static int x1205_detach(struct i2c_client *client)
 {
         int err;
-        struct x1205_data *data = i2c_get_clientdata(client);
+        struct rtc_device *rtc = i2c_get_clientdata(client);
 
         dev_dbg(&client->dev, "%s\n", __FUNCTION__);
 
+        if (rtc)
+                rtc_device_unregister(rtc);
+
         if ((err = i2c_detach_client(client)))
                 return err;
 
-        list_del(&data->list);
-
-        kfree(data);
+        kfree(client);
 
         return 0;
 }
 
-static int x1205_command(struct i2c_client *client, unsigned int cmd,
-        void *param)
-{
-        if (param == NULL)
-                return -EINVAL;
-
-        if (!capable(CAP_SYS_TIME))
-                return -EACCES;
-
-        dev_dbg(&client->dev, "%s: cmd=%d\n", __FUNCTION__, cmd);
-
-        switch (cmd) {
-        case X1205_CMD_GETDATETIME:
-                return x1205_get_datetime(client, param, X1205_CCR_BASE);
-
-        case X1205_CMD_SETTIME:
-                return x1205_set_datetime(client, param, 0,
-                                X1205_CCR_BASE);
-
-        case X1205_CMD_SETDATETIME:
-                return x1205_set_datetime(client, param, 1,
-                                X1205_CCR_BASE);
-
-        case X1205_CMD_GETALARM:
-                return x1205_get_datetime(client, param, X1205_ALM0_BASE);
-
-        case X1205_CMD_SETALARM:
-                return x1205_set_datetime(client, param, 1,
-                                X1205_ALM0_BASE);
-
-        case X1205_CMD_GETDTRIM:
-                return x1205_get_dtrim(client, param);
-
-        case X1205_CMD_GETATRIM:
-                return x1205_get_atrim(client, param);
-
-        default:
-                return -EINVAL;
-        }
-}
-
 static int __init x1205_init(void)
 {
         return i2c_add_driver(&x1205_driver);
@@ -685,14 +609,11 @@ static void __exit x1205_exit(void)
 }
 
 MODULE_AUTHOR(
-        "Karen Spearel <kas11@tampabay.rr.com>, "
+        "Karen Spearel <kas111 at gmail dot com>, "
         "Alessandro Zummo <a.zummo@towertech.it>");
-MODULE_DESCRIPTION("Xicor X1205 RTC driver");
+MODULE_DESCRIPTION("Xicor/Intersil X1205 RTC driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
-EXPORT_SYMBOL_GPL(x1205_do_command);
-EXPORT_SYMBOL_GPL(x1205_direct_attach);
-
 module_init(x1205_init);
 module_exit(x1205_exit);
diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index 0ab26d01877b..0d2b447c50ed 100644
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -1026,7 +1026,7 @@ static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
         tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
 } /* End twa_free_request_id() */
 
-/* This function will get parameter table entires from the firmware */
+/* This function will get parameter table entries from the firmware */
 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
 {
         TW_Command_Full *full_command_packet;
diff --git a/drivers/scsi/BusLogic.c b/drivers/scsi/BusLogic.c
index 1c459343292b..bde3d5834ade 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -41,6 +41,8 @@
 #include <linux/stat.h>
 #include <linux/pci.h>
 #include <linux/spinlock.h>
+#include <linux/jiffies.h>
+#include <linux/dma-mapping.h>
 #include <scsi/scsicam.h>
 
 #include <asm/dma.h>
@@ -676,7 +678,7 @@ static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAd
                 if (pci_enable_device(PCI_Device))
                         continue;
 
-                if (pci_set_dma_mask(PCI_Device, (u64) 0xffffffff))
+                if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK ))
                         continue;
 
                 Bus = PCI_Device->bus->number;
@@ -831,7 +833,7 @@ static int __init BusLogic_InitializeMultiMasterProbeInfo(struct BusLogic_HostAd
                 if (pci_enable_device(PCI_Device))
                         continue;
 
-                if (pci_set_dma_mask(PCI_Device, (u64) 0xffffffff))
+                if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK))
                         continue;
 
                 Bus = PCI_Device->bus->number;
@@ -885,7 +887,7 @@ static int __init BusLogic_InitializeFlashPointProbeInfo(struct BusLogic_HostAda
                 if (pci_enable_device(PCI_Device))
                         continue;
 
-                if (pci_set_dma_mask(PCI_Device, (u64) 0xffffffff))
+                if (pci_set_dma_mask(PCI_Device, DMA_32BIT_MASK))
                         continue;
 
                 Bus = PCI_Device->bus->number;
@@ -2896,7 +2898,7 @@ static int BusLogic_QueueCommand(struct scsi_cmnd *Command, void (*CompletionRou
                  */
                 if (HostAdapter->ActiveCommands[TargetID] == 0)
                         HostAdapter->LastSequencePoint[TargetID] = jiffies;
-                else if (jiffies - HostAdapter->LastSequencePoint[TargetID] > 4 * HZ) {
+                else if (time_after(jiffies, HostAdapter->LastSequencePoint[TargetID] + 4 * HZ)) {
                         HostAdapter->LastSequencePoint[TargetID] = jiffies;
                         QueueTag = BusLogic_OrderedQueueTag;
                 }
diff --git a/drivers/scsi/a100u2w.c b/drivers/scsi/a100u2w.c
index 9f45ae1745da..3dce21c78737 100644
--- a/drivers/scsi/a100u2w.c
+++ b/drivers/scsi/a100u2w.c
@@ -89,6 +89,7 @@
 #include <linux/string.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -1052,7 +1053,7 @@ static int __devinit inia100_probe_one(struct pci_dev *pdev,
 
         if (pci_enable_device(pdev))
                 goto out;
-        if (pci_set_dma_mask(pdev, 0xffffffffULL)) {
+        if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
                 printk(KERN_WARNING "Unable to set 32bit DMA "
                                     "on inia100 adapter, ignoring.\n");
                 goto out_disable_device;
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index a16f8ded8f1d..8df4a0ea3761 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -32,6 +32,7 @@
 #include <linux/slab.h>
 #include <linux/completion.h>
 #include <linux/blkdev.h>
+#include <linux/dma-mapping.h>
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index c2596335549d..720330778648 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -45,6 +45,7 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
+#include <linux/dma-mapping.h>
 #include <linux/syscalls.h>
 #include <linux/delay.h>
 #include <linux/smp_lock.h>
@@ -806,8 +807,8 @@ static int __devinit aac_probe_one(struct pci_dev *pdev,
          * to driver communication memory to be allocated below 2gig
          */
         if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) 
-                if (pci_set_dma_mask(pdev, 0x7FFFFFFFULL) ||
-                                pci_set_consistent_dma_mask(pdev, 0x7FFFFFFFULL))
+                if (pci_set_dma_mask(pdev, DMA_31BIT_MASK) ||
+                                pci_set_consistent_dma_mask(pdev, DMA_31BIT_MASK))
                         goto out;
         
         pci_set_master(pdev);
diff --git a/drivers/scsi/atp870u.c b/drivers/scsi/atp870u.c
index 5227a779c05c..a198d86667e9 100644
--- a/drivers/scsi/atp870u.c
+++ b/drivers/scsi/atp870u.c
@@ -28,6 +28,7 @@
 #include <linux/spinlock.h>
 #include <linux/pci.h>
 #include <linux/blkdev.h>
+#include <linux/dma-mapping.h>
 #include <asm/system.h>
 #include <asm/io.h>
 
@@ -2631,7 +2632,7 @@ static int atp870u_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (pci_enable_device(pdev))
                 return -EIO;
 
-        if (!pci_set_dma_mask(pdev, 0xFFFFFFFFUL)) {
+        if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
                 printk(KERN_INFO "atp870u: use 32bit DMA mask.\n");
         } else {
                 printk(KERN_ERR "atp870u: DMA mask required but not available.\n");
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 6e6b293dcb28..b1b704a42efd 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -57,6 +57,7 @@ MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
 #include <linux/reboot.h>
 #include <linux/spinlock.h>
 #include <linux/smp_lock.h>
+#include <linux/dma-mapping.h>
 
 #include <linux/timer.h>
 #include <linux/string.h>
@@ -906,8 +907,8 @@ static int adpt_install_hba(struct scsi_host_template* sht, struct pci_dev* pDev
         }
 
         pci_set_master(pDev);
-        if (pci_set_dma_mask(pDev, 0xffffffffffffffffULL) &&
-            pci_set_dma_mask(pDev, 0xffffffffULL))
+        if (pci_set_dma_mask(pDev, DMA_64BIT_MASK) &&
+            pci_set_dma_mask(pDev, DMA_32BIT_MASK))
                 return -EINVAL;
 
         base_addr0_phys = pci_resource_start(pDev,0);
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index b3f9de8f7595..059eeee4b554 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -490,6 +490,7 @@
 #include <linux/init.h>
 #include <linux/ctype.h>
 #include <linux/spinlock.h>
+#include <linux/dma-mapping.h>
 #include <asm/byteorder.h>
 #include <asm/dma.h>
 #include <asm/io.h>
@@ -1426,7 +1427,7 @@ static int port_detect(unsigned long port_base, unsigned int j,
 
         if (ha->pdev) {
                 pci_set_master(ha->pdev);
-                if (pci_set_dma_mask(ha->pdev, 0xffffffff))
+                if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK))
                         printk("%s: warning, pci_set_dma_mask failed.\n",
                                ha->board_name);
         }
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 62e3cda859af..d5740bbdef3e 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -388,6 +388,7 @@
 #include <linux/proc_fs.h>
 #include <linux/time.h>
 #include <linux/timer.h>
+#include <linux/dma-mapping.h>
 #ifdef GDTH_RTC
 #include <linux/mc146818rtc.h>
 #endif
@@ -671,7 +672,7 @@ static struct file_operations gdth_fops = {
 static struct notifier_block gdth_notifier = {
     gdth_halt, NULL, 0
 };
-
+static int notifier_disabled = 0;
 
 static void gdth_delay(int milliseconds)
 {
@@ -4527,15 +4528,15 @@ static int __init gdth_detect(struct scsi_host_template *shtp)
             if (!(ha->cache_feat & ha->raw_feat & ha->screen_feat &GDT_64BIT)||
                 /* 64-bit DMA only supported from FW >= x.43 */
                 (!ha->dma64_support)) {
-                if (pci_set_dma_mask(pcistr[ctr].pdev, 0xffffffff)) {
+                if (pci_set_dma_mask(pcistr[ctr].pdev, DMA_32BIT_MASK)) {
                     printk(KERN_WARNING "GDT-PCI %d: Unable to set 32-bit DMA\n", hanum);
                     err = TRUE;
                 }
             } else {
                 shp->max_cmd_len = 16;
-                if (!pci_set_dma_mask(pcistr[ctr].pdev, 0xffffffffffffffffULL)) {
+                if (!pci_set_dma_mask(pcistr[ctr].pdev, DMA_64BIT_MASK)) {
                     printk("GDT-PCI %d: 64-bit DMA enabled\n", hanum);
-                } else if (pci_set_dma_mask(pcistr[ctr].pdev, 0xffffffff)) {
+                } else if (pci_set_dma_mask(pcistr[ctr].pdev, DMA_32BIT_MASK)) {
                     printk(KERN_WARNING "GDT-PCI %d: Unable to set 64/32-bit DMA\n", hanum);
                     err = TRUE;
                 }
@@ -4595,13 +4596,13 @@ static int __init gdth_detect(struct scsi_host_template *shtp)
         add_timer(&gdth_timer);
 #endif
         major = register_chrdev(0,"gdth",&gdth_fops);
+        notifier_disabled = 0;
         register_reboot_notifier(&gdth_notifier);
     }
     gdth_polling = FALSE;
     return gdth_ctr_vcount;
 }
 
-
 static int gdth_release(struct Scsi_Host *shp)
 {
     int hanum;
@@ -5632,10 +5633,14 @@ static int gdth_halt(struct notifier_block *nb, ulong event, void *buf)
     char            cmnd[MAX_COMMAND_SIZE];   
 #endif
 
+    if (notifier_disabled)
+        return NOTIFY_OK;
+
     TRACE2(("gdth_halt() event %d\n",(int)event));
     if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
         return NOTIFY_DONE;
 
+    notifier_disabled = 1;
     printk("GDT-HA: Flushing all host drives .. ");
     for (hanum = 0; hanum < gdth_ctr_count; ++hanum) {
         gdth_flush(hanum);
@@ -5679,7 +5684,6 @@ static int gdth_halt(struct notifier_block *nb, ulong event, void *buf)
 #ifdef GDTH_STATISTICS
     del_timer(&gdth_timer);
 #endif
-    unregister_reboot_notifier(&gdth_notifier);
     return NOTIFY_OK;
 }
 
diff --git a/drivers/scsi/initio.c b/drivers/scsi/initio.c
index ea6f3c0e05d9..0cc7f65b584f 100644
--- a/drivers/scsi/initio.c
+++ b/drivers/scsi/initio.c
@@ -127,6 +127,7 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/jiffies.h>
+#include <linux/dma-mapping.h>
 #include <asm/io.h>
 
 #include <scsi/scsi.h>
@@ -2780,7 +2781,7 @@ static int tul_NewReturnNumberOfAdapters(void)
                         if (((dRegValue & 0xFF00) >> 8) == 0xFF)
                                 dRegValue = 0;
                         wBIOS = (wBIOS << 8) + ((UWORD) ((dRegValue & 0xFF00) >> 8));
-                        if (pci_set_dma_mask(pDev, 0xffffffff)) {
+                        if (pci_set_dma_mask(pDev, DMA_32BIT_MASK)) {
                                 printk(KERN_WARNING 
                                        "i91u: Could not set 32 bit DMA mask\n");
                                 continue;
diff --git a/drivers/scsi/ips.c b/drivers/scsi/ips.c
index 481708d527ae..a4c0b04cfdbd 100644
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -179,6 +179,7 @@
 
 #include <linux/blkdev.h>
 #include <linux/types.h>
+#include <linux/dma-mapping.h>
 
 #include <scsi/sg.h>
 
@@ -7284,10 +7285,10 @@ ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
          * are guaranteed to be < 4G.
          */
         if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
-            !pci_set_dma_mask(ha->pcidev, 0xffffffffffffffffULL)) {
+            !pci_set_dma_mask(ha->pcidev, DMA_64BIT_MASK)) {
                 (ha)->flags |= IPS_HA_ENH_SG;
         } else {
-                if (pci_set_dma_mask(ha->pcidev, 0xffffffffULL) != 0) {
+                if (pci_set_dma_mask(ha->pcidev, DMA_32BIT_MASK) != 0) {
                         printk(KERN_WARNING "Unable to set DMA Mask\n");
                         return ips_abort_init(ha, index);
                 }
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 7144674bc8e6..80b68a2481b3 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -45,6 +45,7 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/dma-mapping.h>
 #include <scsi/scsicam.h>
 
 #include "scsi.h"
@@ -2094,7 +2095,7 @@ make_local_pdev(adapter_t *adapter, struct pci_dev **pdev)
 
         memcpy(*pdev, adapter->dev, sizeof(struct pci_dev));
 
-        if( pci_set_dma_mask(*pdev, 0xffffffff) != 0 ) {
+        if( pci_set_dma_mask(*pdev, DMA_32BIT_MASK) != 0 ) {
                 kfree(*pdev);
                 return -1;
         }
@@ -4859,10 +4860,10 @@ megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
         /* Set the Mode of addressing to 64 bit if we can */
         if ((adapter->flag & BOARD_64BIT) && (sizeof(dma_addr_t) == 8)) {
-                pci_set_dma_mask(pdev, 0xffffffffffffffffULL);
+                pci_set_dma_mask(pdev, DMA_64BIT_MASK);
                 adapter->has_64bit_addr = 1;
         } else  {
-                pci_set_dma_mask(pdev, 0xffffffff);
+                pci_set_dma_mask(pdev, DMA_32BIT_MASK);
                 adapter->has_64bit_addr = 0;
         }
                 
diff --git a/drivers/scsi/nsp32.c b/drivers/scsi/nsp32.c
index a279ebb61447..30ee0ef4b459 100644
--- a/drivers/scsi/nsp32.c
+++ b/drivers/scsi/nsp32.c
@@ -38,6 +38,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/ctype.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/dma.h>
 #include <asm/system.h>
@@ -2776,7 +2777,7 @@ static int nsp32_detect(struct scsi_host_template *sht)
         /*
          * setup DMA 
          */
-        if (pci_set_dma_mask(PCIDEV, 0xffffffffUL) != 0) {
+        if (pci_set_dma_mask(PCIDEV, DMA_32BIT_MASK) != 0) {
                 nsp32_msg (KERN_ERR, "failed to set PCI DMA mask");
                 goto scsi_unregister;
         }
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index 66ea47a9c53c..e3bd4bc339f4 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -49,6 +49,7 @@ static const char * osst_version = "0.99.4";
 #include <linux/blkdev.h>
 #include <linux/moduleparam.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
 #include <asm/uaccess.h>
 #include <asm/dma.h>
 #include <asm/system.h>
@@ -856,7 +857,7 @@ static int osst_wait_frame(struct osst_tape * STp, struct osst_request ** aSRpnt
                     ) && result >= 0)
                 {
 #if DEBUG                       
-                        if (debugging || jiffies - startwait >= 2*HZ/OSST_POLL_PER_SEC)
+                        if (debugging || time_after_eq(jiffies, startwait + 2*HZ/OSST_POLL_PER_SEC))
                                 printk (OSST_DEB_MSG
                                         "%s:D: Succ wait f fr %i (>%i): %i-%i %i (%i): %3li.%li s\n",
                                         name, curr, curr+minlast, STp->first_frame_position,
@@ -867,7 +868,7 @@ static int osst_wait_frame(struct osst_tape * STp, struct osst_request ** aSRpnt
                         return 0;
                 }
 #if DEBUG
-                if (jiffies - startwait >= 2*HZ/OSST_POLL_PER_SEC && notyetprinted)
+                if (time_after_eq(jiffies, startwait + 2*HZ/OSST_POLL_PER_SEC) && notyetprinted)
                 {
                         printk (OSST_DEB_MSG "%s:D: Wait for frame %i (>%i): %i-%i %i (%i)\n",
                                 name, curr, curr+minlast, STp->first_frame_position,
diff --git a/drivers/scsi/ppa.c b/drivers/scsi/ppa.c
index 05347eed9dd5..fee843fab1c7 100644
--- a/drivers/scsi/ppa.c
+++ b/drivers/scsi/ppa.c
@@ -18,6 +18,7 @@
 #include <linux/parport.h>
 #include <linux/workqueue.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
 #include <asm/io.h>
 
 #include <scsi/scsi.h>
@@ -726,7 +727,7 @@ static int ppa_engine(ppa_struct *dev, struct scsi_cmnd *cmd)
                                 retv--;
 
                         if (retv) {
-                                if ((jiffies - dev->jstart) > (1 * HZ)) {
+                                if (time_after(jiffies, dev->jstart + (1 * HZ))) {
                                         printk
                                             ("ppa: Parallel port cable is unplugged!!\n");
                                         ppa_fail(dev, DID_BUS_BUSY);
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index e0230249fa0f..5a48e55f9418 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -350,6 +350,7 @@
 #include <linux/pci_ids.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -4321,7 +4322,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
 #ifdef QLA_64BIT_PTR
         if (pci_set_dma_mask(ha->pdev, (dma_addr_t) ~ 0ULL)) {
-                if (pci_set_dma_mask(ha->pdev, 0xffffffff)) {
+                if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK)) {
                         printk(KERN_WARNING "scsi(%li): Unable to set a "
                                "suitable DMA mask - aborting\n", ha->host_no);
                         error = -ENODEV;
@@ -4331,7 +4332,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
                         ha->host_no);
 #else
-        if (pci_set_dma_mask(ha->pdev, 0xffffffff)) {
+        if (pci_set_dma_mask(ha->pdev, DMA_32BIT_MASK)) {
                 printk(KERN_WARNING "scsi(%li): Unable to set a "
                        "suitable DMA mask - aborting\n", ha->host_no);
                 error = -ENODEV;
diff --git a/drivers/scsi/qlogicfc.c b/drivers/scsi/qlogicfc.c
index 94ef3f08d378..52b224a5d6fd 100644
--- a/drivers/scsi/qlogicfc.c
+++ b/drivers/scsi/qlogicfc.c
@@ -61,6 +61,8 @@
 #include <linux/unistd.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/jiffies.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include "scsi.h"
@@ -737,8 +739,8 @@ static int isp2x00_detect(struct scsi_host_template * tmpt)
                                 continue;
 
                         /* Try to configure DMA attributes. */
-                        if (pci_set_dma_mask(pdev, 0xffffffffffffffffULL) &&
-                            pci_set_dma_mask(pdev, 0xffffffffULL))
+                        if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) &&
+                            pci_set_dma_mask(pdev, DMA_32BIT_MASK))
                                         continue;
 
                         host = scsi_register(tmpt, sizeof(struct isp2x00_hostdata));
@@ -1325,7 +1327,7 @@ static int isp2x00_queuecommand(Scsi_Cmnd * Cmnd, void (*done) (Scsi_Cmnd *))
                 cmd->control_flags = cpu_to_le16(CFLAG_READ);
 
         if (Cmnd->device->tagged_supported) {
-                if ((jiffies - hostdata->tag_ages[Cmnd->device->id]) > (2 * ISP_TIMEOUT)) {
+                if (time_after(jiffies, hostdata->tag_ages[Cmnd->device->id] + (2 * ISP_TIMEOUT))) {
                         cmd->control_flags |= cpu_to_le16(CFLAG_ORDERED_TAG);
                         hostdata->tag_ages[Cmnd->device->id] = jiffies;
                 } else
diff --git a/drivers/scsi/qlogicpti.c b/drivers/scsi/qlogicpti.c
index 1fd5fc6d0fe3..c7e78dcf09df 100644
--- a/drivers/scsi/qlogicpti.c
+++ b/drivers/scsi/qlogicpti.c
@@ -24,6 +24,7 @@
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
+#include <linux/jiffies.h>
 
 #include <asm/byteorder.h>
 
@@ -1017,7 +1018,7 @@ static inline void cmd_frob(struct Command_Entry *cmd, struct scsi_cmnd *Cmnd,
         if (Cmnd->device->tagged_supported) {
                 if (qpti->cmd_count[Cmnd->device->id] == 0)
                         qpti->tag_ages[Cmnd->device->id] = jiffies;
-                if ((jiffies - qpti->tag_ages[Cmnd->device->id]) > (5*HZ)) {
+                if (time_after(jiffies, qpti->tag_ages[Cmnd->device->id] + (5*HZ))) {
                         cmd->control_flags = CFLAG_ORDERED_TAG;
                         qpti->tag_ages[Cmnd->device->id] = jiffies;
                 } else
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 5996d3cd0ed8..674b15c78f68 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -1528,7 +1528,7 @@ static int serial8250_startup(struct uart_port *port)
 
         /*
          * Clear the FIFO buffers and disable them.
-         * (they will be reeanbled in set_termios())
+         * (they will be reenabled in set_termios())
          */
         serial8250_clear_fifos(up);
 
diff --git a/drivers/serial/8250_au1x00.c b/drivers/serial/8250_au1x00.c
index 8d8d7a70d03e..3d1bfd07208d 100644
--- a/drivers/serial/8250_au1x00.c
+++ b/drivers/serial/8250_au1x00.c
@@ -51,7 +51,7 @@ static struct plat_serial8250_port au1x00_data[] = {
 #elif defined(CONFIG_SOC_AU1100)
         PORT(UART0_ADDR, AU1100_UART0_INT),
         PORT(UART1_ADDR, AU1100_UART1_INT),
-        PORT(UART2_ADDR, AU1100_UART2_INT),
+        /* The internal UART2 does not exist on the AU1100 processor. */
         PORT(UART3_ADDR, AU1100_UART3_INT),
 #elif defined(CONFIG_SOC_AU1550)
         PORT(UART0_ADDR, AU1550_UART0_INT),
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index ceb3697bf84d..fe0d8b8e91c8 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -620,22 +620,6 @@ config SERIAL_SH_SCI_CONSOLE
         depends on SERIAL_SH_SCI=y
         select SERIAL_CORE_CONSOLE
 
-config SERIAL_AU1X00
-        bool "Enable Au1x00 UART Support"
-        depends on MIPS && SOC_AU1X00
-        select SERIAL_CORE
-        help
-          If you have an Alchemy AU1X00 processor (MIPS based) and you want
-          to use serial ports, say Y.  Otherwise, say N.
-
-config SERIAL_AU1X00_CONSOLE
-        bool "Enable Au1x00 serial console"
-        depends on SERIAL_AU1X00
-        select SERIAL_CORE_CONSOLE
-        help
-          If you have an Alchemy AU1X00 processor (MIPS based) and you want
-          to use a console on a serial port, say Y.  Otherwise, say N.
-
 config SERIAL_CORE
         tristate
 
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index a3a4323d9c86..d2b4c214876b 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -41,7 +41,6 @@ obj-$(CONFIG_SERIAL_COLDFIRE) += mcfserial.o
 obj-$(CONFIG_V850E_UART) += v850e_uart.o
 obj-$(CONFIG_SERIAL_PMACZILOG) += pmac_zilog.o
 obj-$(CONFIG_SERIAL_LH7A40X) += serial_lh7a40x.o
-obj-$(CONFIG_SERIAL_AU1X00) += au1x00_uart.o
 obj-$(CONFIG_SERIAL_DZ) += dz.o
 obj-$(CONFIG_SERIAL_SH_SCI) += sh-sci.o
 obj-$(CONFIG_SERIAL_SGI_L1_CONSOLE) += sn_console.o
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index 127d6cd5de7f..1631414000a2 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -51,8 +51,6 @@
 #include <linux/amba/serial.h>
 
 #include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/hardware.h>
 
 #define UART_NR         2
 
@@ -65,26 +63,16 @@
 #define UART_RX_DATA(s)         (((s) & UART01x_FR_RXFE) == 0)
 #define UART_TX_READY(s)        (((s) & UART01x_FR_TXFF) == 0)
 
-#define UART_DUMMY_RSR_RX       /*256*/0
+#define UART_DUMMY_RSR_RX       256
 #define UART_PORT_SIZE          64
 
 /*
- * On the Integrator platform, the port RTS and DTR are provided by
- * bits in the following SC_CTRLS register bits:
- *        RTS  DTR
- *  UART0  7    6
- *  UART1  5    4
- */
-#define SC_CTRLC        (IO_ADDRESS(INTEGRATOR_SC_BASE) + INTEGRATOR_SC_CTRLC_OFFSET)
-#define SC_CTRLS        (IO_ADDRESS(INTEGRATOR_SC_BASE) + INTEGRATOR_SC_CTRLS_OFFSET)
-
-/*
  * We wrap our port structure around the generic uart_port.
  */
 struct uart_amba_port {
         struct uart_port        port;
-        unsigned int            dtr_mask;
-        unsigned int            rts_mask;
+        struct amba_device      *dev;
+        struct amba_pl010_data  *data;
         unsigned int            old_status;
 };
 
@@ -300,20 +288,9 @@ static unsigned int pl010_get_mctrl(struct uart_port *port)
 static void pl010_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
         struct uart_amba_port *uap = (struct uart_amba_port *)port;
-        unsigned int ctrls = 0, ctrlc = 0;
-
-        if (mctrl & TIOCM_RTS)
-                ctrlc |= uap->rts_mask;
-        else
-                ctrls |= uap->rts_mask;
 
-        if (mctrl & TIOCM_DTR)
-                ctrlc |= uap->dtr_mask;
-        else
-                ctrls |= uap->dtr_mask;
-
-        __raw_writel(ctrls, SC_CTRLS);
-        __raw_writel(ctrlc, SC_CTRLC);
+        if (uap->data)
+                uap->data->set_mctrl(uap->dev, uap->port.membase, mctrl);
 }
 
 static void pl010_break_ctl(struct uart_port *port, int break_state)
@@ -539,38 +516,7 @@ static struct uart_ops amba_pl010_pops = {
         .verify_port    = pl010_verify_port,
 };
 
-static struct uart_amba_port amba_ports[UART_NR] = {
-        {
-                .port   = {
-                        .membase        = (void *)IO_ADDRESS(INTEGRATOR_UART0_BASE),
-                        .mapbase        = INTEGRATOR_UART0_BASE,
-                        .iotype         = UPIO_MEM,
-                        .irq            = IRQ_UARTINT0,
-                        .uartclk        = 14745600,
-                        .fifosize       = 16,
-                        .ops            = &amba_pl010_pops,
-                        .flags          = UPF_BOOT_AUTOCONF,
-                        .line           = 0,
-                },
-                .dtr_mask       = 1 << 5,
-                .rts_mask       = 1 << 4,
-        },
-        {
-                .port   = {
-                        .membase        = (void *)IO_ADDRESS(INTEGRATOR_UART1_BASE),
-                        .mapbase        = INTEGRATOR_UART1_BASE,
-                        .iotype         = UPIO_MEM,
-                        .irq            = IRQ_UARTINT1,
-                        .uartclk        = 14745600,
-                        .fifosize       = 16,
-                        .ops            = &amba_pl010_pops,
-                        .flags          = UPF_BOOT_AUTOCONF,
-                        .line           = 1,
-                },
-                .dtr_mask       = 1 << 7,
-                .rts_mask       = 1 << 6,
-        }
-};
+static struct uart_amba_port *amba_ports[UART_NR];
 
 #ifdef CONFIG_SERIAL_AMBA_PL010_CONSOLE
 
@@ -588,7 +534,7 @@ static void pl010_console_putchar(struct uart_port *port, int ch)
 static void
 pl010_console_write(struct console *co, const char *s, unsigned int count)
 {
-        struct uart_port *port = &amba_ports[co->index].port;
+        struct uart_port *port = &amba_ports[co->index]->port;
         unsigned int status, old_cr;
 
         /*
@@ -651,7 +597,7 @@ static int __init pl010_console_setup(struct console *co, char *options)
          */
         if (co->index >= UART_NR)
                 co->index = 0;
-        port = &amba_ports[co->index].port;
+        port = &amba_ports[co->index]->port;
 
         if (options)
                 uart_parse_options(options, &baud, &parity, &bits, &flow);
@@ -672,24 +618,6 @@ static struct console amba_console = {
         .data           = &amba_reg,
 };
 
-static int __init amba_console_init(void)
-{
-        /*
-         * All port initializations are done statically
-         */
-        register_console(&amba_console);
-        return 0;
-}
-console_initcall(amba_console_init);
-
-static int __init amba_late_console_init(void)
-{
-        if (!(amba_console.flags & CON_ENABLED))
-                register_console(&amba_console);
-        return 0;
-}
-late_initcall(amba_late_console_init);
-
 #define AMBA_CONSOLE    &amba_console
 #else
 #define AMBA_CONSOLE    NULL
@@ -707,30 +635,76 @@ static struct uart_driver amba_reg = {
 
 static int pl010_probe(struct amba_device *dev, void *id)
 {
-        int i;
+        struct uart_amba_port *port;
+        void __iomem *base;
+        int i, ret;
 
-        for (i = 0; i < UART_NR; i++) {
-                if (amba_ports[i].port.mapbase != dev->res.start)
-                        continue;
+        for (i = 0; i < ARRAY_SIZE(amba_ports); i++)
+                if (amba_ports[i] == NULL)
+                        break;
 
-                amba_ports[i].port.dev = &dev->dev;
-                uart_add_one_port(&amba_reg, &amba_ports[i].port);
-                amba_set_drvdata(dev, &amba_ports[i]);
-                break;
+        if (i == ARRAY_SIZE(amba_ports)) {
+                ret = -EBUSY;
+                goto out;
         }
 
-        return 0;
+        port = kzalloc(sizeof(struct uart_amba_port), GFP_KERNEL);
+        if (!port) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        base = ioremap(dev->res.start, PAGE_SIZE);
+        if (!base) {
+                ret = -ENOMEM;
+                goto free;
+        }
+
+        port->port.dev = &dev->dev;
+        port->port.mapbase = dev->res.start;
+        port->port.membase = base;
+        port->port.iotype = UPIO_MEM;
+        port->port.irq = dev->irq[0];
+        port->port.uartclk = 14745600;
+        port->port.fifosize = 16;
+        port->port.ops = &amba_pl010_pops;
+        port->port.flags = UPF_BOOT_AUTOCONF;
+        port->port.line = i;
+        port->dev = dev;
+        port->data = dev->dev.platform_data;
+
+        amba_ports[i] = port;
+
+        amba_set_drvdata(dev, port);
+        ret = uart_add_one_port(&amba_reg, &port->port);
+        if (ret) {
+                amba_set_drvdata(dev, NULL);
+                amba_ports[i] = NULL;
+                iounmap(base);
+ free:
+                kfree(port);
+        }
+
+ out:
+        return ret;
 }
 
 static int pl010_remove(struct amba_device *dev)
 {
-        struct uart_amba_port *uap = amba_get_drvdata(dev);
-
-        if (uap)
-                uart_remove_one_port(&amba_reg, &uap->port);
+        struct uart_amba_port *port = amba_get_drvdata(dev);
+        int i;
 
         amba_set_drvdata(dev, NULL);
 
+        uart_remove_one_port(&amba_reg, &port->port);
+
+        for (i = 0; i < ARRAY_SIZE(amba_ports); i++)
+                if (amba_ports[i] == port)
+                        amba_ports[i] = NULL;
+
+        iounmap(port->port.membase);
+        kfree(port);
+
         return 0;
 }
 
diff --git a/drivers/serial/au1x00_uart.c b/drivers/serial/au1x00_uart.c
deleted file mode 100644
index 948880ac5878..000000000000
--- a/drivers/serial/au1x00_uart.c
+++ /dev/null
@@ -1,1287 +0,0 @@
-/*
- *  Driver for 8250/16550-type serial ports
- *
- *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
- *
- *  Copyright (C) 2001 Russell King.
- *
- * 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.
- *
- * A note about mapbase / membase
- *
- *  mapbase is the physical address of the IO port.  Currently, we don't
- *  support this very well, and it may well be dropped from this driver
- *  in future.  As such, mapbase should be NULL.
- *
- *  membase is an 'ioremapped' cookie.  This is compatible with the old
- *  serial.c driver, and is currently the preferred form.
- */
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/tty.h>
-#include <linux/ioport.h>
-#include <linux/init.h>
-#include <linux/console.h>
-#include <linux/sysrq.h>
-#include <linux/serial.h>
-#include <linux/serialP.h>
-#include <linux/delay.h>
-
-#include <asm/serial.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/mach-au1x00/au1000.h>
-
-#if defined(CONFIG_SERIAL_AU1X00_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
-#define SUPPORT_SYSRQ
-#endif
-
-#include <linux/serial_core.h>
-#include "8250.h"
-
-/*
- * Debugging.
- */
-#if 0
-#define DEBUG_AUTOCONF(fmt...)  printk(fmt)
-#else
-#define DEBUG_AUTOCONF(fmt...)  do { } while (0)
-#endif
-
-#if 0
-#define DEBUG_INTR(fmt...)      printk(fmt)
-#else
-#define DEBUG_INTR(fmt...)      do { } while (0)
-#endif
-
-#define PASS_LIMIT      256
-
-/*
- * We default to IRQ0 for the "no irq" hack.   Some
- * machine types want others as well - they're free
- * to redefine this in their header file.
- */
-#define is_real_interrupt(irq)  ((irq) != 0)
-
-static struct old_serial_port old_serial_port[] = {
-        {       .baud_base = 0,
-                .iomem_base = (u8 *)UART0_ADDR,
-                .irq = AU1000_UART0_INT,
-                .flags = STD_COM_FLAGS,
-                .iomem_reg_shift = 2,
-        }, {
-                .baud_base = 0,
-                .iomem_base = (u8 *)UART1_ADDR,
-                .irq = AU1000_UART1_INT,
-                .flags = STD_COM_FLAGS,
-                .iomem_reg_shift = 2
-        }, {
-                .baud_base = 0,
-                .iomem_base = (u8 *)UART2_ADDR,
-                .irq = AU1000_UART2_INT,
-                .flags = STD_COM_FLAGS,
-                .iomem_reg_shift = 2
-        }, {
-                .baud_base = 0,
-                .iomem_base = (u8 *)UART3_ADDR,
-                .irq = AU1000_UART3_INT,
-                .flags = STD_COM_FLAGS,
-                .iomem_reg_shift = 2
-        }
-};
-
-#define UART_NR ARRAY_SIZE(old_serial_port)
-
-struct uart_8250_port {
-        struct uart_port        port;
-        struct timer_list       timer;          /* "no irq" timer */
-        struct list_head        list;           /* ports on this IRQ */
-        unsigned short          rev;
-        unsigned char           acr;
-        unsigned char           ier;
-        unsigned char           lcr;
-        unsigned char           mcr_mask;       /* mask of user bits */
-        unsigned char           mcr_force;      /* mask of forced bits */
-        unsigned char           lsr_break_flag;
-
-        /*
-         * We provide a per-port pm hook.
-         */
-        void                    (*pm)(struct uart_port *port,
-                                      unsigned int state, unsigned int old);
-};
-
-struct irq_info {
-        spinlock_t              lock;
-        struct list_head        *head;
-};
-
-static struct irq_info irq_lists[NR_IRQS];
-
-/*
- * Here we define the default xmit fifo size used for each type of UART.
- */
-static const struct serial_uart_config uart_config[PORT_MAX_8250+1] = {
-        { "unknown",    1,      0 },
-        { "8250",       1,      0 },
-        { "16450",      1,      0 },
-        { "16550",      1,      0 },
-        /* PORT_16550A */
-        { "AU1X00_UART",16,     UART_CLEAR_FIFO | UART_USE_FIFO },
-};
-
-static unsigned int serial_in(struct uart_8250_port *up, int offset)
-{
-        return au_readl((unsigned long)up->port.membase + offset);
-}
-
-static void serial_out(struct uart_8250_port *up, int offset, int value)
-{
-        au_writel(value, (unsigned long)up->port.membase + offset);
-}
-
-#define serial_inp(up, offset)          serial_in(up, offset)
-#define serial_outp(up, offset, value)  serial_out(up, offset, value)
-
-/*
- * This routine is called by rs_init() to initialize a specific serial
- * port.  It determines what type of UART chip this serial port is
- * using: 8250, 16450, 16550, 16550A.  The important question is
- * whether or not this UART is a 16550A or not, since this will
- * determine whether or not we can use its FIFO features or not.
- */
-static void autoconfig(struct uart_8250_port *up, unsigned int probeflags)
-{
-        unsigned char save_lcr, save_mcr;
-        unsigned long flags;
-
-        if (!up->port.iobase && !up->port.mapbase && !up->port.membase)
-                return;
-
-        DEBUG_AUTOCONF("ttyS%d: autoconf (0x%04x, 0x%08lx): ",
-                        up->port.line, up->port.iobase, up->port.membase);
-
-        /*
-         * We really do need global IRQs disabled here - we're going to
-         * be frobbing the chips IRQ enable register to see if it exists.
-         */
-        spin_lock_irqsave(&up->port.lock, flags);
-//      save_flags(flags); cli();
-
-        save_mcr = serial_in(up, UART_MCR);
-        save_lcr = serial_in(up, UART_LCR);
-
-        up->port.type = PORT_16550A;
-        serial_outp(up, UART_LCR, save_lcr);
-
-        up->port.fifosize = uart_config[up->port.type].dfl_xmit_fifo_size;
-
-        if (up->port.type == PORT_UNKNOWN)
-                goto out;
-
-        /*
-         * Reset the UART.
-         */
-        serial_outp(up, UART_MCR, save_mcr);
-        serial_outp(up, UART_FCR, (UART_FCR_ENABLE_FIFO |
-                                     UART_FCR_CLEAR_RCVR |
-                                     UART_FCR_CLEAR_XMIT));
-        serial_outp(up, UART_FCR, 0);
-        (void)serial_in(up, UART_RX);
-        serial_outp(up, UART_IER, 0);
-
- out:   
-        spin_unlock_irqrestore(&up->port.lock, flags);
-//      restore_flags(flags);
-        DEBUG_AUTOCONF("type=%s\n", uart_config[up->port.type].name);
-}
-
-static void serial8250_stop_tx(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-
-        if (up->ier & UART_IER_THRI) {
-                up->ier &= ~UART_IER_THRI;
-                serial_out(up, UART_IER, up->ier);
-        }
-}
-
-static void serial8250_start_tx(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-
-        if (!(up->ier & UART_IER_THRI)) {
-                up->ier |= UART_IER_THRI;
-                serial_out(up, UART_IER, up->ier);
-        }
-}
-
-static void serial8250_stop_rx(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-
-        up->ier &= ~UART_IER_RLSI;
-        up->port.read_status_mask &= ~UART_LSR_DR;
-        serial_out(up, UART_IER, up->ier);
-}
-
-static void serial8250_enable_ms(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-
-        up->ier |= UART_IER_MSI;
-        serial_out(up, UART_IER, up->ier);
-}
-
-static void
-receive_chars(struct uart_8250_port *up, int *status, struct pt_regs *regs)
-{
-        struct tty_struct *tty = up->port.info->tty;
-        unsigned char ch, flag;
-        int max_count = 256;
-
-        do {
-                ch = serial_inp(up, UART_RX);
-                flag = TTY_NORMAL;
-                up->port.icount.rx++;
-
-                if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
-                                       UART_LSR_FE | UART_LSR_OE))) {
-                        /*
-                         * For statistics only
-                         */
-                        if (*status & UART_LSR_BI) {
-                                *status &= ~(UART_LSR_FE | UART_LSR_PE);
-                                up->port.icount.brk++;
-                                /*
-                                 * We do the SysRQ and SAK checking
-                                 * here because otherwise the break
-                                 * may get masked by ignore_status_mask
-                                 * or read_status_mask.
-                                 */
-                                if (uart_handle_break(&up->port))
-                                        goto ignore_char;
-                        } else if (*status & UART_LSR_PE)
-                                up->port.icount.parity++;
-                        else if (*status & UART_LSR_FE)
-                                up->port.icount.frame++;
-                        if (*status & UART_LSR_OE)
-                                up->port.icount.overrun++;
-
-                        /*
-                         * Mask off conditions which should be ingored.
-                         */
-                        *status &= up->port.read_status_mask;
-
-#ifdef CONFIG_SERIAL_AU1X00_CONSOLE
-                        if (up->port.line == up->port.cons->index) {
-                                /* Recover the break flag from console xmit */
-                                *status |= up->lsr_break_flag;
-                                up->lsr_break_flag = 0;
-                        }
-#endif
-                        if (*status & UART_LSR_BI) {
-                                DEBUG_INTR("handling break....");
-                                flag = TTY_BREAK;
-                        } else if (*status & UART_LSR_PE)
-                                flag = TTY_PARITY;
-                        else if (*status & UART_LSR_FE)
-                                flag = TTY_FRAME;
-                }
-                if (uart_handle_sysrq_char(&up->port, ch, regs))
-                        goto ignore_char;
-                if ((*status & up->port.ignore_status_mask) == 0)
-                        tty_insert_flip_char(tty, ch, flag);
-                if (*status & UART_LSR_OE)
-                        /*
-                         * Overrun is special, since it's reported
-                         * immediately, and doesn't affect the current
-                         * character.
-                         */
-                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
-                }
-        ignore_char:
-                *status = serial_inp(up, UART_LSR);
-        } while ((*status & UART_LSR_DR) && (max_count-- > 0));
-        spin_unlock(&up->port.lock);
-        tty_flip_buffer_push(tty);
-        spin_lock(&up->port.lock);
-}
-
-static void transmit_chars(struct uart_8250_port *up)
-{
-        struct circ_buf *xmit = &up->port.info->xmit;
-        int count;
-
-        if (up->port.x_char) {
-                serial_outp(up, UART_TX, up->port.x_char);
-                up->port.icount.tx++;
-                up->port.x_char = 0;
-                return;
-        }
-        if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
-                serial8250_stop_tx(&up->port);
-                return;
-        }
-
-        count = up->port.fifosize;
-        do {
-                serial_out(up, UART_TX, xmit->buf[xmit->tail]);
-                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
-                up->port.icount.tx++;
-                if (uart_circ_empty(xmit))
-                        break;
-        } while (--count > 0);
-
-        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
-                uart_write_wakeup(&up->port);
-
-        DEBUG_INTR("THRE...");
-
-        if (uart_circ_empty(xmit))
-                serial8250_stop_tx(&up->port);
-}
-
-static void check_modem_status(struct uart_8250_port *up)
-{
-        int status;
-
-        status = serial_in(up, UART_MSR);
-
-        if ((status & UART_MSR_ANY_DELTA) == 0)
-                return;
-
-        if (status & UART_MSR_TERI)
-                up->port.icount.rng++;
-        if (status & UART_MSR_DDSR)
-                up->port.icount.dsr++;
-        if (status & UART_MSR_DDCD)
-                uart_handle_dcd_change(&up->port, status & UART_MSR_DCD);
-        if (status & UART_MSR_DCTS)
-                uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
-
-        wake_up_interruptible(&up->port.info->delta_msr_wait);
-}
-
-/*
- * This handles the interrupt from one port.
- */
-static inline void
-serial8250_handle_port(struct uart_8250_port *up, struct pt_regs *regs)
-{
-        unsigned int status = serial_inp(up, UART_LSR);
-
-        DEBUG_INTR("status = %x...", status);
-
-        if (status & UART_LSR_DR)
-                receive_chars(up, &status, regs);
-        check_modem_status(up);
-        if (status & UART_LSR_THRE)
-                transmit_chars(up);
-}
-
-/*
- * This is the serial driver's interrupt routine.
- *
- * Arjan thinks the old way was overly complex, so it got simplified.
- * Alan disagrees, saying that need the complexity to handle the weird
- * nature of ISA shared interrupts.  (This is a special exception.)
- *
- * In order to handle ISA shared interrupts properly, we need to check
- * that all ports have been serviced, and therefore the ISA interrupt
- * line has been de-asserted.
- *
- * This means we need to loop through all ports. checking that they
- * don't have an interrupt pending.
- */
-static irqreturn_t serial8250_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        struct irq_info *i = dev_id;
-        struct list_head *l, *end = NULL;
-        int pass_counter = 0;
-
-        DEBUG_INTR("serial8250_interrupt(%d)...", irq);
-
-        spin_lock(&i->lock);
-
-        l = i->head;
-        do {
-                struct uart_8250_port *up;
-                unsigned int iir;
-
-                up = list_entry(l, struct uart_8250_port, list);
-
-                iir = serial_in(up, UART_IIR);
-                if (!(iir & UART_IIR_NO_INT)) {
-                        spin_lock(&up->port.lock);
-                        serial8250_handle_port(up, regs);
-                        spin_unlock(&up->port.lock);
-
-                        end = NULL;
-                } else if (end == NULL)
-                        end = l;
-
-                l = l->next;
-
-                if (l == i->head && pass_counter++ > PASS_LIMIT) {
-                        /* If we hit this, we're dead. */
-                        printk(KERN_ERR "serial8250: too much work for "
-                                "irq%d\n", irq);
-                        break;
-                }
-        } while (l != end);
-
-        spin_unlock(&i->lock);
-
-        DEBUG_INTR("end.\n");
-        /* FIXME! Was it really ours? */
-        return IRQ_HANDLED;
-}
-
-/*
- * To support ISA shared interrupts, we need to have one interrupt
- * handler that ensures that the IRQ line has been deasserted
- * before returning.  Failing to do this will result in the IRQ
- * line being stuck active, and, since ISA irqs are edge triggered,
- * no more IRQs will be seen.
- */
-static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
-{
-        spin_lock_irq(&i->lock);
-
-        if (!list_empty(i->head)) {
-                if (i->head == &up->list)
-                        i->head = i->head->next;
-                list_del(&up->list);
-        } else {
-                BUG_ON(i->head != &up->list);
-                i->head = NULL;
-        }
-
-        spin_unlock_irq(&i->lock);
-}
-
-static int serial_link_irq_chain(struct uart_8250_port *up)
-{
-        struct irq_info *i = irq_lists + up->port.irq;
-        int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? SA_SHIRQ : 0;
-
-        spin_lock_irq(&i->lock);
-
-        if (i->head) {
-                list_add(&up->list, i->head);
-                spin_unlock_irq(&i->lock);
-
-                ret = 0;
-        } else {
-                INIT_LIST_HEAD(&up->list);
-                i->head = &up->list;
-                spin_unlock_irq(&i->lock);
-
-                ret = request_irq(up->port.irq, serial8250_interrupt,
-                                  irq_flags, "serial", i);
-                if (ret < 0)
-                        serial_do_unlink(i, up);
-        }
-
-        return ret;
-}
-
-static void serial_unlink_irq_chain(struct uart_8250_port *up)
-{
-        struct irq_info *i = irq_lists + up->port.irq;
-
-        BUG_ON(i->head == NULL);
-
-        if (list_empty(i->head))
-                free_irq(up->port.irq, i);
-
-        serial_do_unlink(i, up);
-}
-
-/*
- * This function is used to handle ports that do not have an
- * interrupt.  This doesn't work very well for 16450's, but gives
- * barely passable results for a 16550A.  (Although at the expense
- * of much CPU overhead).
- */
-static void serial8250_timeout(unsigned long data)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)data;
-        unsigned int timeout;
-        unsigned int iir;
-
-        iir = serial_in(up, UART_IIR);
-        if (!(iir & UART_IIR_NO_INT)) {
-                spin_lock(&up->port.lock);
-                serial8250_handle_port(up, NULL);
-                spin_unlock(&up->port.lock);
-        }
-
-        timeout = up->port.timeout;
-        timeout = timeout > 6 ? (timeout / 2 - 2) : 1;
-        mod_timer(&up->timer, jiffies + timeout);
-}
-
-static unsigned int serial8250_tx_empty(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        unsigned long flags;
-        unsigned int ret;
-
-        spin_lock_irqsave(&up->port.lock, flags);
-        ret = serial_in(up, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
-        spin_unlock_irqrestore(&up->port.lock, flags);
-
-        return ret;
-}
-
-static unsigned int serial8250_get_mctrl(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        unsigned char status;
-        unsigned int ret;
-
-        status = serial_in(up, UART_MSR);
-
-        ret = 0;
-        if (status & UART_MSR_DCD)
-                ret |= TIOCM_CAR;
-        if (status & UART_MSR_RI)
-                ret |= TIOCM_RNG;
-        if (status & UART_MSR_DSR)
-                ret |= TIOCM_DSR;
-        if (status & UART_MSR_CTS)
-                ret |= TIOCM_CTS;
-        return ret;
-}
-
-static void serial8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        unsigned char mcr = 0;
-
-        if (mctrl & TIOCM_RTS)
-                mcr |= UART_MCR_RTS;
-        if (mctrl & TIOCM_DTR)
-                mcr |= UART_MCR_DTR;
-        if (mctrl & TIOCM_OUT1)
-                mcr |= UART_MCR_OUT1;
-        if (mctrl & TIOCM_OUT2)
-                mcr |= UART_MCR_OUT2;
-        if (mctrl & TIOCM_LOOP)
-                mcr |= UART_MCR_LOOP;
-
-        mcr = (mcr & up->mcr_mask) | up->mcr_force;
-
-        serial_out(up, UART_MCR, mcr);
-}
-
-static void serial8250_break_ctl(struct uart_port *port, int break_state)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        unsigned long flags;
-
-        spin_lock_irqsave(&up->port.lock, flags);
-        if (break_state == -1)
-                up->lcr |= UART_LCR_SBC;
-        else
-                up->lcr &= ~UART_LCR_SBC;
-        serial_out(up, UART_LCR, up->lcr);
-        spin_unlock_irqrestore(&up->port.lock, flags);
-}
-
-static int serial8250_startup(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        unsigned long flags;
-        int retval;
-
-        /*
-         * Clear the FIFO buffers and disable them.
-         * (they will be reeanbled in set_termios())
-         */
-        if (uart_config[up->port.type].flags & UART_CLEAR_FIFO) {
-                serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
-                serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO |
-                                UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
-                serial_outp(up, UART_FCR, 0);
-        }
-
-        /*
-         * Clear the interrupt registers.
-         */
-        (void) serial_inp(up, UART_LSR);
-        (void) serial_inp(up, UART_RX);
-        (void) serial_inp(up, UART_IIR);
-        (void) serial_inp(up, UART_MSR);
-
-        /*
-         * At this point, there's no way the LSR could still be 0xff;
-         * if it is, then bail out, because there's likely no UART
-         * here.
-         */
-        if (!(up->port.flags & UPF_BUGGY_UART) &&
-            (serial_inp(up, UART_LSR) == 0xff)) {
-                printk("ttyS%d: LSR safety check engaged!\n", up->port.line);
-                return -ENODEV;
-        }
-
-        retval = serial_link_irq_chain(up);
-                if (retval)
-                        return retval;
-
-        /*
-         * Now, initialize the UART
-         */
-        serial_outp(up, UART_LCR, UART_LCR_WLEN8);
-
-        spin_lock_irqsave(&up->port.lock, flags);
-        if (up->port.flags & UPF_FOURPORT) {
-                if (!is_real_interrupt(up->port.irq))
-                        up->port.mctrl |= TIOCM_OUT1;
-        } else
-                /*
-                 * Most PC uarts need OUT2 raised to enable interrupts.
-                 */
-                if (is_real_interrupt(up->port.irq))
-                        up->port.mctrl |= TIOCM_OUT2;
-
-        serial8250_set_mctrl(&up->port, up->port.mctrl);
-        spin_unlock_irqrestore(&up->port.lock, flags);
-
-        /*
-         * Finally, enable interrupts.  Note: Modem status interrupts
-         * are set via set_termios(), which will be occurring imminently
-         * anyway, so we don't enable them here.
-         */
-        up->ier = UART_IER_RLSI | UART_IER_RDI;
-        serial_outp(up, UART_IER, up->ier);
-
-        if (up->port.flags & UPF_FOURPORT) {
-                unsigned int icp;
-                /*
-                 * Enable interrupts on the AST Fourport board
-                 */
-                icp = (up->port.iobase & 0xfe0) | 0x01f;
-                outb_p(0x80, icp);
-                (void) inb_p(icp);
-        }
-
-        /*
-         * And clear the interrupt registers again for luck.
-         */
-        (void) serial_inp(up, UART_LSR);
-        (void) serial_inp(up, UART_RX);
-        (void) serial_inp(up, UART_IIR);
-        (void) serial_inp(up, UART_MSR);
-
-        return 0;
-}
-
-static void serial8250_shutdown(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        unsigned long flags;
-
-        /*
-         * Disable interrupts from this port
-         */
-        up->ier = 0;
-        serial_outp(up, UART_IER, 0);
-
-        spin_lock_irqsave(&up->port.lock, flags);
-        if (up->port.flags & UPF_FOURPORT) {
-                /* reset interrupts on the AST Fourport board */
-                inb((up->port.iobase & 0xfe0) | 0x1f);
-                up->port.mctrl |= TIOCM_OUT1;
-        } else
-                up->port.mctrl &= ~TIOCM_OUT2;
-
-        serial8250_set_mctrl(&up->port, up->port.mctrl);
-        spin_unlock_irqrestore(&up->port.lock, flags);
-
-        /*
-         * Disable break condition and FIFOs
-         */
-        serial_out(up, UART_LCR, serial_inp(up, UART_LCR) & ~UART_LCR_SBC);
-        serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO |
-                                  UART_FCR_CLEAR_RCVR |
-                                  UART_FCR_CLEAR_XMIT);
-        serial_outp(up, UART_FCR, 0);
-
-        /*
-         * Read data port to reset things, and then unlink from
-         * the IRQ chain.
-         */
-        (void) serial_in(up, UART_RX);
-
-        if (!is_real_interrupt(up->port.irq))
-                del_timer_sync(&up->timer);
-        else
-                serial_unlink_irq_chain(up);
-}
-
-static unsigned int serial8250_get_divisor(struct uart_port *port, unsigned int baud)
-{
-        unsigned int quot;
-
-        /*
-         * Handle magic divisors for baud rates above baud_base on
-         * SMSC SuperIO chips.
-         */
-        if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
-            baud == (port->uartclk/4))
-                quot = 0x8001;
-        else if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
-                 baud == (port->uartclk/8))
-                quot = 0x8002;
-        else
-                quot = uart_get_divisor(port, baud);
-
-        return quot;
-}
-
-static void
-serial8250_set_termios(struct uart_port *port, struct termios *termios,
-                       struct termios *old)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        unsigned char cval, fcr = 0;
-        unsigned long flags;
-        unsigned int baud, quot;
-
-        switch (termios->c_cflag & CSIZE) {
-        case CS5:
-                cval = UART_LCR_WLEN5;
-                break;
-        case CS6:
-                cval = UART_LCR_WLEN6;
-                break;
-        case CS7:
-                cval = UART_LCR_WLEN7;
-                break;
-        default:
-        case CS8:
-                cval = UART_LCR_WLEN8;
-                break;
-        }
-
-        if (termios->c_cflag & CSTOPB)
-                cval |= UART_LCR_STOP;
-        if (termios->c_cflag & PARENB)
-                cval |= UART_LCR_PARITY;
-        if (!(termios->c_cflag & PARODD))
-                cval |= UART_LCR_EPAR;
-#ifdef CMSPAR
-        if (termios->c_cflag & CMSPAR)
-                cval |= UART_LCR_SPAR;
-#endif
-
-        /*
-         * Ask the core to calculate the divisor for us.
-         */
-        baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); 
-        quot = serial8250_get_divisor(port, baud);
-        quot = 0x35; /* FIXME */
-
-        /*
-         * Work around a bug in the Oxford Semiconductor 952 rev B
-         * chip which causes it to seriously miscalculate baud rates
-         * when DLL is 0.
-         */
-        if ((quot & 0xff) == 0 && up->port.type == PORT_16C950 &&
-            up->rev == 0x5201)
-                quot ++;
-
-        if (uart_config[up->port.type].flags & UART_USE_FIFO) {
-                if (baud < 2400)
-                        fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIGGER_1;
-                else
-                        fcr = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIGGER_8;
-        }
-
-        /*
-         * Ok, we're now changing the port state.  Do it with
-         * interrupts disabled.
-         */
-        spin_lock_irqsave(&up->port.lock, flags);
-
-        /*
-         * Update the per-port timeout.
-         */
-        uart_update_timeout(port, termios->c_cflag, baud);
-
-        up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
-        if (termios->c_iflag & INPCK)
-                up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
-        if (termios->c_iflag & (BRKINT | PARMRK))
-                up->port.read_status_mask |= UART_LSR_BI;
-
-        /*
-         * Characteres to ignore
-         */
-        up->port.ignore_status_mask = 0;
-        if (termios->c_iflag & IGNPAR)
-                up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
-        if (termios->c_iflag & IGNBRK) {
-                up->port.ignore_status_mask |= UART_LSR_BI;
-                /*
-                 * If we're ignoring parity and break indicators,
-                 * ignore overruns too (for real raw support).
-                 */
-                if (termios->c_iflag & IGNPAR)
-                        up->port.ignore_status_mask |= UART_LSR_OE;
-        }
-
-        /*
-         * ignore all characters if CREAD is not set
-         */
-        if ((termios->c_cflag & CREAD) == 0)
-                up->port.ignore_status_mask |= UART_LSR_DR;
-
-        /*
-         * CTS flow control flag and modem status interrupts
-         */
-        up->ier &= ~UART_IER_MSI;
-        if (UART_ENABLE_MS(&up->port, termios->c_cflag))
-                up->ier |= UART_IER_MSI;
-
-        serial_out(up, UART_IER, up->ier);
-        serial_outp(up, 0x28, quot & 0xffff);
-        up->lcr = cval;                                 /* Save LCR */
-        if (up->port.type != PORT_16750) {
-                if (fcr & UART_FCR_ENABLE_FIFO) {
-                        /* emulated UARTs (Lucent Venus 167x) need two steps */
-                        serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
-                }
-                serial_outp(up, UART_FCR, fcr);         /* set fcr */
-        }
-        spin_unlock_irqrestore(&up->port.lock, flags);
-}
-
-static void
-serial8250_pm(struct uart_port *port, unsigned int state,
-              unsigned int oldstate)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        if (state) {
-                /* sleep */
-                if (up->pm)
-                        up->pm(port, state, oldstate);
-        } else {
-                /* wake */
-                if (up->pm)
-                        up->pm(port, state, oldstate);
-        }
-}
-
-/*
- * Resource handling.  This is complicated by the fact that resources
- * depend on the port type.  Maybe we should be claiming the standard
- * 8250 ports, and then trying to get other resources as necessary?
- */
-static int
-serial8250_request_std_resource(struct uart_8250_port *up, struct resource **res)
-{
-        unsigned int size = 8 << up->port.regshift;
-        int ret = 0;
-
-        switch (up->port.iotype) {
-        case UPIO_MEM:
-                if (up->port.mapbase) {
-                        *res = request_mem_region(up->port.mapbase, size, "serial");
-                        if (!*res)
-                                ret = -EBUSY;
-                }
-                break;
-
-        case UPIO_HUB6:
-        case UPIO_PORT:
-                *res = request_region(up->port.iobase, size, "serial");
-                if (!*res)
-                        ret = -EBUSY;
-                break;
-        }
-        return ret;
-}
-
-
-static void serial8250_release_port(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        unsigned long start, offset = 0, size = 0;
-
-        size <<= up->port.regshift;
-
-        switch (up->port.iotype) {
-        case UPIO_MEM:
-                if (up->port.mapbase) {
-                        /*
-                         * Unmap the area.
-                         */
-                        iounmap(up->port.membase);
-                        up->port.membase = NULL;
-
-                        start = up->port.mapbase;
-
-                        if (size)
-                                release_mem_region(start + offset, size);
-                        release_mem_region(start, 8 << up->port.regshift);
-                }
-                break;
-
-        case UPIO_HUB6:
-        case UPIO_PORT:
-                start = up->port.iobase;
-
-                if (size)
-                        release_region(start + offset, size);
-                release_region(start + offset, 8 << up->port.regshift);
-                break;
-
-        default:
-                break;
-        }
-}
-
-static int serial8250_request_port(struct uart_port *port)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        struct resource *res = NULL, *res_rsa = NULL;
-        int ret = 0;
-
-        ret = serial8250_request_std_resource(up, &res);
-
-        /*
-         * If we have a mapbase, then request that as well.
-         */
-        if (ret == 0 && up->port.flags & UPF_IOREMAP) {
-                int size = res->end - res->start + 1;
-
-                up->port.membase = ioremap(up->port.mapbase, size);
-                if (!up->port.membase)
-                        ret = -ENOMEM;
-        }
-
-        if (ret < 0) {
-                if (res_rsa)
-                        release_resource(res_rsa);
-                if (res)
-                        release_resource(res);
-        }
-        return ret;
-}
-
-static void serial8250_config_port(struct uart_port *port, int flags)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-        struct resource *res_std = NULL, *res_rsa = NULL;
-        int probeflags = PROBE_ANY;
-
-        probeflags &= ~PROBE_RSA;
-
-        if (flags & UART_CONFIG_TYPE)
-                autoconfig(up, probeflags);
-
-        /*
-         * If the port wasn't an RSA port, release the resource.
-         */
-        if (up->port.type != PORT_RSA && res_rsa)
-                release_resource(res_rsa);
-
-        if (up->port.type == PORT_UNKNOWN && res_std)
-                release_resource(res_std);
-}
-
-static int
-serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
-{
-        if (ser->irq >= NR_IRQS || ser->irq < 0 ||
-            ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
-            ser->type > PORT_MAX_8250 || ser->type == PORT_CIRRUS ||
-            ser->type == PORT_STARTECH)
-                return -EINVAL;
-        return 0;
-}
-
-static const char *
-serial8250_type(struct uart_port *port)
-{
-        int type = port->type;
-
-        if (type >= ARRAY_SIZE(uart_config))
-                type = 0;
-        return uart_config[type].name;
-}
-
-static struct uart_ops serial8250_pops = {
-        .tx_empty       = serial8250_tx_empty,
-        .set_mctrl      = serial8250_set_mctrl,
-        .get_mctrl      = serial8250_get_mctrl,
-        .stop_tx        = serial8250_stop_tx,
-        .start_tx       = serial8250_start_tx,
-        .stop_rx        = serial8250_stop_rx,
-        .enable_ms      = serial8250_enable_ms,
-        .break_ctl      = serial8250_break_ctl,
-        .startup        = serial8250_startup,
-        .shutdown       = serial8250_shutdown,
-        .set_termios    = serial8250_set_termios,
-        .pm             = serial8250_pm,
-        .type           = serial8250_type,
-        .release_port   = serial8250_release_port,
-        .request_port   = serial8250_request_port,
-        .config_port    = serial8250_config_port,
-        .verify_port    = serial8250_verify_port,
-};
-
-static struct uart_8250_port serial8250_ports[UART_NR];
-
-static void __init serial8250_isa_init_ports(void)
-{
-        struct uart_8250_port *up;
-        static int first = 1;
-        int i;
-
-        if (!first)
-                return;
-        first = 0;
-
-        for (i = 0, up = serial8250_ports; i < ARRAY_SIZE(old_serial_port);
-             i++, up++) {
-                up->port.iobase   = old_serial_port[i].port;
-                up->port.irq      = old_serial_port[i].irq;
-                up->port.uartclk  = get_au1x00_uart_baud_base();
-                up->port.flags    = old_serial_port[i].flags;
-                up->port.hub6     = old_serial_port[i].hub6;
-                up->port.membase  = old_serial_port[i].iomem_base;
-                up->port.iotype   = old_serial_port[i].io_type;
-                up->port.regshift = old_serial_port[i].iomem_reg_shift;
-                up->port.ops      = &serial8250_pops;
-        }
-}
-
-static void __init serial8250_register_ports(struct uart_driver *drv)
-{
-        int i;
-
-        serial8250_isa_init_ports();
-
-        for (i = 0; i < UART_NR; i++) {
-                struct uart_8250_port *up = &serial8250_ports[i];
-
-                up->port.line = i;
-                up->port.ops = &serial8250_pops;
-                init_timer(&up->timer);
-                up->timer.function = serial8250_timeout;
-
-                /*
-                 * ALPHA_KLUDGE_MCR needs to be killed.
-                 */
-                up->mcr_mask = ~ALPHA_KLUDGE_MCR;
-                up->mcr_force = ALPHA_KLUDGE_MCR;
-
-                uart_add_one_port(drv, &up->port);
-        }
-}
-
-#ifdef CONFIG_SERIAL_AU1X00_CONSOLE
-
-#define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
-
-/*
- *      Wait for transmitter & holding register to empty
- */
-static inline void wait_for_xmitr(struct uart_8250_port *up)
-{
-        unsigned int status, tmout = 10000;
-
-        /* Wait up to 10ms for the character(s) to be sent. */
-        do {
-                status = serial_in(up, UART_LSR);
-
-                if (status & UART_LSR_BI)
-                        up->lsr_break_flag = UART_LSR_BI;
-
-                if (--tmout == 0)
-                        break;
-                udelay(1);
-        } while ((status & BOTH_EMPTY) != BOTH_EMPTY);
-
-        /* Wait up to 1s for flow control if necessary */
-        if (up->port.flags & UPF_CONS_FLOW) {
-                tmout = 1000000;
-                while (--tmout &&
-                       ((serial_in(up, UART_MSR) & UART_MSR_CTS) == 0))
-                        udelay(1);
-        }
-}
-
-static void au1x00_console_putchar(struct uart_port *port, int ch)
-{
-        struct uart_8250_port *up = (struct uart_8250_port *)port;
-
-        wait_for_xmitr(up);
-        serial_out(up, UART_TX, ch);
-}
-
-/*
- *      Print a string to the serial port trying not to disturb
- *      any possible real use of the port...
- *
- *      The console_lock must be held when we get here.
- */
-static void
-serial8250_console_write(struct console *co, const char *s, unsigned int count)
-{
-        struct uart_8250_port *up = &serial8250_ports[co->index];
-        unsigned int ier;
-
-        /*
-         *      First save the UER then disable the interrupts
-         */
-        ier = serial_in(up, UART_IER);
-        serial_out(up, UART_IER, 0);
-
-        uart_console_write(&up->port, s, count, au1x00_console_putchar);
-
-        /*
-         *      Finally, wait for transmitter to become empty
-         *      and restore the IER
-         */
-        wait_for_xmitr(up);
-        serial_out(up, UART_IER, ier);
-}
-
-static int __init serial8250_console_setup(struct console *co, char *options)
-{
-        struct uart_port *port;
-        int baud = 9600;
-        int bits = 8;
-        int parity = 'n';
-        int flow = 'n';
-
-        /*
-         * Check whether an invalid uart number has been specified, and
-         * if so, search for the first available port that does have
-         * console support.
-         */
-        if (co->index >= UART_NR)
-                co->index = 0;
-        port = &serial8250_ports[co->index].port;
-
-        /*
-         * Temporary fix.
-         */
-        spin_lock_init(&port->lock);
-
-        if (options)
-                uart_parse_options(options, &baud, &parity, &bits, &flow);
-
-        return uart_set_options(port, co, baud, parity, bits, flow);
-}
-
-extern struct uart_driver serial8250_reg;
-static struct console serial8250_console = {
-        .name           = "ttyS",
-        .write          = serial8250_console_write,
-        .device         = uart_console_device,
-        .setup          = serial8250_console_setup,
-        .flags          = CON_PRINTBUFFER,
-        .index          = -1,
-        .data           = &serial8250_reg,
-};
-
-static int __init serial8250_console_init(void)
-{
-        serial8250_isa_init_ports();
-        register_console(&serial8250_console);
-        return 0;
-}
-console_initcall(serial8250_console_init);
-
-#define SERIAL8250_CONSOLE      &serial8250_console
-#else
-#define SERIAL8250_CONSOLE      NULL
-#endif
-
-static struct uart_driver serial8250_reg = {
-        .owner                  = THIS_MODULE,
-        .driver_name            = "serial",
-        .devfs_name             = "tts/",
-        .dev_name               = "ttyS",
-        .major                  = TTY_MAJOR,
-        .minor                  = 64,
-        .nr                     = UART_NR,
-        .cons                   = SERIAL8250_CONSOLE,
-};
-
-int __init early_serial_setup(struct uart_port *port)
-{
-        serial8250_isa_init_ports();
-        serial8250_ports[port->line].port       = *port;
-        serial8250_ports[port->line].port.ops   = &serial8250_pops;
-        return 0;
-}
-
-/**
- *      serial8250_suspend_port - suspend one serial port
- *      @line:  serial line number
- *      @level: the level of port suspension, as per uart_suspend_port
- *
- *      Suspend one serial port.
- */
-void serial8250_suspend_port(int line)
-{
-        uart_suspend_port(&serial8250_reg, &serial8250_ports[line].port);
-}
-
-/**
- *      serial8250_resume_port - resume one serial port
- *      @line:  serial line number
- *      @level: the level of port resumption, as per uart_resume_port
- *
- *      Resume one serial port.
- */
-void serial8250_resume_port(int line)
-{
-        uart_resume_port(&serial8250_reg, &serial8250_ports[line].port);
-}
-
-static int __init serial8250_init(void)
-{
-        int ret, i;
-
-        printk(KERN_INFO "Serial: Au1x00 driver\n");
-
-        for (i = 0; i < NR_IRQS; i++)
-                spin_lock_init(&irq_lists[i].lock);
-
-        ret = uart_register_driver(&serial8250_reg);
-        if (ret >= 0)
-                serial8250_register_ports(&serial8250_reg);
-
-        return ret;
-}
-
-static void __exit serial8250_exit(void)
-{
-        int i;
-
-        for (i = 0; i < UART_NR; i++)
-                uart_remove_one_port(&serial8250_reg, &serial8250_ports[i].port);
-
-        uart_unregister_driver(&serial8250_reg);
-}
-
-module_init(serial8250_init);
-module_exit(serial8250_exit);
-
-EXPORT_SYMBOL(serial8250_suspend_port);
-EXPORT_SYMBOL(serial8250_resume_port);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Au1x00 serial driver\n");
diff --git a/drivers/serial/serial_txx9.c b/drivers/serial/serial_txx9.c
index b848b7d94412..3bdee64d1a99 100644
--- a/drivers/serial/serial_txx9.c
+++ b/drivers/serial/serial_txx9.c
@@ -483,7 +483,7 @@ static int serial_txx9_startup(struct uart_port *port)
 
         /*
          * Clear the FIFO buffers and disable them.
-         * (they will be reeanbled in set_termios())
+         * (they will be reenabled in set_termios())
          */
         sio_set(up, TXX9_SIFCR,
                 TXX9_SIFCR_TFRST | TXX9_SIFCR_RFRST | TXX9_SIFCR_FRSTE);
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index 9fe2283d91e5..1c4396c2962d 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -641,7 +641,7 @@ static int sunsu_startup(struct uart_port *port)
 
         /*
          * Clear the FIFO buffers and disable them.
-         * (they will be reeanbled in set_termios())
+         * (they will be reenabled in set_termios())
          */
         if (uart_config[up->port.type].flags & UART_CLEAR_FIFO) {
                 serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
diff --git a/drivers/telephony/phonedev.c b/drivers/telephony/phonedev.c
index 7a6db1c5c8c5..e166fffea86b 100644
--- a/drivers/telephony/phonedev.c
+++ b/drivers/telephony/phonedev.c
@@ -49,7 +49,7 @@ static int phone_open(struct inode *inode, struct file *file)
         unsigned int minor = iminor(inode);
         int err = 0;
         struct phone_device *p;
-        struct file_operations *old_fops, *new_fops = NULL;
+        const struct file_operations *old_fops, *new_fops = NULL;
 
         if (minor >= PHONE_NUM_DEVICES)
                 return -ENODEV;
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index 37b13368c814..b263a54a13c0 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -24,15 +24,15 @@
 #include "usb.h"
 
 #define MAX_USB_MINORS  256
-static struct file_operations *usb_minors[MAX_USB_MINORS];
+static const struct file_operations *usb_minors[MAX_USB_MINORS];
 static DEFINE_SPINLOCK(minor_lock);
 
 static int usb_open(struct inode * inode, struct file * file)
 {
         int minor = iminor(inode);
-        struct file_operations *c;
+        const struct file_operations *c;
         int err = -ENODEV;
-        struct file_operations *old_fops, *new_fops = NULL;
+        const struct file_operations *old_fops, *new_fops = NULL;
 
         spin_lock (&minor_lock);
         c = usb_minors[minor];
diff --git a/drivers/usb/core/notify.c b/drivers/usb/core/notify.c
index 4b55285de9a0..fe0ed54fa0ae 100644
--- a/drivers/usb/core/notify.c
+++ b/drivers/usb/core/notify.c
@@ -16,57 +16,7 @@
 #include <linux/mutex.h>
 #include "usb.h"
 
-
-static struct notifier_block *usb_notifier_list;
-static DEFINE_MUTEX(usb_notifier_lock);
-
-static void usb_notifier_chain_register(struct notifier_block **list,
-                                        struct notifier_block *n)
-{
-        mutex_lock(&usb_notifier_lock);
-        while (*list) {
-                if (n->priority > (*list)->priority)
-                        break;
-                list = &((*list)->next);
-        }
-        n->next = *list;
-        *list = n;
-        mutex_unlock(&usb_notifier_lock);
-}
-
-static void usb_notifier_chain_unregister(struct notifier_block **nl,
-                                   struct notifier_block *n)
-{
-        mutex_lock(&usb_notifier_lock);
-        while ((*nl)!=NULL) {
-                if ((*nl)==n) {
-                        *nl = n->next;
-                        goto exit;
-                }
-                nl=&((*nl)->next);
-        }
-exit:
-        mutex_unlock(&usb_notifier_lock);
-}
-
-static int usb_notifier_call_chain(struct notifier_block **n,
-                                   unsigned long val, void *v)
-{
-        int ret=NOTIFY_DONE;
-        struct notifier_block *nb = *n;
-
-        mutex_lock(&usb_notifier_lock);
-        while (nb) {
-                ret = nb->notifier_call(nb,val,v);
-                if (ret&NOTIFY_STOP_MASK) {
-                        goto exit;
-                }
-                nb = nb->next;
-        }
-exit:
-        mutex_unlock(&usb_notifier_lock);
-        return ret;
-}
+static BLOCKING_NOTIFIER_HEAD(usb_notifier_list);
 
 /**
  * usb_register_notify - register a notifier callback whenever a usb change happens
@@ -76,7 +26,7 @@ exit:
  */
 void usb_register_notify(struct notifier_block *nb)
 {
-        usb_notifier_chain_register(&usb_notifier_list, nb);
+        blocking_notifier_chain_register(&usb_notifier_list, nb);
 }
 EXPORT_SYMBOL_GPL(usb_register_notify);
 
@@ -89,27 +39,28 @@ EXPORT_SYMBOL_GPL(usb_register_notify);
  */
 void usb_unregister_notify(struct notifier_block *nb)
 {
-        usb_notifier_chain_unregister(&usb_notifier_list, nb);
+        blocking_notifier_chain_unregister(&usb_notifier_list, nb);
 }
 EXPORT_SYMBOL_GPL(usb_unregister_notify);
 
 
 void usb_notify_add_device(struct usb_device *udev)
 {
-        usb_notifier_call_chain(&usb_notifier_list, USB_DEVICE_ADD, udev);
+        blocking_notifier_call_chain(&usb_notifier_list, USB_DEVICE_ADD, udev);
 }
 
 void usb_notify_remove_device(struct usb_device *udev)
 {
-        usb_notifier_call_chain(&usb_notifier_list, USB_DEVICE_REMOVE, udev);
+        blocking_notifier_call_chain(&usb_notifier_list,
+                        USB_DEVICE_REMOVE, udev);
 }
 
 void usb_notify_add_bus(struct usb_bus *ubus)
 {
-        usb_notifier_call_chain(&usb_notifier_list, USB_BUS_ADD, ubus);
+        blocking_notifier_call_chain(&usb_notifier_list, USB_BUS_ADD, ubus);
 }
 
 void usb_notify_remove_bus(struct usb_bus *ubus)
 {
-        usb_notifier_call_chain(&usb_notifier_list, USB_BUS_REMOVE, ubus);
+        blocking_notifier_call_chain(&usb_notifier_list, USB_BUS_REMOVE, ubus);
 }
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index b44cfda76b61..3f618ce6998d 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -1581,7 +1581,7 @@ restart:
 
 static struct inode *
 gadgetfs_create_file (struct super_block *sb, char const *name,
-                void *data, struct file_operations *fops,
+                void *data, const struct file_operations *fops,
                 struct dentry **dentry_p);
 
 static int activate_ep_files (struct dev_data *dev)
@@ -1955,7 +1955,7 @@ module_param (default_perm, uint, 0644);
 
 static struct inode *
 gadgetfs_make_inode (struct super_block *sb,
-                void *data, struct file_operations *fops,
+                void *data, const struct file_operations *fops,
                 int mode)
 {
         struct inode *inode = new_inode (sb);
@@ -1979,7 +1979,7 @@ gadgetfs_make_inode (struct super_block *sb,
  */
 static struct inode *
 gadgetfs_create_file (struct super_block *sb, char const *name,
-                void *data, struct file_operations *fops,
+                void *data, const struct file_operations *fops,
                 struct dentry **dentry_p)
 {
         struct dentry   *dentry;
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index 372527a83593..682bf2215660 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -158,7 +158,7 @@ static int ohci_s3c2410_hub_control (
                 "s3c2410_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
                 hcd, typeReq, wValue, wIndex, buf, wLength);
 
-        /* if we are only an humble host without any special capabilites
+        /* if we are only an humble host without any special capabilities
          * process the request straight away and exit */
 
         if (info == NULL) {
diff --git a/drivers/usb/net/zaurus.c b/drivers/usb/net/zaurus.c
index 9c5ab251370c..f7ac9d6b9856 100644
--- a/drivers/usb/net/zaurus.c
+++ b/drivers/usb/net/zaurus.c
@@ -217,7 +217,7 @@ static int blan_mdlm_bind(struct usbnet *dev, struct usb_interface *intf)
                          * with devices that use it and those that don't.
                          */
                         if ((detail->bDetailData[1] & ~0x02) != 0x01) {
-                                /* bmDataCapabilites == 0 would be fine too,
+                                /* bmDataCapabilities == 0 would be fine too,
                                  * but framing is minidriver-coupled for now.
                                  */
 bad_detail:
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index fdebd60a3250..22e9d696fdd2 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -70,6 +70,22 @@ config FB_MACMODES
        depends on FB
        default n
 
+config FB_FIRMWARE_EDID
+       bool "Enable firmware EDID"
+       depends on FB
+       default y
+       ---help---
+         This enables access to the EDID transferred from the firmware.
+         On the i386, this is from the Video BIOS. Enable this if DDC/I2C
+         transfers do not work for your driver and if you are using
+         nvidiafb, i810fb or savagefb.
+
+         In general, choosing Y for this option is safe.  If you
+         experience extremely long delays while booting before you get
+         something on your display, try setting this to N.  Matrox cards in
+         combination with certain motherboards and monitors are known to
+         suffer from this problem.
+
 config FB_MODE_HELPERS
         bool "Enable Video Mode Handling Helpers"
         depends on FB
@@ -1202,6 +1218,17 @@ config FB_AU1100
         bool "Au1100 LCD Driver"
         depends on (FB = y) && EXPERIMENTAL && PCI && MIPS && MIPS_PB1100=y
 
+config FB_AU1200
+        bool "Au1200 LCD Driver"
+        depends on FB && MIPS && SOC_AU1200
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        help
+          This is the framebuffer driver for the AMD Au1200 SOC.  It can drive
+          various panels and CRTs by passing in kernel cmd line option
+          au1200fb:panel=<name>.
+
 source "drivers/video/geode/Kconfig"
 
 config FB_FFB
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index aa434e725c0d..cb90218515ac 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -86,6 +86,7 @@ obj-$(CONFIG_FB_ASILIANT)	  += asiliantfb.o
 obj-$(CONFIG_FB_PXA)              += pxafb.o
 obj-$(CONFIG_FB_W100)             += w100fb.o
 obj-$(CONFIG_FB_AU1100)           += au1100fb.o
+obj-$(CONFIG_FB_AU1200)           += au1200fb.o
 obj-$(CONFIG_FB_PMAG_AA)          += pmag-aa-fb.o
 obj-$(CONFIG_FB_PMAG_BA)          += pmag-ba-fb.o
 obj-$(CONFIG_FB_PMAGB_B)          += pmagb-b-fb.o
diff --git a/drivers/video/acornfb.c b/drivers/video/acornfb.c
index 76448d6ae896..98baecccb3fd 100644
--- a/drivers/video/acornfb.c
+++ b/drivers/video/acornfb.c
@@ -1308,7 +1308,7 @@ static int __init acornfb_probe(struct platform_device *dev)
         /*
          * Try to select a suitable default mode
          */
-        for (i = 0; i < sizeof(modedb) / sizeof(*modedb); i++) {
+        for (i = 0; i < ARRAY_SIZE(modedb); i++) {
                 unsigned long hs;
 
                 hs = modedb[i].refresh *
@@ -1380,7 +1380,7 @@ static int __init acornfb_probe(struct platform_device *dev)
          */
         free_unused_pages(PAGE_OFFSET + size, PAGE_OFFSET + MAX_SIZE);
 #endif
-        
+
         fb_info.fix.smem_len = size;
         current_par.palette_size   = VIDC_PALETTE_SIZE;
 
@@ -1391,7 +1391,7 @@ static int __init acornfb_probe(struct platform_device *dev)
          */
         do {
                 rc = fb_find_mode(&fb_info.var, &fb_info, NULL, modedb,
-                                 sizeof(modedb) / sizeof(*modedb),
+                                 ARRAY_SIZE(modedb),
                                  &acornfb_default_mode, DEFAULT_BPP);
                 /*
                  * If we found an exact match, all ok.
@@ -1408,7 +1408,7 @@ static int __init acornfb_probe(struct platform_device *dev)
                         break;
 
                 rc = fb_find_mode(&fb_info.var, &fb_info, NULL, modedb,
-                                 sizeof(modedb) / sizeof(*modedb),
+                                 ARRAY_SIZE(modedb),
                                  &acornfb_default_mode, DEFAULT_BPP);
                 if (rc)
                         break;
diff --git a/drivers/video/asiliantfb.c b/drivers/video/asiliantfb.c
index c924d81f7978..29f9f0dfe3b4 100644
--- a/drivers/video/asiliantfb.c
+++ b/drivers/video/asiliantfb.c
@@ -353,8 +353,6 @@ struct chips_init_reg {
         unsigned char data;
 };
 
-#define N_ELTS(x)       (sizeof(x) / sizeof(x[0]))
-
 static struct chips_init_reg chips_init_sr[] =
 {
         {0x00, 0x03},           /* Reset register */
@@ -460,22 +458,22 @@ static void __devinit chips_hw_init(struct fb_info *p)
 {
         int i;
 
-        for (i = 0; i < N_ELTS(chips_init_xr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_xr); ++i)
                 write_xr(chips_init_xr[i].addr, chips_init_xr[i].data);
         write_xr(0x81, 0x12);
         write_xr(0x82, 0x08);
         write_xr(0x20, 0x00);
-        for (i = 0; i < N_ELTS(chips_init_sr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_sr); ++i)
                 write_sr(chips_init_sr[i].addr, chips_init_sr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_gr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_gr); ++i)
                 write_gr(chips_init_gr[i].addr, chips_init_gr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_ar); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_ar); ++i)
                 write_ar(chips_init_ar[i].addr, chips_init_ar[i].data);
         /* Enable video output in attribute index register */
         writeb(0x20, mmio_base + 0x780);
-        for (i = 0; i < N_ELTS(chips_init_cr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_cr); ++i)
                 write_cr(chips_init_cr[i].addr, chips_init_cr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_fr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_fr); ++i)
                 write_fr(chips_init_fr[i].addr, chips_init_fr[i].data);
 }
 
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index f07be22e119d..f7bbff4ddc6a 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1726,9 +1726,9 @@ static int __init aty128_init(struct pci_dev *pdev, const struct pci_device_id *
         strcpy(video_card, "Rage128 XX ");
         video_card[8] = ent->device >> 8;
         video_card[9] = ent->device & 0xFF;
-            
+
         /* range check to make sure */
-        if (ent->driver_data < (sizeof(r128_family)/sizeof(char *)))
+        if (ent->driver_data < ARRAY_SIZE(r128_family))
             strncat(video_card, r128_family[ent->driver_data], sizeof(video_card));
 
         printk(KERN_INFO "aty128fb: %s [chip rev 0x%x] ", video_card, chip_rev);
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 1b1f24e2bfbe..b39e72d5413b 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -435,7 +435,7 @@ static int __devinit correct_chipset(struct atyfb_par *par)
         const char *name;
         int i;
 
-        for (i = sizeof(aty_chips) / sizeof(*aty_chips) - 1; i >= 0; i--)
+        for (i = ARRAY_SIZE(aty_chips) - 1; i >= 0; i--)
                 if (par->pci_id == aty_chips[i].pci_id)
                         break;
 
@@ -2169,10 +2169,10 @@ static void __init aty_calc_mem_refresh(struct atyfb_par *par, int xclk)
 
         if (IS_XL(par->pci_id) || IS_MOBILITY(par->pci_id)) {
                 refresh_tbl = ragexl_tbl;
-                size = sizeof(ragexl_tbl)/sizeof(int);
+                size = ARRAY_SIZE(ragexl_tbl);
         } else {
                 refresh_tbl = ragepro_tbl;
-                size = sizeof(ragepro_tbl)/sizeof(int);
+                size = ARRAY_SIZE(ragepro_tbl);
         }
 
         for (i=0; i < size; i++) {
@@ -2299,6 +2299,10 @@ static int __init aty_init(struct fb_info *info, const char *name)
                 case CLK_ATI18818_1:
                         par->pll_ops = &aty_pll_ati18818_1;
                         break;
+                case CLK_IBMRGB514:
+                        par->pll_ops = &aty_pll_ibm514;
+                        break;
+#if 0 /* dead code */
                 case CLK_STG1703:
                         par->pll_ops = &aty_pll_stg1703;
                         break;
@@ -2308,9 +2312,7 @@ static int __init aty_init(struct fb_info *info, const char *name)
                 case CLK_ATT20C408:
                         par->pll_ops = &aty_pll_att20c408;
                         break;
-                case CLK_IBMRGB514:
-                        par->pll_ops = &aty_pll_ibm514;
-                        break;
+#endif
                 default:
                         PRINTKI("aty_init: CLK type not implemented yet!");
                         par->pll_ops = &aty_pll_unsupported;
@@ -3398,7 +3400,7 @@ static int __devinit atyfb_pci_probe(struct pci_dev *pdev, const struct pci_devi
         struct atyfb_par *par;
         int i, rc = -ENOMEM;
 
-        for (i = sizeof(aty_chips) / sizeof(*aty_chips) - 1; i >= 0; i--)
+        for (i = ARRAY_SIZE(aty_chips); i >= 0; i--)
                 if (pdev->device == aty_chips[i].pci_id)
                         break;
 
diff --git a/drivers/video/aty/mach64_gx.c b/drivers/video/aty/mach64_gx.c
index 01fdff79483b..2045639cb671 100644
--- a/drivers/video/aty/mach64_gx.c
+++ b/drivers/video/aty/mach64_gx.c
@@ -149,8 +149,7 @@ static int aty_var_to_pll_514(const struct fb_info *info, u32 vclk_per,
         };
         int i;
 
-        for (i = 0; i < sizeof(RGB514_clocks) / sizeof(*RGB514_clocks);
-             i++)
+        for (i = 0; i < ARRAY_SIZE(RGB514_clocks); i++)
                 if (vclk_per <= RGB514_clocks[i].limit) {
                         pll->ibm514.m = RGB514_clocks[i].m;
                         pll->ibm514.n = RGB514_clocks[i].n;
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index c9f0c5a07e6e..9a6b5b39b88e 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -1067,7 +1067,7 @@ static int radeon_setcolreg (unsigned regno, unsigned red, unsigned green,
 
 
         if (regno > 255)
-                return 1;
+                return -EINVAL;
 
         red >>= 8;
         green >>= 8;
@@ -1086,9 +1086,9 @@ static int radeon_setcolreg (unsigned regno, unsigned red, unsigned green,
                         pindex = regno * 8;
 
                         if (rinfo->depth == 16 && regno > 63)
-                                return 1;
+                                return -EINVAL;
                         if (rinfo->depth == 15 && regno > 31)
-                                return 1;
+                                return -EINVAL;
 
                         /* For 565, the green component is mixed one order
                          * below
diff --git a/drivers/video/au1200fb.c b/drivers/video/au1200fb.c
new file mode 100644
index 000000000000..b367de30b98c
--- /dev/null
+++ b/drivers/video/au1200fb.c
@@ -0,0 +1,3844 @@
+/*
+ * BRIEF MODULE DESCRIPTION
+ *      Au1200 LCD Driver.
+ *
+ * Copyright 2004-2005 AMD
+ * Author: AMD
+ *
+ * Based on:
+ * linux/drivers/video/skeletonfb.c -- Skeleton for a frame buffer device
+ *  Created 28 Dec 1997 by Geert Uytterhoeven
+ *
+ *  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  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  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.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/ctype.h>
+#include <linux/dma-mapping.h>
+
+#include <asm/mach-au1x00/au1000.h>
+#include "au1200fb.h"
+
+#ifdef CONFIG_PM
+#include <asm/mach-au1x00/au1xxx_pm.h>
+#endif
+
+#ifndef CONFIG_FB_AU1200_DEVS
+#define CONFIG_FB_AU1200_DEVS 4
+#endif
+
+#define DRIVER_NAME "au1200fb"
+#define DRIVER_DESC "LCD controller driver for AU1200 processors"
+
+#define DEBUG 1
+
+#define print_err(f, arg...) printk(KERN_ERR DRIVER_NAME ": " f "\n", ## arg)
+#define print_warn(f, arg...) printk(KERN_WARNING DRIVER_NAME ": " f "\n", ## arg)
+#define print_info(f, arg...) printk(KERN_INFO DRIVER_NAME ": " f "\n", ## arg)
+
+#if DEBUG
+#define print_dbg(f, arg...) printk(KERN_DEBUG __FILE__ ": " f "\n", ## arg)
+#else
+#define print_dbg(f, arg...) do {} while (0)
+#endif
+
+
+#define AU1200_LCD_FB_IOCTL 0x46FF
+
+#define AU1200_LCD_SET_SCREEN 1
+#define AU1200_LCD_GET_SCREEN 2
+#define AU1200_LCD_SET_WINDOW 3
+#define AU1200_LCD_GET_WINDOW 4
+#define AU1200_LCD_SET_PANEL  5
+#define AU1200_LCD_GET_PANEL  6
+
+#define SCREEN_SIZE                 (1<< 1)
+#define SCREEN_BACKCOLOR    (1<< 2)
+#define SCREEN_BRIGHTNESS   (1<< 3)
+#define SCREEN_COLORKEY     (1<< 4)
+#define SCREEN_MASK         (1<< 5)
+
+struct au1200_lcd_global_regs_t {
+        unsigned int flags;
+        unsigned int xsize;
+        unsigned int ysize;
+        unsigned int backcolor;
+        unsigned int brightness;
+        unsigned int colorkey;
+        unsigned int mask;
+        unsigned int panel_choice;
+        char panel_desc[80];
+
+};
+
+#define WIN_POSITION            (1<< 0)
+#define WIN_ALPHA_COLOR         (1<< 1)
+#define WIN_ALPHA_MODE          (1<< 2)
+#define WIN_PRIORITY            (1<< 3)
+#define WIN_CHANNEL             (1<< 4)
+#define WIN_BUFFER_FORMAT       (1<< 5)
+#define WIN_COLOR_ORDER         (1<< 6)
+#define WIN_PIXEL_ORDER         (1<< 7)
+#define WIN_SIZE                (1<< 8)
+#define WIN_COLORKEY_MODE       (1<< 9)
+#define WIN_DOUBLE_BUFFER_MODE  (1<< 10)
+#define WIN_RAM_ARRAY_MODE      (1<< 11)
+#define WIN_BUFFER_SCALE        (1<< 12)
+#define WIN_ENABLE                  (1<< 13)
+
+struct au1200_lcd_window_regs_t {
+        unsigned int flags;
+        unsigned int xpos;
+        unsigned int ypos;
+        unsigned int alpha_color;
+        unsigned int alpha_mode;
+        unsigned int priority;
+        unsigned int channel;
+        unsigned int buffer_format;
+        unsigned int color_order;
+        unsigned int pixel_order;
+        unsigned int xsize;
+        unsigned int ysize;
+        unsigned int colorkey_mode;
+        unsigned int double_buffer_mode;
+        unsigned int ram_array_mode;
+        unsigned int xscale;
+        unsigned int yscale;
+        unsigned int enable;
+};
+
+
+struct au1200_lcd_iodata_t {
+        unsigned int subcmd;
+        struct au1200_lcd_global_regs_t global;
+        struct au1200_lcd_window_regs_t window;
+};
+
+#if defined(__BIG_ENDIAN)
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_11
+#else
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_00
+#endif
+#define LCD_CONTROL_DEFAULT_SBPPF LCD_CONTROL_SBPPF_565
+
+/* Private, per-framebuffer management information (independent of the panel itself) */
+struct au1200fb_device {
+        struct fb_info fb_info;                 /* FB driver info record */
+
+        int                                     plane;
+        unsigned char*          fb_mem;         /* FrameBuffer memory map */
+        unsigned int            fb_len;
+        dma_addr_t              fb_phys;
+};
+
+static struct au1200fb_device _au1200fb_devices[CONFIG_FB_AU1200_DEVS];
+/********************************************************************/
+
+/* LCD controller restrictions */
+#define AU1200_LCD_MAX_XRES     1280
+#define AU1200_LCD_MAX_YRES     1024
+#define AU1200_LCD_MAX_BPP      32
+#define AU1200_LCD_MAX_CLK      96000000 /* fixme: this needs to go away ? */
+#define AU1200_LCD_NBR_PALETTE_ENTRIES 256
+
+/* Default number of visible screen buffer to allocate */
+#define AU1200FB_NBR_VIDEO_BUFFERS 1
+
+/********************************************************************/
+
+static struct au1200_lcd *lcd = (struct au1200_lcd *) AU1200_LCD_ADDR;
+static int window_index = 2; /* default is zero */
+static int panel_index = 2; /* default is zero */
+static struct window_settings *win;
+static struct panel_settings *panel;
+static int noblanking = 1;
+static int nohwcursor = 0;
+
+struct window_settings {
+        unsigned char name[64];
+        uint32 mode_backcolor;
+        uint32 mode_colorkey;
+        uint32 mode_colorkeymsk;
+        struct {
+                int xres;
+                int yres;
+                int xpos;
+                int ypos;
+                uint32 mode_winctrl1; /* winctrl1[FRM,CCO,PO,PIPE] */
+                uint32 mode_winenable;
+        } w[4];
+};
+
+#if defined(__BIG_ENDIAN)
+#define LCD_WINCTRL1_PO_16BPP LCD_WINCTRL1_PO_00
+#else
+#define LCD_WINCTRL1_PO_16BPP LCD_WINCTRL1_PO_01
+#endif
+
+extern int board_au1200fb_panel_init (void);
+extern int board_au1200fb_panel_shutdown (void);
+
+#ifdef CONFIG_PM
+int au1200fb_pm_callback(au1xxx_power_dev_t *dev,
+                au1xxx_request_t request, void *data);
+au1xxx_power_dev_t *LCD_pm_dev;
+#endif
+
+/*
+ * Default window configurations
+ */
+static struct window_settings windows[] = {
+        { /* Index 0 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 100, 100, 100, 100,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN1,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+
+        { /* Index 1 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 320, 240, 5, 5,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_24BPP |
+                                LCD_WINCTRL1_PO_00,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565
+                                | LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 100, 100, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0/*LCD_WINENABLE_WEN2*/,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 200, 25, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+        { /* Index 2 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_32BPP |
+                                LCD_WINCTRL1_PO_00|LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0/*LCD_WINENABLE_WEN2*/,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+        /* Need VGA 640 @ 24bpp, @ 32bpp */
+        /* Need VGA 800 @ 24bpp, @ 32bpp */
+        /* Need VGA 1024 @ 24bpp, @ 32bpp */
+};
+
+/*
+ * Controller configurations for various panels.
+ */
+
+struct panel_settings
+{
+        const char name[25];            /* Full name <vendor>_<model> */
+
+        struct  fb_monspecs monspecs;   /* FB monitor specs */
+
+        /* panel timings */
+        uint32 mode_screen;
+        uint32 mode_horztiming;
+        uint32 mode_verttiming;
+        uint32 mode_clkcontrol;
+        uint32 mode_pwmdiv;
+        uint32 mode_pwmhi;
+        uint32 mode_outmask;
+        uint32 mode_fifoctrl;
+        uint32 mode_toyclksrc;
+        uint32 mode_backlight;
+        uint32 mode_auxpll;
+        int (*device_init)(void);
+        int (*device_shutdown)(void);
+#define Xres min_xres
+#define Yres min_yres
+        u32     min_xres;               /* Minimum horizontal resolution */
+        u32     max_xres;               /* Maximum horizontal resolution */
+        u32     min_yres;               /* Minimum vertical resolution */
+        u32     max_yres;               /* Maximum vertical resolution */
+};
+
+/********************************************************************/
+/* fixme: Maybe a modedb for the CRT ? otherwise panels should be as-is */
+
+/* List of panels known to work with the AU1200 LCD controller.
+ * To add a new panel, enter the same specifications as the
+ * Generic_TFT one, and MAKE SURE that it doesn't conflicts
+ * with the controller restrictions. Restrictions are:
+ *
+ * STN color panels: max_bpp <= 12
+ * STN mono panels: max_bpp <= 4
+ * TFT panels: max_bpp <= 16
+ * max_xres <= 800
+ * max_yres <= 600
+ */
+static struct panel_settings known_lcd_panels[] =
+{
+        [0] = { /* QVGA 320x240 H:33.3kHz V:110Hz */
+                .name = "QVGA_320x240",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(320) |
+                        LCD_SCREEN_SY_N(240),
+                .mode_horztiming        = 0x00c4623b,
+                .mode_verttiming        = 0x00502814,
+                .mode_clkcontrol        = 0x00020002, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                320, 320,
+                240, 240,
+        },
+
+        [1] = { /* VGA 640x480 H:30.3kHz V:58Hz */
+                .name = "VGA_640x480",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x13f9df80,
+                .mode_horztiming        = 0x003c5859,
+                .mode_verttiming        = 0x00741201,
+                .mode_clkcontrol        = 0x00020001, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                640, 480,
+                640, 480,
+        },
+
+        [2] = { /* SVGA 800x600 H:46.1kHz V:69Hz */
+                .name = "SVGA_800x600",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x18fa5780,
+                .mode_horztiming        = 0x00dc7e77,
+                .mode_verttiming        = 0x00584805,
+                .mode_clkcontrol        = 0x00020000, /* /2=48Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                800, 800,
+                600, 600,
+        },
+
+        [3] = { /* XVGA 1024x768 H:56.2kHz V:70Hz */
+                .name = "XVGA_1024x768",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x1ffaff80,
+                .mode_horztiming        = 0x007d0e57,
+                .mode_verttiming        = 0x00740a01,
+                .mode_clkcontrol        = 0x000A0000, /* /1 */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 6, /* 72MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                1024, 1024,
+                768, 768,
+        },
+
+        [4] = { /* XVGA XVGA 1280x1024 H:68.5kHz V:65Hz */
+                .name = "XVGA_1280x1024",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x27fbff80,
+                .mode_horztiming        = 0x00cdb2c7,
+                .mode_verttiming        = 0x00600002,
+                .mode_clkcontrol        = 0x000A0000, /* /1 */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 10, /* 120MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                1280, 1280,
+                1024, 1024,
+        },
+
+        [5] = { /* Samsung 1024x768 TFT */
+                .name = "Samsung_1024x768_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x1ffaff80,
+                .mode_horztiming        = 0x018cc677,
+                .mode_verttiming        = 0x00241217,
+                .mode_clkcontrol        = 0x00000000, /* SCB 0x1 /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f, /* SCB 0x0 */
+                .mode_pwmhi             = 0x03400000, /* SCB 0x0 */
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                1024, 1024,
+                768, 768,
+        },
+
+        [6] = { /* Toshiba 640x480 TFT */
+                .name = "Toshiba_640x480_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(640) |
+                        LCD_SCREEN_SY_N(480),
+                .mode_horztiming        = LCD_HORZTIMING_HPW_N(96) |
+                        LCD_HORZTIMING_HND1_N(13) | LCD_HORZTIMING_HND2_N(51),
+                .mode_verttiming        = LCD_VERTTIMING_VPW_N(2) |
+                        LCD_VERTTIMING_VND1_N(11) | LCD_VERTTIMING_VND2_N(32),
+                .mode_clkcontrol        = 0x00000000, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                640, 480,
+                640, 480,
+        },
+
+        [7] = { /* Sharp 320x240 TFT */
+                .name = "Sharp_320x240_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 12500,
+                        .hfmax = 20000,
+                        .vfmin = 38,
+                        .vfmax = 81,
+                        .dclkmin = 4500000,
+                        .dclkmax = 6800000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(320) |
+                        LCD_SCREEN_SY_N(240),
+                .mode_horztiming        = LCD_HORZTIMING_HPW_N(60) |
+                        LCD_HORZTIMING_HND1_N(13) | LCD_HORZTIMING_HND2_N(2),
+                .mode_verttiming        = LCD_VERTTIMING_VPW_N(2) |
+                        LCD_VERTTIMING_VND1_N(2) | LCD_VERTTIMING_VND2_N(5),
+                .mode_clkcontrol        = LCD_CLKCONTROL_PCD_N(7), /*16=6Mhz*/
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                320, 320,
+                240, 240,
+        },
+
+        [8] = { /* Toppoly TD070WGCB2 7" 856x480 TFT */
+                .name = "Toppoly_TD070WGCB2",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(856) |
+                        LCD_SCREEN_SY_N(480),
+                .mode_horztiming        = LCD_HORZTIMING_HND2_N(43) |
+                        LCD_HORZTIMING_HND1_N(43) | LCD_HORZTIMING_HPW_N(114),
+                .mode_verttiming        = LCD_VERTTIMING_VND2_N(20) |
+                        LCD_VERTTIMING_VND1_N(21) | LCD_VERTTIMING_VPW_N(4),
+                .mode_clkcontrol        = 0x00020001, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                856, 856,
+                480, 480,
+        },
+};
+
+#define NUM_PANELS (ARRAY_SIZE(known_lcd_panels))
+
+/********************************************************************/
+
+#ifdef CONFIG_PM
+static int set_brightness(unsigned int brightness)
+{
+        unsigned int hi1, divider;
+
+        /* limit brightness pwm duty to >= 30/1600 */
+        if (brightness < 30) {
+                brightness = 30;
+        }
+        divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+        hi1 = (lcd->pwmhi >> 16) + 1;
+        hi1 = (((brightness & 0xFF) + 1) * divider >> 8);
+        lcd->pwmhi &= 0xFFFF;
+        lcd->pwmhi |= (hi1 << 16);
+
+        return brightness;
+}
+#endif /* CONFIG_PM */
+
+static int winbpp (unsigned int winctrl1)
+{
+        int bits = 0;
+
+        /* how many bits are needed for each pixel format */
+        switch (winctrl1 & LCD_WINCTRL1_FRM) {
+        case LCD_WINCTRL1_FRM_1BPP:
+                bits = 1;
+                break;
+        case LCD_WINCTRL1_FRM_2BPP:
+                bits = 2;
+                break;
+        case LCD_WINCTRL1_FRM_4BPP:
+                bits = 4;
+                break;
+        case LCD_WINCTRL1_FRM_8BPP:
+                bits = 8;
+                break;
+        case LCD_WINCTRL1_FRM_12BPP:
+        case LCD_WINCTRL1_FRM_16BPP655:
+        case LCD_WINCTRL1_FRM_16BPP565:
+        case LCD_WINCTRL1_FRM_16BPP556:
+        case LCD_WINCTRL1_FRM_16BPPI1555:
+        case LCD_WINCTRL1_FRM_16BPPI5551:
+        case LCD_WINCTRL1_FRM_16BPPA1555:
+        case LCD_WINCTRL1_FRM_16BPPA5551:
+                bits = 16;
+                break;
+        case LCD_WINCTRL1_FRM_24BPP:
+        case LCD_WINCTRL1_FRM_32BPP:
+                bits = 32;
+                break;
+        }
+
+        return bits;
+}
+
+static int fbinfo2index (struct fb_info *fb_info)
+{
+        int i;
+
+        for (i = 0; i < CONFIG_FB_AU1200_DEVS; ++i) {
+                if (fb_info == (struct fb_info *)(&_au1200fb_devices[i].fb_info))
+                        return i;
+        }
+        printk("au1200fb: ERROR: fbinfo2index failed!\n");
+        return -1;
+}
+
+static int au1200_setlocation (struct au1200fb_device *fbdev, int plane,
+        int xpos, int ypos)
+{
+        uint32 winctrl0, winctrl1, winenable, fb_offset = 0;
+        int xsz, ysz;
+
+        /* FIX!!! NOT CHECKING FOR COMPLETE OFFSCREEN YET */
+
+        winctrl0 = lcd->window[plane].winctrl0;
+        winctrl1 = lcd->window[plane].winctrl1;
+        winctrl0 &= (LCD_WINCTRL0_A | LCD_WINCTRL0_AEN);
+        winctrl1 &= ~(LCD_WINCTRL1_SZX | LCD_WINCTRL1_SZY);
+
+        /* Check for off-screen adjustments */
+        xsz = win->w[plane].xres;
+        ysz = win->w[plane].yres;
+        if ((xpos + win->w[plane].xres) > panel->Xres) {
+                /* Off-screen to the right */
+                xsz = panel->Xres - xpos; /* off by 1 ??? */
+                /*printk("off screen right\n");*/
+        }
+
+        if ((ypos + win->w[plane].yres) > panel->Yres) {
+                /* Off-screen to the bottom */
+                ysz = panel->Yres - ypos; /* off by 1 ??? */
+                /*printk("off screen bottom\n");*/
+        }
+
+        if (xpos < 0) {
+                /* Off-screen to the left */
+                xsz = win->w[plane].xres + xpos;
+                fb_offset += (((0 - xpos) * winbpp(lcd->window[plane].winctrl1))/8);
+                xpos = 0;
+                /*printk("off screen left\n");*/
+        }
+
+        if (ypos < 0) {
+                /* Off-screen to the top */
+                ysz = win->w[plane].yres + ypos;
+                /* fixme: fb_offset += ((0-ypos)*fb_pars[plane].line_length); */
+                ypos = 0;
+                /*printk("off screen top\n");*/
+        }
+
+        /* record settings */
+        win->w[plane].xpos = xpos;
+        win->w[plane].ypos = ypos;
+
+        xsz -= 1;
+        ysz -= 1;
+        winctrl0 |= (xpos << 21);
+        winctrl0 |= (ypos << 10);
+        winctrl1 |= (xsz << 11);
+        winctrl1 |= (ysz << 0);
+
+        /* Disable the window while making changes, then restore WINEN */
+        winenable = lcd->winenable & (1 << plane);
+        au_sync();
+        lcd->winenable &= ~(1 << plane);
+        lcd->window[plane].winctrl0 = winctrl0;
+        lcd->window[plane].winctrl1 = winctrl1;
+        lcd->window[plane].winbuf0 =
+        lcd->window[plane].winbuf1 = fbdev->fb_phys;
+        lcd->window[plane].winbufctrl = 0; /* select winbuf0 */
+        lcd->winenable |= winenable;
+        au_sync();
+
+        return 0;
+}
+
+static void au1200_setpanel (struct panel_settings *newpanel)
+{
+        /*
+         * Perform global setup/init of LCD controller
+         */
+        uint32 winenable;
+
+        /* Make sure all windows disabled */
+        winenable = lcd->winenable;
+        lcd->winenable = 0;
+        au_sync();
+        /*
+         * Ensure everything is disabled before reconfiguring
+         */
+        if (lcd->screen & LCD_SCREEN_SEN) {
+                /* Wait for vertical sync period */
+                lcd->intstatus = LCD_INT_SS;
+                while ((lcd->intstatus & LCD_INT_SS) == 0) {
+                        au_sync();
+                }
+
+                lcd->screen &= ~LCD_SCREEN_SEN; /*disable the controller*/
+
+                do {
+                        lcd->intstatus = lcd->intstatus; /*clear interrupts*/
+                        au_sync();
+                /*wait for controller to shut down*/
+                } while ((lcd->intstatus & LCD_INT_SD) == 0);
+
+                /* Call shutdown of current panel (if up) */
+                /* this must occur last, because if an external clock is driving
+                    the controller, the clock cannot be turned off before first
+                        shutting down the controller.
+                 */
+                if (panel->device_shutdown != NULL)
+                        panel->device_shutdown();
+        }
+
+        /* Newpanel == NULL indicates a shutdown operation only */
+        if (newpanel == NULL)
+                return;
+
+        panel = newpanel;
+
+        printk("Panel(%s), %dx%d\n", panel->name, panel->Xres, panel->Yres);
+
+        /*
+         * Setup clocking if internal LCD clock source (assumes sys_auxpll valid)
+         */
+        if (!(panel->mode_clkcontrol & LCD_CLKCONTROL_EXT))
+        {
+                uint32 sys_clksrc;
+                au_writel(panel->mode_auxpll, SYS_AUXPLL);
+                sys_clksrc = au_readl(SYS_CLKSRC) & ~0x0000001f;
+                sys_clksrc |= panel->mode_toyclksrc;
+                au_writel(sys_clksrc, SYS_CLKSRC);
+        }
+
+        /*
+         * Configure panel timings
+         */
+        lcd->screen = panel->mode_screen;
+        lcd->horztiming = panel->mode_horztiming;
+        lcd->verttiming = panel->mode_verttiming;
+        lcd->clkcontrol = panel->mode_clkcontrol;
+        lcd->pwmdiv = panel->mode_pwmdiv;
+        lcd->pwmhi = panel->mode_pwmhi;
+        lcd->outmask = panel->mode_outmask;
+        lcd->fifoctrl = panel->mode_fifoctrl;
+        au_sync();
+
+        /* fixme: Check window settings to make sure still valid
+         * for new geometry */
+#if 0
+        au1200_setlocation(fbdev, 0, win->w[0].xpos, win->w[0].ypos);
+        au1200_setlocation(fbdev, 1, win->w[1].xpos, win->w[1].ypos);
+        au1200_setlocation(fbdev, 2, win->w[2].xpos, win->w[2].ypos);
+        au1200_setlocation(fbdev, 3, win->w[3].xpos, win->w[3].ypos);
+#endif
+        lcd->winenable = winenable;
+
+        /*
+         * Re-enable screen now that it is configured
+         */
+        lcd->screen |= LCD_SCREEN_SEN;
+        au_sync();
+
+        /* Call init of panel */
+        if (panel->device_init != NULL) panel->device_init();
+
+        /* FIX!!!! not appropriate on panel change!!! Global setup/init */
+        lcd->intenable = 0;
+        lcd->intstatus = ~0;
+        lcd->backcolor = win->mode_backcolor;
+
+        /* Setup Color Key - FIX!!! */
+        lcd->colorkey = win->mode_colorkey;
+        lcd->colorkeymsk = win->mode_colorkeymsk;
+
+        /* Setup HWCursor - FIX!!! Need to support this eventually */
+        lcd->hwc.cursorctrl = 0;
+        lcd->hwc.cursorpos = 0;
+        lcd->hwc.cursorcolor0 = 0;
+        lcd->hwc.cursorcolor1 = 0;
+        lcd->hwc.cursorcolor2 = 0;
+        lcd->hwc.cursorcolor3 = 0;
+
+
+#if 0
+#define D(X) printk("%25s: %08X\n", #X, X)
+        D(lcd->screen);
+        D(lcd->horztiming);
+        D(lcd->verttiming);
+        D(lcd->clkcontrol);
+        D(lcd->pwmdiv);
+        D(lcd->pwmhi);
+        D(lcd->outmask);
+        D(lcd->fifoctrl);
+        D(lcd->window[0].winctrl0);
+        D(lcd->window[0].winctrl1);
+        D(lcd->window[0].winctrl2);
+        D(lcd->window[0].winbuf0);
+        D(lcd->window[0].winbuf1);
+        D(lcd->window[0].winbufctrl);
+        D(lcd->window[1].winctrl0);
+        D(lcd->window[1].winctrl1);
+        D(lcd->window[1].winctrl2);
+        D(lcd->window[1].winbuf0);
+        D(lcd->window[1].winbuf1);
+        D(lcd->window[1].winbufctrl);
+        D(lcd->window[2].winctrl0);
+        D(lcd->window[2].winctrl1);
+        D(lcd->window[2].winctrl2);
+        D(lcd->window[2].winbuf0);
+        D(lcd->window[2].winbuf1);
+        D(lcd->window[2].winbufctrl);
+        D(lcd->window[3].winctrl0);
+        D(lcd->window[3].winctrl1);
+        D(lcd->window[3].winctrl2);
+        D(lcd->window[3].winbuf0);
+        D(lcd->window[3].winbuf1);
+        D(lcd->window[3].winbufctrl);
+        D(lcd->winenable);
+        D(lcd->intenable);
+        D(lcd->intstatus);
+        D(lcd->backcolor);
+        D(lcd->winenable);
+        D(lcd->colorkey);
+    D(lcd->colorkeymsk);
+        D(lcd->hwc.cursorctrl);
+        D(lcd->hwc.cursorpos);
+        D(lcd->hwc.cursorcolor0);
+        D(lcd->hwc.cursorcolor1);
+        D(lcd->hwc.cursorcolor2);
+        D(lcd->hwc.cursorcolor3);
+#endif
+}
+
+static void au1200_setmode(struct au1200fb_device *fbdev)
+{
+        int plane = fbdev->plane;
+        /* Window/plane setup */
+        lcd->window[plane].winctrl1 = ( 0
+                | LCD_WINCTRL1_PRI_N(plane)
+                | win->w[plane].mode_winctrl1 /* FRM,CCO,PO,PIPE */
+                ) ;
+
+        au1200_setlocation(fbdev, plane, win->w[plane].xpos, win->w[plane].ypos);
+
+        lcd->window[plane].winctrl2 = ( 0
+                | LCD_WINCTRL2_CKMODE_00
+                | LCD_WINCTRL2_DBM
+                | LCD_WINCTRL2_BX_N( fbdev->fb_info.fix.line_length)
+                | LCD_WINCTRL2_SCX_1
+                | LCD_WINCTRL2_SCY_1
+                ) ;
+        lcd->winenable |= win->w[plane].mode_winenable;
+        au_sync();
+}
+
+
+/* Inline helpers */
+
+/*#define panel_is_dual(panel)  ((panel->mode_screen & LCD_SCREEN_PT) == LCD_SCREEN_PT_010)*/
+/*#define panel_is_active(panel)((panel->mode_screen & LCD_SCREEN_PT) == LCD_SCREEN_PT_010)*/
+
+#define panel_is_color(panel) ((panel->mode_screen & LCD_SCREEN_PT) <= LCD_SCREEN_PT_CDSTN)
+
+/* Bitfields format supported by the controller. */
+static struct fb_bitfield rgb_bitfields[][4] = {
+        /*     Red,        Green,        Blue,       Transp   */
+        [LCD_WINCTRL1_FRM_16BPP655 >> 25] =
+                { { 10, 6, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPP565 >> 25] =
+                { { 11, 5, 0 }, { 5, 6, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPP556 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 0, 6, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPI1555 >> 25] =
+                { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPI5551 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPA1555 >> 25] =
+                { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 15, 1, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPA5551 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 1, 0 } },
+
+        [LCD_WINCTRL1_FRM_24BPP >> 25] =
+                { { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_32BPP >> 25] =
+                { { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 24, 0, 0 } },
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Helpers */
+
+static void au1200fb_update_fbinfo(struct fb_info *fbi)
+{
+        /* FIX!!!! This also needs to take the window pixel format into account!!! */
+
+        /* Update var-dependent FB info */
+        if (panel_is_color(panel)) {
+                if (fbi->var.bits_per_pixel <= 8) {
+                        /* palettized */
+                        fbi->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+                        fbi->fix.line_length = fbi->var.xres_virtual /
+                                (8/fbi->var.bits_per_pixel);
+                } else {
+                        /* non-palettized */
+                        fbi->fix.visual = FB_VISUAL_TRUECOLOR;
+                        fbi->fix.line_length = fbi->var.xres_virtual * (fbi->var.bits_per_pixel / 8);
+                }
+        } else {
+                /* mono FIX!!! mono 8 and 4 bits */
+                fbi->fix.visual = FB_VISUAL_MONO10;
+                fbi->fix.line_length = fbi->var.xres_virtual / 8;
+        }
+
+        fbi->screen_size = fbi->fix.line_length * fbi->var.yres_virtual;
+        print_dbg("line length: %d\n", fbi->fix.line_length);
+        print_dbg("bits_per_pixel: %d\n", fbi->var.bits_per_pixel);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 framebuffer driver */
+
+/* fb_check_var
+ * Validate var settings with hardware restrictions and modify it if necessary
+ */
+static int au1200fb_fb_check_var(struct fb_var_screeninfo *var,
+        struct fb_info *fbi)
+{
+        struct au1200fb_device *fbdev = (struct au1200fb_device *)fbi;
+        u32 pixclock;
+        int screen_size, plane;
+
+        plane = fbdev->plane;
+
+        /* Make sure that the mode respect all LCD controller and
+         * panel restrictions. */
+        var->xres = win->w[plane].xres;
+        var->yres = win->w[plane].yres;
+
+        /* No need for virtual resolution support */
+        var->xres_virtual = var->xres;
+        var->yres_virtual = var->yres;
+
+        var->bits_per_pixel = winbpp(win->w[plane].mode_winctrl1);
+
+        screen_size = var->xres_virtual * var->yres_virtual;
+        if (var->bits_per_pixel > 8) screen_size *= (var->bits_per_pixel / 8);
+        else screen_size /= (8/var->bits_per_pixel);
+
+        if (fbdev->fb_len < screen_size)
+                return -EINVAL; /* Virtual screen is to big, abort */
+
+        /* FIX!!!! what are the implicaitons of ignoring this for windows ??? */
+        /* The max LCD clock is fixed to 48MHz (value of AUX_CLK). The pixel
+         * clock can only be obtain by dividing this value by an even integer.
+         * Fallback to a slower pixel clock if necessary. */
+        pixclock = max((u32)(PICOS2KHZ(var->pixclock) * 1000), fbi->monspecs.dclkmin);
+        pixclock = min(pixclock, min(fbi->monspecs.dclkmax, (u32)AU1200_LCD_MAX_CLK/2));
+
+        if (AU1200_LCD_MAX_CLK % pixclock) {
+                int diff = AU1200_LCD_MAX_CLK % pixclock;
+                pixclock -= diff;
+        }
+
+        var->pixclock = KHZ2PICOS(pixclock/1000);
+#if 0
+        if (!panel_is_active(panel)) {
+                int pcd = AU1200_LCD_MAX_CLK / (pixclock * 2) - 1;
+
+                if (!panel_is_color(panel)
+                        && (panel->control_base & LCD_CONTROL_MPI) && (pcd < 3)) {
+                        /* STN 8bit mono panel support is up to 6MHz pixclock */
+                        var->pixclock = KHZ2PICOS(6000);
+                } else if (!pcd) {
+                        /* Other STN panel support is up to 12MHz  */
+                        var->pixclock = KHZ2PICOS(12000);
+                }
+        }
+#endif
+        /* Set bitfield accordingly */
+        switch (var->bits_per_pixel) {
+                case 16:
+                {
+                        /* 16bpp True color.
+                         * These must be set to MATCH WINCTRL[FORM] */
+                        int idx;
+                        idx = (win->w[0].mode_winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+                        var->red    = rgb_bitfields[idx][0];
+                        var->green  = rgb_bitfields[idx][1];
+                        var->blue   = rgb_bitfields[idx][2];
+                        var->transp = rgb_bitfields[idx][3];
+                        break;
+                }
+
+                case 32:
+                {
+                        /* 32bpp True color.
+                         * These must be set to MATCH WINCTRL[FORM] */
+                        int idx;
+                        idx = (win->w[0].mode_winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+                        var->red    = rgb_bitfields[idx][0];
+                        var->green  = rgb_bitfields[idx][1];
+                        var->blue   = rgb_bitfields[idx][2];
+                        var->transp = rgb_bitfields[idx][3];
+                        break;
+                }
+                default:
+                        print_dbg("Unsupported depth %dbpp", var->bits_per_pixel);
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* fb_set_par
+ * Set hardware with var settings. This will enable the controller with a
+ * specific mode, normally validated with the fb_check_var method
+ */
+static int au1200fb_fb_set_par(struct fb_info *fbi)
+{
+        struct au1200fb_device *fbdev = (struct au1200fb_device *)fbi;
+
+        au1200fb_update_fbinfo(fbi);
+        au1200_setmode(fbdev);
+
+        return 0;
+}
+
+/* fb_setcolreg
+ * Set color in LCD palette.
+ */
+static int au1200fb_fb_setcolreg(unsigned regno, unsigned red, unsigned green,
+        unsigned blue, unsigned transp, struct fb_info *fbi)
+{
+        volatile u32 *palette = lcd->palette;
+        u32 value;
+
+        if (regno > (AU1200_LCD_NBR_PALETTE_ENTRIES - 1))
+                return -EINVAL;
+
+        if (fbi->var.grayscale) {
+                /* Convert color to grayscale */
+                red = green = blue =
+                        (19595 * red + 38470 * green + 7471 * blue) >> 16;
+        }
+
+        if (fbi->fix.visual == FB_VISUAL_TRUECOLOR) {
+                /* Place color in the pseudopalette */
+                if (regno > 16)
+                        return -EINVAL;
+
+                palette = (u32*) fbi->pseudo_palette;
+
+                red   >>= (16 - fbi->var.red.length);
+                green >>= (16 - fbi->var.green.length);
+                blue  >>= (16 - fbi->var.blue.length);
+
+                value = (red   << fbi->var.red.offset)  |
+                        (green << fbi->var.green.offset)|
+                        (blue  << fbi->var.blue.offset);
+                value &= 0xFFFF;
+
+        } else if (1 /*FIX!!! panel_is_active(fbdev->panel)*/) {
+                /* COLOR TFT PALLETTIZED (use RGB 565) */
+                value = (red & 0xF800)|((green >> 5) &
+                                0x07E0)|((blue >> 11) & 0x001F);
+                value &= 0xFFFF;
+
+        } else if (0 /*panel_is_color(fbdev->panel)*/) {
+                /* COLOR STN MODE */
+                value = 0x1234;
+                value &= 0xFFF;
+        } else {
+                /* MONOCHROME MODE */
+                value = (green >> 12) & 0x000F;
+                value &= 0xF;
+        }
+
+        palette[regno] = value;
+
+        return 0;
+}
+
+/* fb_blank
+ * Blank the screen. Depending on the mode, the screen will be
+ * activated with the backlight color, or desactivated
+ */
+static int au1200fb_fb_blank(int blank_mode, struct fb_info *fbi)
+{
+        /* Short-circuit screen blanking */
+        if (noblanking)
+                return 0;
+
+        switch (blank_mode) {
+
+        case FB_BLANK_UNBLANK:
+        case FB_BLANK_NORMAL:
+                /* printk("turn on panel\n"); */
+                au1200_setpanel(panel);
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+        case FB_BLANK_HSYNC_SUSPEND:
+        case FB_BLANK_POWERDOWN:
+                /* printk("turn off panel\n"); */
+                au1200_setpanel(NULL);
+                break;
+        default:
+                break;
+
+        }
+
+        /* FB_BLANK_NORMAL is a soft blank */
+        return (blank_mode == FB_BLANK_NORMAL) ? -EINVAL : 0;
+}
+
+/* fb_mmap
+ * Map video memory in user space. We don't use the generic fb_mmap
+ * method mainly to allow the use of the TLB streaming flag (CCA=6)
+ */
+static int au1200fb_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
+
+{
+        unsigned int len;
+        unsigned long start=0, off;
+        struct au1200fb_device *fbdev = (struct au1200fb_device *) info;
+
+#ifdef CONFIG_PM
+        au1xxx_pm_access(LCD_pm_dev);
+#endif
+
+        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) {
+                return -EINVAL;
+        }
+
+        start = fbdev->fb_phys & PAGE_MASK;
+        len = PAGE_ALIGN((start & ~PAGE_MASK) + fbdev->fb_len);
+
+        off = vma->vm_pgoff << PAGE_SHIFT;
+
+        if ((vma->vm_end - vma->vm_start + off) > len) {
+                return -EINVAL;
+        }
+
+        off += start;
+        vma->vm_pgoff = off >> PAGE_SHIFT;
+
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        pgprot_val(vma->vm_page_prot) |= _CACHE_MASK; /* CCA=7 */
+
+        vma->vm_flags |= VM_IO;
+
+        return io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
+                                  vma->vm_end - vma->vm_start,
+                                  vma->vm_page_prot);
+
+        return 0;
+}
+
+static void set_global(u_int cmd, struct au1200_lcd_global_regs_t *pdata)
+{
+
+        unsigned int hi1, divider;
+
+        /* SCREEN_SIZE: user cannot reset size, must switch panel choice */
+
+        if (pdata->flags & SCREEN_BACKCOLOR)
+                lcd->backcolor = pdata->backcolor;
+
+        if (pdata->flags & SCREEN_BRIGHTNESS) {
+
+                // limit brightness pwm duty to >= 30/1600
+                if (pdata->brightness < 30) {
+                        pdata->brightness = 30;
+                }
+                divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+                hi1 = (lcd->pwmhi >> 16) + 1;
+                hi1 = (((pdata->brightness & 0xFF)+1) * divider >> 8);
+                lcd->pwmhi &= 0xFFFF;
+                lcd->pwmhi |= (hi1 << 16);
+        }
+
+        if (pdata->flags & SCREEN_COLORKEY)
+                lcd->colorkey = pdata->colorkey;
+
+        if (pdata->flags & SCREEN_MASK)
+                lcd->colorkeymsk = pdata->mask;
+        au_sync();
+}
+
+static void get_global(u_int cmd, struct au1200_lcd_global_regs_t *pdata)
+{
+        unsigned int hi1, divider;
+
+        pdata->xsize = ((lcd->screen & LCD_SCREEN_SX) >> 19) + 1;
+        pdata->ysize = ((lcd->screen & LCD_SCREEN_SY) >> 8) + 1;
+
+        pdata->backcolor = lcd->backcolor;
+        pdata->colorkey = lcd->colorkey;
+        pdata->mask = lcd->colorkeymsk;
+
+        // brightness
+        hi1 = (lcd->pwmhi >> 16) + 1;
+        divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+        pdata->brightness = ((hi1 << 8) / divider) - 1;
+        au_sync();
+}
+
+static void set_window(unsigned int plane,
+        struct au1200_lcd_window_regs_t *pdata)
+{
+        unsigned int val, bpp;
+
+        /* Window control register 0 */
+        if (pdata->flags & WIN_POSITION) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_OX |
+                                LCD_WINCTRL0_OY);
+                val |= ((pdata->xpos << 21) & LCD_WINCTRL0_OX);
+                val |= ((pdata->ypos << 10) & LCD_WINCTRL0_OY);
+                lcd->window[plane].winctrl0 = val;
+        }
+        if (pdata->flags & WIN_ALPHA_COLOR) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_A);
+                val |= ((pdata->alpha_color << 2) & LCD_WINCTRL0_A);
+                lcd->window[plane].winctrl0 = val;
+        }
+        if (pdata->flags & WIN_ALPHA_MODE) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_AEN);
+                val |= ((pdata->alpha_mode << 1) & LCD_WINCTRL0_AEN);
+                lcd->window[plane].winctrl0 = val;
+        }
+
+        /* Window control register 1 */
+        if (pdata->flags & WIN_PRIORITY) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PRI);
+                val |= ((pdata->priority << 30) & LCD_WINCTRL1_PRI);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_CHANNEL) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PIPE);
+                val |= ((pdata->channel << 29) & LCD_WINCTRL1_PIPE);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_BUFFER_FORMAT) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_FRM);
+                val |= ((pdata->buffer_format << 25) & LCD_WINCTRL1_FRM);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_COLOR_ORDER) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_CCO);
+                val |= ((pdata->color_order << 24) & LCD_WINCTRL1_CCO);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_PIXEL_ORDER) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PO);
+                val |= ((pdata->pixel_order << 22) & LCD_WINCTRL1_PO);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_SIZE) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_SZX |
+                                LCD_WINCTRL1_SZY);
+                val |= (((pdata->xsize << 11) - 1) & LCD_WINCTRL1_SZX);
+                val |= (((pdata->ysize) - 1) & LCD_WINCTRL1_SZY);
+                lcd->window[plane].winctrl1 = val;
+                /* program buffer line width */
+                bpp = winbpp(val) / 8;
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_BX);
+                val |= (((pdata->xsize * bpp) << 8) & LCD_WINCTRL2_BX);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        /* Window control register 2 */
+        if (pdata->flags & WIN_COLORKEY_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_CKMODE);
+                val |= ((pdata->colorkey_mode << 24) & LCD_WINCTRL2_CKMODE);
+                lcd->window[plane].winctrl2 = val;
+        }
+        if (pdata->flags & WIN_DOUBLE_BUFFER_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_DBM);
+                val |= ((pdata->double_buffer_mode << 23) & LCD_WINCTRL2_DBM);
+                lcd->window[plane].winctrl2 = val;
+        }
+        if (pdata->flags & WIN_RAM_ARRAY_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_RAM);
+                val |= ((pdata->ram_array_mode << 21) & LCD_WINCTRL2_RAM);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        /* Buffer line width programmed with WIN_SIZE */
+
+        if (pdata->flags & WIN_BUFFER_SCALE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_SCX |
+                                LCD_WINCTRL2_SCY);
+                val |= ((pdata->xsize << 11) & LCD_WINCTRL2_SCX);
+                val |= ((pdata->ysize) & LCD_WINCTRL2_SCY);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        if (pdata->flags & WIN_ENABLE) {
+                val = lcd->winenable;
+                val &= ~(1<<plane);
+                val |= (pdata->enable & 1) << plane;
+                lcd->winenable = val;
+        }
+        au_sync();
+}
+
+static void get_window(unsigned int plane,
+        struct au1200_lcd_window_regs_t *pdata)
+{
+        /* Window control register 0 */
+        pdata->xpos = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_OX) >> 21;
+        pdata->ypos = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_OY) >> 10;
+        pdata->alpha_color = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_A) >> 2;
+        pdata->alpha_mode = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_AEN) >> 1;
+
+        /* Window control register 1 */
+        pdata->priority = (lcd->window[plane].winctrl1& LCD_WINCTRL1_PRI) >> 30;
+        pdata->channel = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_PIPE) >> 29;
+        pdata->buffer_format = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+        pdata->color_order = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_CCO) >> 24;
+        pdata->pixel_order = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_PO) >> 22;
+        pdata->xsize = ((lcd->window[plane].winctrl1 & LCD_WINCTRL1_SZX) >> 11) + 1;
+        pdata->ysize = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_SZY) + 1;
+
+        /* Window control register 2 */
+        pdata->colorkey_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_CKMODE) >> 24;
+        pdata->double_buffer_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_DBM) >> 23;
+        pdata->ram_array_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_RAM) >> 21;
+
+        pdata->enable = (lcd->winenable >> plane) & 1;
+        au_sync();
+}
+
+static int au1200fb_ioctl(struct fb_info *info, unsigned int cmd,
+                          unsigned long arg)
+{
+        int plane;
+        int val;
+
+#ifdef CONFIG_PM
+        au1xxx_pm_access(LCD_pm_dev);
+#endif
+
+        plane = fbinfo2index(info);
+        print_dbg("au1200fb: ioctl %d on plane %d\n", cmd, plane);
+
+        if (cmd == AU1200_LCD_FB_IOCTL) {
+                struct au1200_lcd_iodata_t iodata;
+
+                if (copy_from_user(&iodata, (void __user *) arg, sizeof(iodata)))
+                        return -EFAULT;
+
+                print_dbg("FB IOCTL called\n");
+
+                switch (iodata.subcmd) {
+                case AU1200_LCD_SET_SCREEN:
+                        print_dbg("AU1200_LCD_SET_SCREEN\n");
+                        set_global(cmd, &iodata.global);
+                        break;
+
+                case AU1200_LCD_GET_SCREEN:
+                        print_dbg("AU1200_LCD_GET_SCREEN\n");
+                        get_global(cmd, &iodata.global);
+                        break;
+
+                case AU1200_LCD_SET_WINDOW:
+                        print_dbg("AU1200_LCD_SET_WINDOW\n");
+                        set_window(plane, &iodata.window);
+                        break;
+
+                case AU1200_LCD_GET_WINDOW:
+                        print_dbg("AU1200_LCD_GET_WINDOW\n");
+                        get_window(plane, &iodata.window);
+                        break;
+
+                case AU1200_LCD_SET_PANEL:
+                        print_dbg("AU1200_LCD_SET_PANEL\n");
+                        if ((iodata.global.panel_choice >= 0) &&
+                                        (iodata.global.panel_choice <
+                                         NUM_PANELS))
+                        {
+                                struct panel_settings *newpanel;
+                                panel_index = iodata.global.panel_choice;
+                                newpanel = &known_lcd_panels[panel_index];
+                                au1200_setpanel(newpanel);
+                        }
+                        break;
+
+                case AU1200_LCD_GET_PANEL:
+                        print_dbg("AU1200_LCD_GET_PANEL\n");
+                        iodata.global.panel_choice = panel_index;
+                        break;
+
+                default:
+                        return -EINVAL;
+                }
+
+                val = copy_to_user((void __user *) arg, &iodata, sizeof(iodata));
+                if (val) {
+                        print_dbg("error: could not copy %d bytes\n", val);
+                        return -EFAULT;
+                }
+        }
+
+        return 0;
+}
+
+
+static struct fb_ops au1200fb_fb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_check_var   = au1200fb_fb_check_var,
+        .fb_set_par     = au1200fb_fb_set_par,
+        .fb_setcolreg   = au1200fb_fb_setcolreg,
+        .fb_blank       = au1200fb_fb_blank,
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+        .fb_sync        = NULL,
+        .fb_ioctl       = au1200fb_ioctl,
+        .fb_mmap        = au1200fb_fb_mmap,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static irqreturn_t au1200fb_handle_irq(int irq, void* dev_id, struct pt_regs *regs)
+{
+        /* Nothing to do for now, just clear any pending interrupt */
+        lcd->intstatus = lcd->intstatus;
+        au_sync();
+
+        return IRQ_HANDLED;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 LCD device probe helpers */
+
+static int au1200fb_init_fbinfo(struct au1200fb_device *fbdev)
+{
+        struct fb_info *fbi = &fbdev->fb_info;
+        int bpp;
+
+        memset(fbi, 0, sizeof(struct fb_info));
+        fbi->fbops = &au1200fb_fb_ops;
+
+        bpp = winbpp(win->w[fbdev->plane].mode_winctrl1);
+
+        /* Copy monitor specs from panel data */
+        /* fixme: we're setting up LCD controller windows, so these dont give a
+        damn as to what the monitor specs are (the panel itself does, but that
+        isnt done here...so maybe need a generic catchall monitor setting??? */
+        memcpy(&fbi->monspecs, &panel->monspecs, sizeof(struct fb_monspecs));
+
+        /* We first try the user mode passed in argument. If that failed,
+         * or if no one has been specified, we default to the first mode of the
+         * panel list. Note that after this call, var data will be set */
+        if (!fb_find_mode(&fbi->var,
+                          fbi,
+                          NULL, /* drv_info.opt_mode, */
+                          fbi->monspecs.modedb,
+                          fbi->monspecs.modedb_len,
+                          fbi->monspecs.modedb,
+                          bpp)) {
+
+                print_err("Cannot find valid mode for panel %s", panel->name);
+                return -EFAULT;
+        }
+
+        fbi->pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL);
+        if (!fbi->pseudo_palette) {
+                return -ENOMEM;
+        }
+        memset(fbi->pseudo_palette, 0, sizeof(u32) * 16);
+
+        if (fb_alloc_cmap(&fbi->cmap, AU1200_LCD_NBR_PALETTE_ENTRIES, 0) < 0) {
+                print_err("Fail to allocate colormap (%d entries)",
+                           AU1200_LCD_NBR_PALETTE_ENTRIES);
+                kfree(fbi->pseudo_palette);
+                return -EFAULT;
+        }
+
+        strncpy(fbi->fix.id, "AU1200", sizeof(fbi->fix.id));
+        fbi->fix.smem_start = fbdev->fb_phys;
+        fbi->fix.smem_len = fbdev->fb_len;
+        fbi->fix.type = FB_TYPE_PACKED_PIXELS;
+        fbi->fix.xpanstep = 0;
+        fbi->fix.ypanstep = 0;
+        fbi->fix.mmio_start = 0;
+        fbi->fix.mmio_len = 0;
+        fbi->fix.accel = FB_ACCEL_NONE;
+
+        fbi->screen_base = (char __iomem *) fbdev->fb_mem;
+
+        au1200fb_update_fbinfo(fbi);
+
+        return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 LCD controller device driver */
+
+static int au1200fb_drv_probe(struct device *dev)
+{
+        struct au1200fb_device *fbdev;
+        unsigned long page;
+        int bpp, plane, ret;
+
+        if (!dev)
+                return -EINVAL;
+
+        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane) {
+                bpp = winbpp(win->w[plane].mode_winctrl1);
+                if (win->w[plane].xres == 0)
+                        win->w[plane].xres = panel->Xres;
+                if (win->w[plane].yres == 0)
+                        win->w[plane].yres = panel->Yres;
+
+                fbdev = &_au1200fb_devices[plane];
+                memset(fbdev, 0, sizeof(struct au1200fb_device));
+                fbdev->plane = plane;
+
+                /* Allocate the framebuffer to the maximum screen size */
+                fbdev->fb_len = (win->w[plane].xres * win->w[plane].yres * bpp) / 8;
+
+                fbdev->fb_mem = dma_alloc_noncoherent(dev,
+                                PAGE_ALIGN(fbdev->fb_len),
+                                &fbdev->fb_phys, GFP_KERNEL);
+                if (!fbdev->fb_mem) {
+                        print_err("fail to allocate frambuffer (size: %dK))",
+                                  fbdev->fb_len / 1024);
+                        return -ENOMEM;
+                }
+
+                /*
+                 * Set page reserved so that mmap will work. This is necessary
+                 * since we'll be remapping normal memory.
+                 */
+                for (page = (unsigned long)fbdev->fb_phys;
+                     page < PAGE_ALIGN((unsigned long)fbdev->fb_phys +
+                             fbdev->fb_len);
+                     page += PAGE_SIZE) {
+                        SetPageReserved(pfn_to_page(page >> PAGE_SHIFT)); /* LCD DMA is NOT coherent on Au1200 */
+                }
+                print_dbg("Framebuffer memory map at %p", fbdev->fb_mem);
+                print_dbg("phys=0x%08x, size=%dK", fbdev->fb_phys, fbdev->fb_len / 1024);
+
+                /* Init FB data */
+                if ((ret = au1200fb_init_fbinfo(fbdev)) < 0)
+                        goto failed;
+
+                /* Register new framebuffer */
+                if ((ret = register_framebuffer(&fbdev->fb_info)) < 0) {
+                        print_err("cannot register new framebuffer");
+                        goto failed;
+                }
+
+                au1200fb_fb_set_par(&fbdev->fb_info);
+
+#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
+                if (plane == 0)
+                        if (fb_prepare_logo(&fbdev->fb_info, FB_ROTATE_UR)) {
+                                /* Start display and show logo on boot */
+                                fb_set_cmap(&fbdev->fb_info.cmap,
+                                                &fbdev->fb_info);
+
+                                fb_show_logo(&fbdev->fb_info, FB_ROTATE_UR);
+                        }
+#endif
+        }
+
+        /* Now hook interrupt too */
+        if ((ret = request_irq(AU1200_LCD_INT, au1200fb_handle_irq,
+                          SA_INTERRUPT | SA_SHIRQ, "lcd", (void *)dev)) < 0) {
+                print_err("fail to request interrupt line %d (err: %d)",
+                          AU1200_LCD_INT, ret);
+                goto failed;
+        }
+
+        return 0;
+
+failed:
+        /* NOTE: This only does the current plane/window that failed; others are still active */
+        if (fbdev->fb_mem)
+                dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                                fbdev->fb_mem, fbdev->fb_phys);
+        if (fbdev->fb_info.cmap.len != 0)
+                fb_dealloc_cmap(&fbdev->fb_info.cmap);
+        if (fbdev->fb_info.pseudo_palette)
+                kfree(fbdev->fb_info.pseudo_palette);
+        if (plane == 0)
+                free_irq(AU1200_LCD_INT, (void*)dev);
+        return ret;
+}
+
+static int au1200fb_drv_remove(struct device *dev)
+{
+        struct au1200fb_device *fbdev;
+        int plane;
+
+        if (!dev)
+                return -ENODEV;
+
+        /* Turn off the panel */
+        au1200_setpanel(NULL);
+
+        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane)
+        {
+                fbdev = &_au1200fb_devices[plane];
+
+                /* Clean up all probe data */
+                unregister_framebuffer(&fbdev->fb_info);
+                if (fbdev->fb_mem)
+                        dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                                        fbdev->fb_mem, fbdev->fb_phys);
+                if (fbdev->fb_info.cmap.len != 0)
+                        fb_dealloc_cmap(&fbdev->fb_info.cmap);
+                if (fbdev->fb_info.pseudo_palette)
+                        kfree(fbdev->fb_info.pseudo_palette);
+        }
+
+        free_irq(AU1200_LCD_INT, (void *)dev);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int au1200fb_drv_suspend(struct device *dev, u32 state, u32 level)
+{
+        /* TODO */
+        return 0;
+}
+
+static int au1200fb_drv_resume(struct device *dev, u32 level)
+{
+        /* TODO */
+        return 0;
+}
+#endif /* CONFIG_PM */
+
+static struct device_driver au1200fb_driver = {
+        .name           = "au1200-lcd",
+        .bus            = &platform_bus_type,
+        .probe          = au1200fb_drv_probe,
+        .remove         = au1200fb_drv_remove,
+#ifdef CONFIG_PM
+        .suspend        = au1200fb_drv_suspend,
+        .resume         = au1200fb_drv_resume,
+#endif
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Kernel driver */
+
+static void au1200fb_setup(void)
+{
+        char* options = NULL;
+        char* this_opt;
+        int num_panels = ARRAY_SIZE(known_lcd_panels);
+        int panel_idx = -1;
+
+        fb_get_options(DRIVER_NAME, &options);
+
+        if (options) {
+                while ((this_opt = strsep(&options,",")) != NULL) {
+                        /* Panel option - can be panel name,
+                         * "bs" for board-switch, or number/index */
+                        if (!strncmp(this_opt, "panel:", 6)) {
+                                int i;
+                                long int li;
+                                char *endptr;
+                                this_opt += 6;
+                                /* First check for index, which allows
+                                 * to short circuit this mess */
+                                li = simple_strtol(this_opt, &endptr, 0);
+                                if (*endptr == '\0') {
+                                        panel_idx = (int)li;
+                                }
+                                else if (strcmp(this_opt, "bs") == 0) {
+                                        extern int board_au1200fb_panel(void);
+                                        panel_idx = board_au1200fb_panel();
+                                }
+
+                                else
+                                for (i = 0; i < num_panels; i++) {
+                                        if (!strcmp(this_opt, known_lcd_panels[i].name)) {
+                                                panel_idx = i;
+                                                break;
+                                        }
+                                }
+
+                                if ((panel_idx < 0) || (panel_idx >= num_panels)) {
+                                                print_warn("Panel %s not supported!", this_opt);
+                                }
+                                else
+                                        panel_index = panel_idx;
+                        }
+
+                        else if (strncmp(this_opt, "nohwcursor", 10) == 0) {
+                                nohwcursor = 1;
+                        }
+
+                        /* Unsupported option */
+                        else {
+                                print_warn("Unsupported option \"%s\"", this_opt);
+                        }
+                }
+        }
+}
+
+#ifdef CONFIG_PM
+static int au1200fb_pm_callback(au1xxx_power_dev_t *dev,
+                au1xxx_request_t request, void *data) {
+        int retval = -1;
+        unsigned int d = 0;
+        unsigned int brightness = 0;
+
+        if (request == AU1XXX_PM_SLEEP) {
+                board_au1200fb_panel_shutdown();
+        }
+        else if (request == AU1XXX_PM_WAKEUP) {
+                if(dev->prev_state == SLEEP_STATE)
+                {
+                        int plane;
+                        au1200_setpanel(panel);
+                        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane)         {
+                                struct au1200fb_device *fbdev;
+                                fbdev = &_au1200fb_devices[plane];
+                                au1200fb_fb_set_par(&fbdev->fb_info);
+                        }
+                }
+
+                d = *((unsigned int*)data);
+                if(d <=10) brightness = 26;
+                else if(d<=20) brightness = 51;
+                else if(d<=30) brightness = 77;
+                else if(d<=40) brightness = 102;
+                else if(d<=50) brightness = 128;
+                else if(d<=60) brightness = 153;
+                else if(d<=70) brightness = 179;
+                else if(d<=80) brightness = 204;
+                else if(d<=90) brightness = 230;
+                else brightness = 255;
+                set_brightness(brightness);
+        } else if (request == AU1XXX_PM_GETSTATUS) {
+                return dev->cur_state;
+        } else if (request == AU1XXX_PM_ACCESS) {
+                if (dev->cur_state != SLEEP_STATE)
+                        return retval;
+                else {
+                        au1200_setpanel(panel);
+                }
+        } else if (request == AU1XXX_PM_IDLE) {
+        } else if (request == AU1XXX_PM_CLEANUP) {
+        }
+
+        return retval;
+}
+#endif
+
+static int __init au1200fb_init(void)
+{
+        print_info("" DRIVER_DESC "");
+
+        /* Setup driver with options */
+        au1200fb_setup();
+
+        /* Point to the panel selected */
+        panel = &known_lcd_panels[panel_index];
+        win = &windows[window_index];
+
+        printk(DRIVER_NAME ": Panel %d %s\n", panel_index, panel->name);
+        printk(DRIVER_NAME ": Win %d %s\n", window_index, win->name);
+
+        /* Kickstart the panel, the framebuffers/windows come soon enough */
+        au1200_setpanel(panel);
+
+        #ifdef CONFIG_PM
+        LCD_pm_dev = new_au1xxx_power_device("LCD", &au1200fb_pm_callback, NULL);
+        if ( LCD_pm_dev == NULL)
+                printk(KERN_INFO "Unable to create a power management device entry for the au1200fb.\n");
+        else
+                printk(KERN_INFO "Power management device entry for the au1200fb loaded.\n");
+        #endif
+
+        return driver_register(&au1200fb_driver);
+}
+
+static void __exit au1200fb_cleanup(void)
+{
+        driver_unregister(&au1200fb_driver);
+}
+
+module_init(au1200fb_init);
+module_exit(au1200fb_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+/*
+ * BRIEF MODULE DESCRIPTION
+ *      Au1200 LCD Driver.
+ *
+ * Copyright 2004-2005 AMD
+ * Author: AMD
+ *
+ * Based on:
+ * linux/drivers/video/skeletonfb.c -- Skeleton for a frame buffer device
+ *  Created 28 Dec 1997 by Geert Uytterhoeven
+ *
+ *  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  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  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.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/ctype.h>
+#include <linux/dma-mapping.h>
+
+#include <asm/mach-au1x00/au1000.h>
+#include "au1200fb.h"
+
+#ifdef CONFIG_PM
+#include <asm/mach-au1x00/au1xxx_pm.h>
+#endif
+
+#ifndef CONFIG_FB_AU1200_DEVS
+#define CONFIG_FB_AU1200_DEVS 4
+#endif
+
+#define DRIVER_NAME "au1200fb"
+#define DRIVER_DESC "LCD controller driver for AU1200 processors"
+
+#define DEBUG 1
+
+#define print_err(f, arg...) printk(KERN_ERR DRIVER_NAME ": " f "\n", ## arg)
+#define print_warn(f, arg...) printk(KERN_WARNING DRIVER_NAME ": " f "\n", ## arg)
+#define print_info(f, arg...) printk(KERN_INFO DRIVER_NAME ": " f "\n", ## arg)
+
+#if DEBUG
+#define print_dbg(f, arg...) printk(KERN_DEBUG __FILE__ ": " f "\n", ## arg)
+#else
+#define print_dbg(f, arg...) do {} while (0)
+#endif
+
+
+#define AU1200_LCD_FB_IOCTL 0x46FF
+
+#define AU1200_LCD_SET_SCREEN 1
+#define AU1200_LCD_GET_SCREEN 2
+#define AU1200_LCD_SET_WINDOW 3
+#define AU1200_LCD_GET_WINDOW 4
+#define AU1200_LCD_SET_PANEL  5
+#define AU1200_LCD_GET_PANEL  6
+
+#define SCREEN_SIZE                 (1<< 1)
+#define SCREEN_BACKCOLOR    (1<< 2)
+#define SCREEN_BRIGHTNESS   (1<< 3)
+#define SCREEN_COLORKEY     (1<< 4)
+#define SCREEN_MASK         (1<< 5)
+
+struct au1200_lcd_global_regs_t {
+        unsigned int flags;
+        unsigned int xsize;
+        unsigned int ysize;
+        unsigned int backcolor;
+        unsigned int brightness;
+        unsigned int colorkey;
+        unsigned int mask;
+        unsigned int panel_choice;
+        char panel_desc[80];
+
+};
+
+#define WIN_POSITION            (1<< 0)
+#define WIN_ALPHA_COLOR         (1<< 1)
+#define WIN_ALPHA_MODE          (1<< 2)
+#define WIN_PRIORITY            (1<< 3)
+#define WIN_CHANNEL             (1<< 4)
+#define WIN_BUFFER_FORMAT       (1<< 5)
+#define WIN_COLOR_ORDER         (1<< 6)
+#define WIN_PIXEL_ORDER         (1<< 7)
+#define WIN_SIZE                (1<< 8)
+#define WIN_COLORKEY_MODE       (1<< 9)
+#define WIN_DOUBLE_BUFFER_MODE  (1<< 10)
+#define WIN_RAM_ARRAY_MODE      (1<< 11)
+#define WIN_BUFFER_SCALE        (1<< 12)
+#define WIN_ENABLE                  (1<< 13)
+
+struct au1200_lcd_window_regs_t {
+        unsigned int flags;
+        unsigned int xpos;
+        unsigned int ypos;
+        unsigned int alpha_color;
+        unsigned int alpha_mode;
+        unsigned int priority;
+        unsigned int channel;
+        unsigned int buffer_format;
+        unsigned int color_order;
+        unsigned int pixel_order;
+        unsigned int xsize;
+        unsigned int ysize;
+        unsigned int colorkey_mode;
+        unsigned int double_buffer_mode;
+        unsigned int ram_array_mode;
+        unsigned int xscale;
+        unsigned int yscale;
+        unsigned int enable;
+};
+
+
+struct au1200_lcd_iodata_t {
+        unsigned int subcmd;
+        struct au1200_lcd_global_regs_t global;
+        struct au1200_lcd_window_regs_t window;
+};
+
+#if defined(__BIG_ENDIAN)
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_11
+#else
+#define LCD_CONTROL_DEFAULT_PO LCD_CONTROL_PO_00
+#endif
+#define LCD_CONTROL_DEFAULT_SBPPF LCD_CONTROL_SBPPF_565
+
+/* Private, per-framebuffer management information (independent of the panel itself) */
+struct au1200fb_device {
+        struct fb_info fb_info;                 /* FB driver info record */
+
+        int                                     plane;
+        unsigned char*          fb_mem;         /* FrameBuffer memory map */
+        unsigned int            fb_len;
+        dma_addr_t              fb_phys;
+};
+
+static struct au1200fb_device _au1200fb_devices[CONFIG_FB_AU1200_DEVS];
+/********************************************************************/
+
+/* LCD controller restrictions */
+#define AU1200_LCD_MAX_XRES     1280
+#define AU1200_LCD_MAX_YRES     1024
+#define AU1200_LCD_MAX_BPP      32
+#define AU1200_LCD_MAX_CLK      96000000 /* fixme: this needs to go away ? */
+#define AU1200_LCD_NBR_PALETTE_ENTRIES 256
+
+/* Default number of visible screen buffer to allocate */
+#define AU1200FB_NBR_VIDEO_BUFFERS 1
+
+/********************************************************************/
+
+static struct au1200_lcd *lcd = (struct au1200_lcd *) AU1200_LCD_ADDR;
+static int window_index = 2; /* default is zero */
+static int panel_index = 2; /* default is zero */
+static struct window_settings *win;
+static struct panel_settings *panel;
+static int noblanking = 1;
+static int nohwcursor = 0;
+
+struct window_settings {
+        unsigned char name[64];
+        uint32 mode_backcolor;
+        uint32 mode_colorkey;
+        uint32 mode_colorkeymsk;
+        struct {
+                int xres;
+                int yres;
+                int xpos;
+                int ypos;
+                uint32 mode_winctrl1; /* winctrl1[FRM,CCO,PO,PIPE] */
+                uint32 mode_winenable;
+        } w[4];
+};
+
+#if defined(__BIG_ENDIAN)
+#define LCD_WINCTRL1_PO_16BPP LCD_WINCTRL1_PO_00
+#else
+#define LCD_WINCTRL1_PO_16BPP LCD_WINCTRL1_PO_01
+#endif
+
+extern int board_au1200fb_panel_init (void);
+extern int board_au1200fb_panel_shutdown (void);
+
+#ifdef CONFIG_PM
+int au1200fb_pm_callback(au1xxx_power_dev_t *dev,
+                au1xxx_request_t request, void *data);
+au1xxx_power_dev_t *LCD_pm_dev;
+#endif
+
+/*
+ * Default window configurations
+ */
+static struct window_settings windows[] = {
+        { /* Index 0 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 100, 100, 100, 100,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN1,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+
+        { /* Index 1 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 320, 240, 5, 5,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_24BPP |
+                                LCD_WINCTRL1_PO_00,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565
+                                | LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 100, 100, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0/*LCD_WINENABLE_WEN2*/,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 200, 25, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+        { /* Index 2 */
+                "0-FS gfx, 1-video, 2-ovly gfx, 3-ovly gfx",
+                /* mode_backcolor       */ 0x006600ff,
+                /* mode_colorkey,msk*/ 0, 0,
+                {
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ LCD_WINENABLE_WEN0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP,
+                        /* mode_winenable*/ 0,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_32BPP |
+                                LCD_WINCTRL1_PO_00|LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0/*LCD_WINENABLE_WEN2*/,
+                        },
+                        {
+                        /* xres, yres, xpos, ypos */ 0, 0, 0, 0,
+                        /* mode_winctrl1 */ LCD_WINCTRL1_FRM_16BPP565 |
+                                LCD_WINCTRL1_PO_16BPP |
+                                LCD_WINCTRL1_PIPE,
+                        /* mode_winenable*/ 0,
+                        },
+                },
+        },
+        /* Need VGA 640 @ 24bpp, @ 32bpp */
+        /* Need VGA 800 @ 24bpp, @ 32bpp */
+        /* Need VGA 1024 @ 24bpp, @ 32bpp */
+};
+
+/*
+ * Controller configurations for various panels.
+ */
+
+struct panel_settings
+{
+        const char name[25];            /* Full name <vendor>_<model> */
+
+        struct  fb_monspecs monspecs;   /* FB monitor specs */
+
+        /* panel timings */
+        uint32 mode_screen;
+        uint32 mode_horztiming;
+        uint32 mode_verttiming;
+        uint32 mode_clkcontrol;
+        uint32 mode_pwmdiv;
+        uint32 mode_pwmhi;
+        uint32 mode_outmask;
+        uint32 mode_fifoctrl;
+        uint32 mode_toyclksrc;
+        uint32 mode_backlight;
+        uint32 mode_auxpll;
+        int (*device_init)(void);
+        int (*device_shutdown)(void);
+#define Xres min_xres
+#define Yres min_yres
+        u32     min_xres;               /* Minimum horizontal resolution */
+        u32     max_xres;               /* Maximum horizontal resolution */
+        u32     min_yres;               /* Minimum vertical resolution */
+        u32     max_yres;               /* Maximum vertical resolution */
+};
+
+/********************************************************************/
+/* fixme: Maybe a modedb for the CRT ? otherwise panels should be as-is */
+
+/* List of panels known to work with the AU1200 LCD controller.
+ * To add a new panel, enter the same specifications as the
+ * Generic_TFT one, and MAKE SURE that it doesn't conflicts
+ * with the controller restrictions. Restrictions are:
+ *
+ * STN color panels: max_bpp <= 12
+ * STN mono panels: max_bpp <= 4
+ * TFT panels: max_bpp <= 16
+ * max_xres <= 800
+ * max_yres <= 600
+ */
+static struct panel_settings known_lcd_panels[] =
+{
+        [0] = { /* QVGA 320x240 H:33.3kHz V:110Hz */
+                .name = "QVGA_320x240",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(320) |
+                        LCD_SCREEN_SY_N(240),
+                .mode_horztiming        = 0x00c4623b,
+                .mode_verttiming        = 0x00502814,
+                .mode_clkcontrol        = 0x00020002, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                320, 320,
+                240, 240,
+        },
+
+        [1] = { /* VGA 640x480 H:30.3kHz V:58Hz */
+                .name = "VGA_640x480",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x13f9df80,
+                .mode_horztiming        = 0x003c5859,
+                .mode_verttiming        = 0x00741201,
+                .mode_clkcontrol        = 0x00020001, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                640, 480,
+                640, 480,
+        },
+
+        [2] = { /* SVGA 800x600 H:46.1kHz V:69Hz */
+                .name = "SVGA_800x600",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x18fa5780,
+                .mode_horztiming        = 0x00dc7e77,
+                .mode_verttiming        = 0x00584805,
+                .mode_clkcontrol        = 0x00020000, /* /2=48Mhz */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                800, 800,
+                600, 600,
+        },
+
+        [3] = { /* XVGA 1024x768 H:56.2kHz V:70Hz */
+                .name = "XVGA_1024x768",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x1ffaff80,
+                .mode_horztiming        = 0x007d0e57,
+                .mode_verttiming        = 0x00740a01,
+                .mode_clkcontrol        = 0x000A0000, /* /1 */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 6, /* 72MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                1024, 1024,
+                768, 768,
+        },
+
+        [4] = { /* XVGA XVGA 1280x1024 H:68.5kHz V:65Hz */
+                .name = "XVGA_1280x1024",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x27fbff80,
+                .mode_horztiming        = 0x00cdb2c7,
+                .mode_verttiming        = 0x00600002,
+                .mode_clkcontrol        = 0x000A0000, /* /1 */
+                .mode_pwmdiv            = 0x00000000,
+                .mode_pwmhi             = 0x00000000,
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 10, /* 120MHz AUXPLL */
+                .device_init            = NULL,
+                .device_shutdown        = NULL,
+                1280, 1280,
+                1024, 1024,
+        },
+
+        [5] = { /* Samsung 1024x768 TFT */
+                .name = "Samsung_1024x768_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = 0x1ffaff80,
+                .mode_horztiming        = 0x018cc677,
+                .mode_verttiming        = 0x00241217,
+                .mode_clkcontrol        = 0x00000000, /* SCB 0x1 /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f, /* SCB 0x0 */
+                .mode_pwmhi             = 0x03400000, /* SCB 0x0 */
+                .mode_outmask   = 0x00FFFFFF,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                1024, 1024,
+                768, 768,
+        },
+
+        [6] = { /* Toshiba 640x480 TFT */
+                .name = "Toshiba_640x480_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(640) |
+                        LCD_SCREEN_SY_N(480),
+                .mode_horztiming        = LCD_HORZTIMING_HPW_N(96) |
+                        LCD_HORZTIMING_HND1_N(13) | LCD_HORZTIMING_HND2_N(51),
+                .mode_verttiming        = LCD_VERTTIMING_VPW_N(2) |
+                        LCD_VERTTIMING_VND1_N(11) | LCD_VERTTIMING_VND2_N(32),
+                .mode_clkcontrol        = 0x00000000, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                640, 480,
+                640, 480,
+        },
+
+        [7] = { /* Sharp 320x240 TFT */
+                .name = "Sharp_320x240_TFT",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 12500,
+                        .hfmax = 20000,
+                        .vfmin = 38,
+                        .vfmax = 81,
+                        .dclkmin = 4500000,
+                        .dclkmax = 6800000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(320) |
+                        LCD_SCREEN_SY_N(240),
+                .mode_horztiming        = LCD_HORZTIMING_HPW_N(60) |
+                        LCD_HORZTIMING_HND1_N(13) | LCD_HORZTIMING_HND2_N(2),
+                .mode_verttiming        = LCD_VERTTIMING_VPW_N(2) |
+                        LCD_VERTTIMING_VND1_N(2) | LCD_VERTTIMING_VND2_N(5),
+                .mode_clkcontrol        = LCD_CLKCONTROL_PCD_N(7), /*16=6Mhz*/
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                320, 320,
+                240, 240,
+        },
+
+        [8] = { /* Toppoly TD070WGCB2 7" 856x480 TFT */
+                .name = "Toppoly_TD070WGCB2",
+                .monspecs = {
+                        .modedb = NULL,
+                        .modedb_len = 0,
+                        .hfmin = 30000,
+                        .hfmax = 70000,
+                        .vfmin = 60,
+                        .vfmax = 60,
+                        .dclkmin = 6000000,
+                        .dclkmax = 28000000,
+                        .input = FB_DISP_RGB,
+                },
+                .mode_screen            = LCD_SCREEN_SX_N(856) |
+                        LCD_SCREEN_SY_N(480),
+                .mode_horztiming        = LCD_HORZTIMING_HND2_N(43) |
+                        LCD_HORZTIMING_HND1_N(43) | LCD_HORZTIMING_HPW_N(114),
+                .mode_verttiming        = LCD_VERTTIMING_VND2_N(20) |
+                        LCD_VERTTIMING_VND1_N(21) | LCD_VERTTIMING_VPW_N(4),
+                .mode_clkcontrol        = 0x00020001, /* /4=24Mhz */
+                .mode_pwmdiv            = 0x8000063f,
+                .mode_pwmhi             = 0x03400000,
+                .mode_outmask   = 0x00fcfcfc,
+                .mode_fifoctrl  = 0x2f2f2f2f,
+                .mode_toyclksrc = 0x00000004, /* AUXPLL directly */
+                .mode_backlight = 0x00000000,
+                .mode_auxpll            = 8, /* 96MHz AUXPLL */
+                .device_init            = board_au1200fb_panel_init,
+                .device_shutdown        = board_au1200fb_panel_shutdown,
+                856, 856,
+                480, 480,
+        },
+};
+
+#define NUM_PANELS (ARRAY_SIZE(known_lcd_panels))
+
+/********************************************************************/
+
+#ifdef CONFIG_PM
+static int set_brightness(unsigned int brightness)
+{
+        unsigned int hi1, divider;
+
+        /* limit brightness pwm duty to >= 30/1600 */
+        if (brightness < 30) {
+                brightness = 30;
+        }
+        divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+        hi1 = (lcd->pwmhi >> 16) + 1;
+        hi1 = (((brightness & 0xFF) + 1) * divider >> 8);
+        lcd->pwmhi &= 0xFFFF;
+        lcd->pwmhi |= (hi1 << 16);
+
+        return brightness;
+}
+#endif /* CONFIG_PM */
+
+static int winbpp (unsigned int winctrl1)
+{
+        int bits = 0;
+
+        /* how many bits are needed for each pixel format */
+        switch (winctrl1 & LCD_WINCTRL1_FRM) {
+        case LCD_WINCTRL1_FRM_1BPP:
+                bits = 1;
+                break;
+        case LCD_WINCTRL1_FRM_2BPP:
+                bits = 2;
+                break;
+        case LCD_WINCTRL1_FRM_4BPP:
+                bits = 4;
+                break;
+        case LCD_WINCTRL1_FRM_8BPP:
+                bits = 8;
+                break;
+        case LCD_WINCTRL1_FRM_12BPP:
+        case LCD_WINCTRL1_FRM_16BPP655:
+        case LCD_WINCTRL1_FRM_16BPP565:
+        case LCD_WINCTRL1_FRM_16BPP556:
+        case LCD_WINCTRL1_FRM_16BPPI1555:
+        case LCD_WINCTRL1_FRM_16BPPI5551:
+        case LCD_WINCTRL1_FRM_16BPPA1555:
+        case LCD_WINCTRL1_FRM_16BPPA5551:
+                bits = 16;
+                break;
+        case LCD_WINCTRL1_FRM_24BPP:
+        case LCD_WINCTRL1_FRM_32BPP:
+                bits = 32;
+                break;
+        }
+
+        return bits;
+}
+
+static int fbinfo2index (struct fb_info *fb_info)
+{
+        int i;
+
+        for (i = 0; i < CONFIG_FB_AU1200_DEVS; ++i) {
+                if (fb_info == (struct fb_info *)(&_au1200fb_devices[i].fb_info))
+                        return i;
+        }
+        printk("au1200fb: ERROR: fbinfo2index failed!\n");
+        return -1;
+}
+
+static int au1200_setlocation (struct au1200fb_device *fbdev, int plane,
+        int xpos, int ypos)
+{
+        uint32 winctrl0, winctrl1, winenable, fb_offset = 0;
+        int xsz, ysz;
+
+        /* FIX!!! NOT CHECKING FOR COMPLETE OFFSCREEN YET */
+
+        winctrl0 = lcd->window[plane].winctrl0;
+        winctrl1 = lcd->window[plane].winctrl1;
+        winctrl0 &= (LCD_WINCTRL0_A | LCD_WINCTRL0_AEN);
+        winctrl1 &= ~(LCD_WINCTRL1_SZX | LCD_WINCTRL1_SZY);
+
+        /* Check for off-screen adjustments */
+        xsz = win->w[plane].xres;
+        ysz = win->w[plane].yres;
+        if ((xpos + win->w[plane].xres) > panel->Xres) {
+                /* Off-screen to the right */
+                xsz = panel->Xres - xpos; /* off by 1 ??? */
+                /*printk("off screen right\n");*/
+        }
+
+        if ((ypos + win->w[plane].yres) > panel->Yres) {
+                /* Off-screen to the bottom */
+                ysz = panel->Yres - ypos; /* off by 1 ??? */
+                /*printk("off screen bottom\n");*/
+        }
+
+        if (xpos < 0) {
+                /* Off-screen to the left */
+                xsz = win->w[plane].xres + xpos;
+                fb_offset += (((0 - xpos) * winbpp(lcd->window[plane].winctrl1))/8);
+                xpos = 0;
+                /*printk("off screen left\n");*/
+        }
+
+        if (ypos < 0) {
+                /* Off-screen to the top */
+                ysz = win->w[plane].yres + ypos;
+                /* fixme: fb_offset += ((0-ypos)*fb_pars[plane].line_length); */
+                ypos = 0;
+                /*printk("off screen top\n");*/
+        }
+
+        /* record settings */
+        win->w[plane].xpos = xpos;
+        win->w[plane].ypos = ypos;
+
+        xsz -= 1;
+        ysz -= 1;
+        winctrl0 |= (xpos << 21);
+        winctrl0 |= (ypos << 10);
+        winctrl1 |= (xsz << 11);
+        winctrl1 |= (ysz << 0);
+
+        /* Disable the window while making changes, then restore WINEN */
+        winenable = lcd->winenable & (1 << plane);
+        au_sync();
+        lcd->winenable &= ~(1 << plane);
+        lcd->window[plane].winctrl0 = winctrl0;
+        lcd->window[plane].winctrl1 = winctrl1;
+        lcd->window[plane].winbuf0 =
+        lcd->window[plane].winbuf1 = fbdev->fb_phys;
+        lcd->window[plane].winbufctrl = 0; /* select winbuf0 */
+        lcd->winenable |= winenable;
+        au_sync();
+
+        return 0;
+}
+
+static void au1200_setpanel (struct panel_settings *newpanel)
+{
+        /*
+         * Perform global setup/init of LCD controller
+         */
+        uint32 winenable;
+
+        /* Make sure all windows disabled */
+        winenable = lcd->winenable;
+        lcd->winenable = 0;
+        au_sync();
+        /*
+         * Ensure everything is disabled before reconfiguring
+         */
+        if (lcd->screen & LCD_SCREEN_SEN) {
+                /* Wait for vertical sync period */
+                lcd->intstatus = LCD_INT_SS;
+                while ((lcd->intstatus & LCD_INT_SS) == 0) {
+                        au_sync();
+                }
+
+                lcd->screen &= ~LCD_SCREEN_SEN; /*disable the controller*/
+
+                do {
+                        lcd->intstatus = lcd->intstatus; /*clear interrupts*/
+                        au_sync();
+                /*wait for controller to shut down*/
+                } while ((lcd->intstatus & LCD_INT_SD) == 0);
+
+                /* Call shutdown of current panel (if up) */
+                /* this must occur last, because if an external clock is driving
+                    the controller, the clock cannot be turned off before first
+                        shutting down the controller.
+                 */
+                if (panel->device_shutdown != NULL)
+                        panel->device_shutdown();
+        }
+
+        /* Newpanel == NULL indicates a shutdown operation only */
+        if (newpanel == NULL)
+                return;
+
+        panel = newpanel;
+
+        printk("Panel(%s), %dx%d\n", panel->name, panel->Xres, panel->Yres);
+
+        /*
+         * Setup clocking if internal LCD clock source (assumes sys_auxpll valid)
+         */
+        if (!(panel->mode_clkcontrol & LCD_CLKCONTROL_EXT))
+        {
+                uint32 sys_clksrc;
+                au_writel(panel->mode_auxpll, SYS_AUXPLL);
+                sys_clksrc = au_readl(SYS_CLKSRC) & ~0x0000001f;
+                sys_clksrc |= panel->mode_toyclksrc;
+                au_writel(sys_clksrc, SYS_CLKSRC);
+        }
+
+        /*
+         * Configure panel timings
+         */
+        lcd->screen = panel->mode_screen;
+        lcd->horztiming = panel->mode_horztiming;
+        lcd->verttiming = panel->mode_verttiming;
+        lcd->clkcontrol = panel->mode_clkcontrol;
+        lcd->pwmdiv = panel->mode_pwmdiv;
+        lcd->pwmhi = panel->mode_pwmhi;
+        lcd->outmask = panel->mode_outmask;
+        lcd->fifoctrl = panel->mode_fifoctrl;
+        au_sync();
+
+        /* fixme: Check window settings to make sure still valid
+         * for new geometry */
+#if 0
+        au1200_setlocation(fbdev, 0, win->w[0].xpos, win->w[0].ypos);
+        au1200_setlocation(fbdev, 1, win->w[1].xpos, win->w[1].ypos);
+        au1200_setlocation(fbdev, 2, win->w[2].xpos, win->w[2].ypos);
+        au1200_setlocation(fbdev, 3, win->w[3].xpos, win->w[3].ypos);
+#endif
+        lcd->winenable = winenable;
+
+        /*
+         * Re-enable screen now that it is configured
+         */
+        lcd->screen |= LCD_SCREEN_SEN;
+        au_sync();
+
+        /* Call init of panel */
+        if (panel->device_init != NULL) panel->device_init();
+
+        /* FIX!!!! not appropriate on panel change!!! Global setup/init */
+        lcd->intenable = 0;
+        lcd->intstatus = ~0;
+        lcd->backcolor = win->mode_backcolor;
+
+        /* Setup Color Key - FIX!!! */
+        lcd->colorkey = win->mode_colorkey;
+        lcd->colorkeymsk = win->mode_colorkeymsk;
+
+        /* Setup HWCursor - FIX!!! Need to support this eventually */
+        lcd->hwc.cursorctrl = 0;
+        lcd->hwc.cursorpos = 0;
+        lcd->hwc.cursorcolor0 = 0;
+        lcd->hwc.cursorcolor1 = 0;
+        lcd->hwc.cursorcolor2 = 0;
+        lcd->hwc.cursorcolor3 = 0;
+
+
+#if 0
+#define D(X) printk("%25s: %08X\n", #X, X)
+        D(lcd->screen);
+        D(lcd->horztiming);
+        D(lcd->verttiming);
+        D(lcd->clkcontrol);
+        D(lcd->pwmdiv);
+        D(lcd->pwmhi);
+        D(lcd->outmask);
+        D(lcd->fifoctrl);
+        D(lcd->window[0].winctrl0);
+        D(lcd->window[0].winctrl1);
+        D(lcd->window[0].winctrl2);
+        D(lcd->window[0].winbuf0);
+        D(lcd->window[0].winbuf1);
+        D(lcd->window[0].winbufctrl);
+        D(lcd->window[1].winctrl0);
+        D(lcd->window[1].winctrl1);
+        D(lcd->window[1].winctrl2);
+        D(lcd->window[1].winbuf0);
+        D(lcd->window[1].winbuf1);
+        D(lcd->window[1].winbufctrl);
+        D(lcd->window[2].winctrl0);
+        D(lcd->window[2].winctrl1);
+        D(lcd->window[2].winctrl2);
+        D(lcd->window[2].winbuf0);
+        D(lcd->window[2].winbuf1);
+        D(lcd->window[2].winbufctrl);
+        D(lcd->window[3].winctrl0);
+        D(lcd->window[3].winctrl1);
+        D(lcd->window[3].winctrl2);
+        D(lcd->window[3].winbuf0);
+        D(lcd->window[3].winbuf1);
+        D(lcd->window[3].winbufctrl);
+        D(lcd->winenable);
+        D(lcd->intenable);
+        D(lcd->intstatus);
+        D(lcd->backcolor);
+        D(lcd->winenable);
+        D(lcd->colorkey);
+    D(lcd->colorkeymsk);
+        D(lcd->hwc.cursorctrl);
+        D(lcd->hwc.cursorpos);
+        D(lcd->hwc.cursorcolor0);
+        D(lcd->hwc.cursorcolor1);
+        D(lcd->hwc.cursorcolor2);
+        D(lcd->hwc.cursorcolor3);
+#endif
+}
+
+static void au1200_setmode(struct au1200fb_device *fbdev)
+{
+        int plane = fbdev->plane;
+        /* Window/plane setup */
+        lcd->window[plane].winctrl1 = ( 0
+                | LCD_WINCTRL1_PRI_N(plane)
+                | win->w[plane].mode_winctrl1 /* FRM,CCO,PO,PIPE */
+                ) ;
+
+        au1200_setlocation(fbdev, plane, win->w[plane].xpos, win->w[plane].ypos);
+
+        lcd->window[plane].winctrl2 = ( 0
+                | LCD_WINCTRL2_CKMODE_00
+                | LCD_WINCTRL2_DBM
+                | LCD_WINCTRL2_BX_N( fbdev->fb_info.fix.line_length)
+                | LCD_WINCTRL2_SCX_1
+                | LCD_WINCTRL2_SCY_1
+                ) ;
+        lcd->winenable |= win->w[plane].mode_winenable;
+        au_sync();
+}
+
+
+/* Inline helpers */
+
+/*#define panel_is_dual(panel)  ((panel->mode_screen & LCD_SCREEN_PT) == LCD_SCREEN_PT_010)*/
+/*#define panel_is_active(panel)((panel->mode_screen & LCD_SCREEN_PT) == LCD_SCREEN_PT_010)*/
+
+#define panel_is_color(panel) ((panel->mode_screen & LCD_SCREEN_PT) <= LCD_SCREEN_PT_CDSTN)
+
+/* Bitfields format supported by the controller. */
+static struct fb_bitfield rgb_bitfields[][4] = {
+        /*     Red,        Green,        Blue,       Transp   */
+        [LCD_WINCTRL1_FRM_16BPP655 >> 25] =
+                { { 10, 6, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPP565 >> 25] =
+                { { 11, 5, 0 }, { 5, 6, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPP556 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 0, 6, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPI1555 >> 25] =
+                { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPI5551 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPA1555 >> 25] =
+                { { 10, 5, 0 }, { 5, 5, 0 }, { 0, 5, 0 }, { 15, 1, 0 } },
+
+        [LCD_WINCTRL1_FRM_16BPPA5551 >> 25] =
+                { { 11, 5, 0 }, { 6, 5, 0 }, { 1, 5, 0 }, { 0, 1, 0 } },
+
+        [LCD_WINCTRL1_FRM_24BPP >> 25] =
+                { { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 0, 0, 0 } },
+
+        [LCD_WINCTRL1_FRM_32BPP >> 25] =
+                { { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 24, 0, 0 } },
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Helpers */
+
+static void au1200fb_update_fbinfo(struct fb_info *fbi)
+{
+        /* FIX!!!! This also needs to take the window pixel format into account!!! */
+
+        /* Update var-dependent FB info */
+        if (panel_is_color(panel)) {
+                if (fbi->var.bits_per_pixel <= 8) {
+                        /* palettized */
+                        fbi->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+                        fbi->fix.line_length = fbi->var.xres_virtual /
+                                (8/fbi->var.bits_per_pixel);
+                } else {
+                        /* non-palettized */
+                        fbi->fix.visual = FB_VISUAL_TRUECOLOR;
+                        fbi->fix.line_length = fbi->var.xres_virtual * (fbi->var.bits_per_pixel / 8);
+                }
+        } else {
+                /* mono FIX!!! mono 8 and 4 bits */
+                fbi->fix.visual = FB_VISUAL_MONO10;
+                fbi->fix.line_length = fbi->var.xres_virtual / 8;
+        }
+
+        fbi->screen_size = fbi->fix.line_length * fbi->var.yres_virtual;
+        print_dbg("line length: %d\n", fbi->fix.line_length);
+        print_dbg("bits_per_pixel: %d\n", fbi->var.bits_per_pixel);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 framebuffer driver */
+
+/* fb_check_var
+ * Validate var settings with hardware restrictions and modify it if necessary
+ */
+static int au1200fb_fb_check_var(struct fb_var_screeninfo *var,
+        struct fb_info *fbi)
+{
+        struct au1200fb_device *fbdev = (struct au1200fb_device *)fbi;
+        u32 pixclock;
+        int screen_size, plane;
+
+        plane = fbdev->plane;
+
+        /* Make sure that the mode respect all LCD controller and
+         * panel restrictions. */
+        var->xres = win->w[plane].xres;
+        var->yres = win->w[plane].yres;
+
+        /* No need for virtual resolution support */
+        var->xres_virtual = var->xres;
+        var->yres_virtual = var->yres;
+
+        var->bits_per_pixel = winbpp(win->w[plane].mode_winctrl1);
+
+        screen_size = var->xres_virtual * var->yres_virtual;
+        if (var->bits_per_pixel > 8) screen_size *= (var->bits_per_pixel / 8);
+        else screen_size /= (8/var->bits_per_pixel);
+
+        if (fbdev->fb_len < screen_size)
+                return -EINVAL; /* Virtual screen is to big, abort */
+
+        /* FIX!!!! what are the implicaitons of ignoring this for windows ??? */
+        /* The max LCD clock is fixed to 48MHz (value of AUX_CLK). The pixel
+         * clock can only be obtain by dividing this value by an even integer.
+         * Fallback to a slower pixel clock if necessary. */
+        pixclock = max((u32)(PICOS2KHZ(var->pixclock) * 1000), fbi->monspecs.dclkmin);
+        pixclock = min(pixclock, min(fbi->monspecs.dclkmax, (u32)AU1200_LCD_MAX_CLK/2));
+
+        if (AU1200_LCD_MAX_CLK % pixclock) {
+                int diff = AU1200_LCD_MAX_CLK % pixclock;
+                pixclock -= diff;
+        }
+
+        var->pixclock = KHZ2PICOS(pixclock/1000);
+#if 0
+        if (!panel_is_active(panel)) {
+                int pcd = AU1200_LCD_MAX_CLK / (pixclock * 2) - 1;
+
+                if (!panel_is_color(panel)
+                        && (panel->control_base & LCD_CONTROL_MPI) && (pcd < 3)) {
+                        /* STN 8bit mono panel support is up to 6MHz pixclock */
+                        var->pixclock = KHZ2PICOS(6000);
+                } else if (!pcd) {
+                        /* Other STN panel support is up to 12MHz  */
+                        var->pixclock = KHZ2PICOS(12000);
+                }
+        }
+#endif
+        /* Set bitfield accordingly */
+        switch (var->bits_per_pixel) {
+                case 16:
+                {
+                        /* 16bpp True color.
+                         * These must be set to MATCH WINCTRL[FORM] */
+                        int idx;
+                        idx = (win->w[0].mode_winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+                        var->red    = rgb_bitfields[idx][0];
+                        var->green  = rgb_bitfields[idx][1];
+                        var->blue   = rgb_bitfields[idx][2];
+                        var->transp = rgb_bitfields[idx][3];
+                        break;
+                }
+
+                case 32:
+                {
+                        /* 32bpp True color.
+                         * These must be set to MATCH WINCTRL[FORM] */
+                        int idx;
+                        idx = (win->w[0].mode_winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+                        var->red    = rgb_bitfields[idx][0];
+                        var->green  = rgb_bitfields[idx][1];
+                        var->blue   = rgb_bitfields[idx][2];
+                        var->transp = rgb_bitfields[idx][3];
+                        break;
+                }
+                default:
+                        print_dbg("Unsupported depth %dbpp", var->bits_per_pixel);
+                        return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* fb_set_par
+ * Set hardware with var settings. This will enable the controller with a
+ * specific mode, normally validated with the fb_check_var method
+ */
+static int au1200fb_fb_set_par(struct fb_info *fbi)
+{
+        struct au1200fb_device *fbdev = (struct au1200fb_device *)fbi;
+
+        au1200fb_update_fbinfo(fbi);
+        au1200_setmode(fbdev);
+
+        return 0;
+}
+
+/* fb_setcolreg
+ * Set color in LCD palette.
+ */
+static int au1200fb_fb_setcolreg(unsigned regno, unsigned red, unsigned green,
+        unsigned blue, unsigned transp, struct fb_info *fbi)
+{
+        volatile u32 *palette = lcd->palette;
+        u32 value;
+
+        if (regno > (AU1200_LCD_NBR_PALETTE_ENTRIES - 1))
+                return -EINVAL;
+
+        if (fbi->var.grayscale) {
+                /* Convert color to grayscale */
+                red = green = blue =
+                        (19595 * red + 38470 * green + 7471 * blue) >> 16;
+        }
+
+        if (fbi->fix.visual == FB_VISUAL_TRUECOLOR) {
+                /* Place color in the pseudopalette */
+                if (regno > 16)
+                        return -EINVAL;
+
+                palette = (u32*) fbi->pseudo_palette;
+
+                red   >>= (16 - fbi->var.red.length);
+                green >>= (16 - fbi->var.green.length);
+                blue  >>= (16 - fbi->var.blue.length);
+
+                value = (red   << fbi->var.red.offset)  |
+                        (green << fbi->var.green.offset)|
+                        (blue  << fbi->var.blue.offset);
+                value &= 0xFFFF;
+
+        } else if (1 /*FIX!!! panel_is_active(fbdev->panel)*/) {
+                /* COLOR TFT PALLETTIZED (use RGB 565) */
+                value = (red & 0xF800)|((green >> 5) &
+                                0x07E0)|((blue >> 11) & 0x001F);
+                value &= 0xFFFF;
+
+        } else if (0 /*panel_is_color(fbdev->panel)*/) {
+                /* COLOR STN MODE */
+                value = 0x1234;
+                value &= 0xFFF;
+        } else {
+                /* MONOCHROME MODE */
+                value = (green >> 12) & 0x000F;
+                value &= 0xF;
+        }
+
+        palette[regno] = value;
+
+        return 0;
+}
+
+/* fb_blank
+ * Blank the screen. Depending on the mode, the screen will be
+ * activated with the backlight color, or desactivated
+ */
+static int au1200fb_fb_blank(int blank_mode, struct fb_info *fbi)
+{
+        /* Short-circuit screen blanking */
+        if (noblanking)
+                return 0;
+
+        switch (blank_mode) {
+
+        case FB_BLANK_UNBLANK:
+        case FB_BLANK_NORMAL:
+                /* printk("turn on panel\n"); */
+                au1200_setpanel(panel);
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+        case FB_BLANK_HSYNC_SUSPEND:
+        case FB_BLANK_POWERDOWN:
+                /* printk("turn off panel\n"); */
+                au1200_setpanel(NULL);
+                break;
+        default:
+                break;
+
+        }
+
+        /* FB_BLANK_NORMAL is a soft blank */
+        return (blank_mode == FB_BLANK_NORMAL) ? -EINVAL : 0;
+}
+
+/* fb_mmap
+ * Map video memory in user space. We don't use the generic fb_mmap
+ * method mainly to allow the use of the TLB streaming flag (CCA=6)
+ */
+static int au1200fb_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
+
+{
+        unsigned int len;
+        unsigned long start=0, off;
+        struct au1200fb_device *fbdev = (struct au1200fb_device *) info;
+
+#ifdef CONFIG_PM
+        au1xxx_pm_access(LCD_pm_dev);
+#endif
+
+        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) {
+                return -EINVAL;
+        }
+
+        start = fbdev->fb_phys & PAGE_MASK;
+        len = PAGE_ALIGN((start & ~PAGE_MASK) + fbdev->fb_len);
+
+        off = vma->vm_pgoff << PAGE_SHIFT;
+
+        if ((vma->vm_end - vma->vm_start + off) > len) {
+                return -EINVAL;
+        }
+
+        off += start;
+        vma->vm_pgoff = off >> PAGE_SHIFT;
+
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        pgprot_val(vma->vm_page_prot) |= _CACHE_MASK; /* CCA=7 */
+
+        vma->vm_flags |= VM_IO;
+
+        return io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
+                                  vma->vm_end - vma->vm_start,
+                                  vma->vm_page_prot);
+
+        return 0;
+}
+
+static void set_global(u_int cmd, struct au1200_lcd_global_regs_t *pdata)
+{
+
+        unsigned int hi1, divider;
+
+        /* SCREEN_SIZE: user cannot reset size, must switch panel choice */
+
+        if (pdata->flags & SCREEN_BACKCOLOR)
+                lcd->backcolor = pdata->backcolor;
+
+        if (pdata->flags & SCREEN_BRIGHTNESS) {
+
+                // limit brightness pwm duty to >= 30/1600
+                if (pdata->brightness < 30) {
+                        pdata->brightness = 30;
+                }
+                divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+                hi1 = (lcd->pwmhi >> 16) + 1;
+                hi1 = (((pdata->brightness & 0xFF)+1) * divider >> 8);
+                lcd->pwmhi &= 0xFFFF;
+                lcd->pwmhi |= (hi1 << 16);
+        }
+
+        if (pdata->flags & SCREEN_COLORKEY)
+                lcd->colorkey = pdata->colorkey;
+
+        if (pdata->flags & SCREEN_MASK)
+                lcd->colorkeymsk = pdata->mask;
+        au_sync();
+}
+
+static void get_global(u_int cmd, struct au1200_lcd_global_regs_t *pdata)
+{
+        unsigned int hi1, divider;
+
+        pdata->xsize = ((lcd->screen & LCD_SCREEN_SX) >> 19) + 1;
+        pdata->ysize = ((lcd->screen & LCD_SCREEN_SY) >> 8) + 1;
+
+        pdata->backcolor = lcd->backcolor;
+        pdata->colorkey = lcd->colorkey;
+        pdata->mask = lcd->colorkeymsk;
+
+        // brightness
+        hi1 = (lcd->pwmhi >> 16) + 1;
+        divider = (lcd->pwmdiv & 0x3FFFF) + 1;
+        pdata->brightness = ((hi1 << 8) / divider) - 1;
+        au_sync();
+}
+
+static void set_window(unsigned int plane,
+        struct au1200_lcd_window_regs_t *pdata)
+{
+        unsigned int val, bpp;
+
+        /* Window control register 0 */
+        if (pdata->flags & WIN_POSITION) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_OX |
+                                LCD_WINCTRL0_OY);
+                val |= ((pdata->xpos << 21) & LCD_WINCTRL0_OX);
+                val |= ((pdata->ypos << 10) & LCD_WINCTRL0_OY);
+                lcd->window[plane].winctrl0 = val;
+        }
+        if (pdata->flags & WIN_ALPHA_COLOR) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_A);
+                val |= ((pdata->alpha_color << 2) & LCD_WINCTRL0_A);
+                lcd->window[plane].winctrl0 = val;
+        }
+        if (pdata->flags & WIN_ALPHA_MODE) {
+                val = lcd->window[plane].winctrl0 & ~(LCD_WINCTRL0_AEN);
+                val |= ((pdata->alpha_mode << 1) & LCD_WINCTRL0_AEN);
+                lcd->window[plane].winctrl0 = val;
+        }
+
+        /* Window control register 1 */
+        if (pdata->flags & WIN_PRIORITY) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PRI);
+                val |= ((pdata->priority << 30) & LCD_WINCTRL1_PRI);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_CHANNEL) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PIPE);
+                val |= ((pdata->channel << 29) & LCD_WINCTRL1_PIPE);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_BUFFER_FORMAT) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_FRM);
+                val |= ((pdata->buffer_format << 25) & LCD_WINCTRL1_FRM);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_COLOR_ORDER) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_CCO);
+                val |= ((pdata->color_order << 24) & LCD_WINCTRL1_CCO);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_PIXEL_ORDER) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_PO);
+                val |= ((pdata->pixel_order << 22) & LCD_WINCTRL1_PO);
+                lcd->window[plane].winctrl1 = val;
+        }
+        if (pdata->flags & WIN_SIZE) {
+                val = lcd->window[plane].winctrl1 & ~(LCD_WINCTRL1_SZX |
+                                LCD_WINCTRL1_SZY);
+                val |= (((pdata->xsize << 11) - 1) & LCD_WINCTRL1_SZX);
+                val |= (((pdata->ysize) - 1) & LCD_WINCTRL1_SZY);
+                lcd->window[plane].winctrl1 = val;
+                /* program buffer line width */
+                bpp = winbpp(val) / 8;
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_BX);
+                val |= (((pdata->xsize * bpp) << 8) & LCD_WINCTRL2_BX);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        /* Window control register 2 */
+        if (pdata->flags & WIN_COLORKEY_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_CKMODE);
+                val |= ((pdata->colorkey_mode << 24) & LCD_WINCTRL2_CKMODE);
+                lcd->window[plane].winctrl2 = val;
+        }
+        if (pdata->flags & WIN_DOUBLE_BUFFER_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_DBM);
+                val |= ((pdata->double_buffer_mode << 23) & LCD_WINCTRL2_DBM);
+                lcd->window[plane].winctrl2 = val;
+        }
+        if (pdata->flags & WIN_RAM_ARRAY_MODE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_RAM);
+                val |= ((pdata->ram_array_mode << 21) & LCD_WINCTRL2_RAM);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        /* Buffer line width programmed with WIN_SIZE */
+
+        if (pdata->flags & WIN_BUFFER_SCALE) {
+                val = lcd->window[plane].winctrl2 & ~(LCD_WINCTRL2_SCX |
+                                LCD_WINCTRL2_SCY);
+                val |= ((pdata->xsize << 11) & LCD_WINCTRL2_SCX);
+                val |= ((pdata->ysize) & LCD_WINCTRL2_SCY);
+                lcd->window[plane].winctrl2 = val;
+        }
+
+        if (pdata->flags & WIN_ENABLE) {
+                val = lcd->winenable;
+                val &= ~(1<<plane);
+                val |= (pdata->enable & 1) << plane;
+                lcd->winenable = val;
+        }
+        au_sync();
+}
+
+static void get_window(unsigned int plane,
+        struct au1200_lcd_window_regs_t *pdata)
+{
+        /* Window control register 0 */
+        pdata->xpos = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_OX) >> 21;
+        pdata->ypos = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_OY) >> 10;
+        pdata->alpha_color = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_A) >> 2;
+        pdata->alpha_mode = (lcd->window[plane].winctrl0 & LCD_WINCTRL0_AEN) >> 1;
+
+        /* Window control register 1 */
+        pdata->priority = (lcd->window[plane].winctrl1& LCD_WINCTRL1_PRI) >> 30;
+        pdata->channel = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_PIPE) >> 29;
+        pdata->buffer_format = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_FRM) >> 25;
+        pdata->color_order = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_CCO) >> 24;
+        pdata->pixel_order = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_PO) >> 22;
+        pdata->xsize = ((lcd->window[plane].winctrl1 & LCD_WINCTRL1_SZX) >> 11) + 1;
+        pdata->ysize = (lcd->window[plane].winctrl1 & LCD_WINCTRL1_SZY) + 1;
+
+        /* Window control register 2 */
+        pdata->colorkey_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_CKMODE) >> 24;
+        pdata->double_buffer_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_DBM) >> 23;
+        pdata->ram_array_mode = (lcd->window[plane].winctrl2 & LCD_WINCTRL2_RAM) >> 21;
+
+        pdata->enable = (lcd->winenable >> plane) & 1;
+        au_sync();
+}
+
+static int au1200fb_ioctl(struct fb_info *info, unsigned int cmd,
+                          unsigned long arg)
+{
+        int plane;
+        int val;
+
+#ifdef CONFIG_PM
+        au1xxx_pm_access(LCD_pm_dev);
+#endif
+
+        plane = fbinfo2index(info);
+        print_dbg("au1200fb: ioctl %d on plane %d\n", cmd, plane);
+
+        if (cmd == AU1200_LCD_FB_IOCTL) {
+                struct au1200_lcd_iodata_t iodata;
+
+                if (copy_from_user(&iodata, (void __user *) arg, sizeof(iodata)))
+                        return -EFAULT;
+
+                print_dbg("FB IOCTL called\n");
+
+                switch (iodata.subcmd) {
+                case AU1200_LCD_SET_SCREEN:
+                        print_dbg("AU1200_LCD_SET_SCREEN\n");
+                        set_global(cmd, &iodata.global);
+                        break;
+
+                case AU1200_LCD_GET_SCREEN:
+                        print_dbg("AU1200_LCD_GET_SCREEN\n");
+                        get_global(cmd, &iodata.global);
+                        break;
+
+                case AU1200_LCD_SET_WINDOW:
+                        print_dbg("AU1200_LCD_SET_WINDOW\n");
+                        set_window(plane, &iodata.window);
+                        break;
+
+                case AU1200_LCD_GET_WINDOW:
+                        print_dbg("AU1200_LCD_GET_WINDOW\n");
+                        get_window(plane, &iodata.window);
+                        break;
+
+                case AU1200_LCD_SET_PANEL:
+                        print_dbg("AU1200_LCD_SET_PANEL\n");
+                        if ((iodata.global.panel_choice >= 0) &&
+                                        (iodata.global.panel_choice <
+                                         NUM_PANELS))
+                        {
+                                struct panel_settings *newpanel;
+                                panel_index = iodata.global.panel_choice;
+                                newpanel = &known_lcd_panels[panel_index];
+                                au1200_setpanel(newpanel);
+                        }
+                        break;
+
+                case AU1200_LCD_GET_PANEL:
+                        print_dbg("AU1200_LCD_GET_PANEL\n");
+                        iodata.global.panel_choice = panel_index;
+                        break;
+
+                default:
+                        return -EINVAL;
+                }
+
+                val = copy_to_user((void __user *) arg, &iodata, sizeof(iodata));
+                if (val) {
+                        print_dbg("error: could not copy %d bytes\n", val);
+                        return -EFAULT;
+                }
+        }
+
+        return 0;
+}
+
+
+static struct fb_ops au1200fb_fb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_check_var   = au1200fb_fb_check_var,
+        .fb_set_par     = au1200fb_fb_set_par,
+        .fb_setcolreg   = au1200fb_fb_setcolreg,
+        .fb_blank       = au1200fb_fb_blank,
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+        .fb_sync        = NULL,
+        .fb_ioctl       = au1200fb_ioctl,
+        .fb_mmap        = au1200fb_fb_mmap,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static irqreturn_t au1200fb_handle_irq(int irq, void* dev_id, struct pt_regs *regs)
+{
+        /* Nothing to do for now, just clear any pending interrupt */
+        lcd->intstatus = lcd->intstatus;
+        au_sync();
+
+        return IRQ_HANDLED;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 LCD device probe helpers */
+
+static int au1200fb_init_fbinfo(struct au1200fb_device *fbdev)
+{
+        struct fb_info *fbi = &fbdev->fb_info;
+        int bpp;
+
+        memset(fbi, 0, sizeof(struct fb_info));
+        fbi->fbops = &au1200fb_fb_ops;
+
+        bpp = winbpp(win->w[fbdev->plane].mode_winctrl1);
+
+        /* Copy monitor specs from panel data */
+        /* fixme: we're setting up LCD controller windows, so these dont give a
+        damn as to what the monitor specs are (the panel itself does, but that
+        isnt done here...so maybe need a generic catchall monitor setting??? */
+        memcpy(&fbi->monspecs, &panel->monspecs, sizeof(struct fb_monspecs));
+
+        /* We first try the user mode passed in argument. If that failed,
+         * or if no one has been specified, we default to the first mode of the
+         * panel list. Note that after this call, var data will be set */
+        if (!fb_find_mode(&fbi->var,
+                          fbi,
+                          NULL, /* drv_info.opt_mode, */
+                          fbi->monspecs.modedb,
+                          fbi->monspecs.modedb_len,
+                          fbi->monspecs.modedb,
+                          bpp)) {
+
+                print_err("Cannot find valid mode for panel %s", panel->name);
+                return -EFAULT;
+        }
+
+        fbi->pseudo_palette = kmalloc(sizeof(u32) * 16, GFP_KERNEL);
+        if (!fbi->pseudo_palette) {
+                return -ENOMEM;
+        }
+        memset(fbi->pseudo_palette, 0, sizeof(u32) * 16);
+
+        if (fb_alloc_cmap(&fbi->cmap, AU1200_LCD_NBR_PALETTE_ENTRIES, 0) < 0) {
+                print_err("Fail to allocate colormap (%d entries)",
+                           AU1200_LCD_NBR_PALETTE_ENTRIES);
+                kfree(fbi->pseudo_palette);
+                return -EFAULT;
+        }
+
+        strncpy(fbi->fix.id, "AU1200", sizeof(fbi->fix.id));
+        fbi->fix.smem_start = fbdev->fb_phys;
+        fbi->fix.smem_len = fbdev->fb_len;
+        fbi->fix.type = FB_TYPE_PACKED_PIXELS;
+        fbi->fix.xpanstep = 0;
+        fbi->fix.ypanstep = 0;
+        fbi->fix.mmio_start = 0;
+        fbi->fix.mmio_len = 0;
+        fbi->fix.accel = FB_ACCEL_NONE;
+
+        fbi->screen_base = (char __iomem *) fbdev->fb_mem;
+
+        au1200fb_update_fbinfo(fbi);
+
+        return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* AU1200 LCD controller device driver */
+
+static int au1200fb_drv_probe(struct device *dev)
+{
+        struct au1200fb_device *fbdev;
+        unsigned long page;
+        int bpp, plane, ret;
+
+        if (!dev)
+                return -EINVAL;
+
+        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane) {
+                bpp = winbpp(win->w[plane].mode_winctrl1);
+                if (win->w[plane].xres == 0)
+                        win->w[plane].xres = panel->Xres;
+                if (win->w[plane].yres == 0)
+                        win->w[plane].yres = panel->Yres;
+
+                fbdev = &_au1200fb_devices[plane];
+                memset(fbdev, 0, sizeof(struct au1200fb_device));
+                fbdev->plane = plane;
+
+                /* Allocate the framebuffer to the maximum screen size */
+                fbdev->fb_len = (win->w[plane].xres * win->w[plane].yres * bpp) / 8;
+
+                fbdev->fb_mem = dma_alloc_noncoherent(dev,
+                                PAGE_ALIGN(fbdev->fb_len),
+                                &fbdev->fb_phys, GFP_KERNEL);
+                if (!fbdev->fb_mem) {
+                        print_err("fail to allocate frambuffer (size: %dK))",
+                                  fbdev->fb_len / 1024);
+                        return -ENOMEM;
+                }
+
+                /*
+                 * Set page reserved so that mmap will work. This is necessary
+                 * since we'll be remapping normal memory.
+                 */
+                for (page = (unsigned long)fbdev->fb_phys;
+                     page < PAGE_ALIGN((unsigned long)fbdev->fb_phys +
+                             fbdev->fb_len);
+                     page += PAGE_SIZE) {
+                        SetPageReserved(pfn_to_page(page >> PAGE_SHIFT)); /* LCD DMA is NOT coherent on Au1200 */
+                }
+                print_dbg("Framebuffer memory map at %p", fbdev->fb_mem);
+                print_dbg("phys=0x%08x, size=%dK", fbdev->fb_phys, fbdev->fb_len / 1024);
+
+                /* Init FB data */
+                if ((ret = au1200fb_init_fbinfo(fbdev)) < 0)
+                        goto failed;
+
+                /* Register new framebuffer */
+                if ((ret = register_framebuffer(&fbdev->fb_info)) < 0) {
+                        print_err("cannot register new framebuffer");
+                        goto failed;
+                }
+
+                au1200fb_fb_set_par(&fbdev->fb_info);
+
+#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
+                if (plane == 0)
+                        if (fb_prepare_logo(&fbdev->fb_info, FB_ROTATE_UR)) {
+                                /* Start display and show logo on boot */
+                                fb_set_cmap(&fbdev->fb_info.cmap,
+                                                &fbdev->fb_info);
+
+                                fb_show_logo(&fbdev->fb_info, FB_ROTATE_UR);
+                        }
+#endif
+        }
+
+        /* Now hook interrupt too */
+        if ((ret = request_irq(AU1200_LCD_INT, au1200fb_handle_irq,
+                          SA_INTERRUPT | SA_SHIRQ, "lcd", (void *)dev)) < 0) {
+                print_err("fail to request interrupt line %d (err: %d)",
+                          AU1200_LCD_INT, ret);
+                goto failed;
+        }
+
+        return 0;
+
+failed:
+        /* NOTE: This only does the current plane/window that failed; others are still active */
+        if (fbdev->fb_mem)
+                dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                                fbdev->fb_mem, fbdev->fb_phys);
+        if (fbdev->fb_info.cmap.len != 0)
+                fb_dealloc_cmap(&fbdev->fb_info.cmap);
+        if (fbdev->fb_info.pseudo_palette)
+                kfree(fbdev->fb_info.pseudo_palette);
+        if (plane == 0)
+                free_irq(AU1200_LCD_INT, (void*)dev);
+        return ret;
+}
+
+static int au1200fb_drv_remove(struct device *dev)
+{
+        struct au1200fb_device *fbdev;
+        int plane;
+
+        if (!dev)
+                return -ENODEV;
+
+        /* Turn off the panel */
+        au1200_setpanel(NULL);
+
+        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane)
+        {
+                fbdev = &_au1200fb_devices[plane];
+
+                /* Clean up all probe data */
+                unregister_framebuffer(&fbdev->fb_info);
+                if (fbdev->fb_mem)
+                        dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                                        fbdev->fb_mem, fbdev->fb_phys);
+                if (fbdev->fb_info.cmap.len != 0)
+                        fb_dealloc_cmap(&fbdev->fb_info.cmap);
+                if (fbdev->fb_info.pseudo_palette)
+                        kfree(fbdev->fb_info.pseudo_palette);
+        }
+
+        free_irq(AU1200_LCD_INT, (void *)dev);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int au1200fb_drv_suspend(struct device *dev, u32 state, u32 level)
+{
+        /* TODO */
+        return 0;
+}
+
+static int au1200fb_drv_resume(struct device *dev, u32 level)
+{
+        /* TODO */
+        return 0;
+}
+#endif /* CONFIG_PM */
+
+static struct device_driver au1200fb_driver = {
+        .name           = "au1200-lcd",
+        .bus            = &platform_bus_type,
+        .probe          = au1200fb_drv_probe,
+        .remove         = au1200fb_drv_remove,
+#ifdef CONFIG_PM
+        .suspend        = au1200fb_drv_suspend,
+        .resume         = au1200fb_drv_resume,
+#endif
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Kernel driver */
+
+static void au1200fb_setup(void)
+{
+        char* options = NULL;
+        char* this_opt;
+        int num_panels = ARRAY_SIZE(known_lcd_panels);
+        int panel_idx = -1;
+
+        fb_get_options(DRIVER_NAME, &options);
+
+        if (options) {
+                while ((this_opt = strsep(&options,",")) != NULL) {
+                        /* Panel option - can be panel name,
+                         * "bs" for board-switch, or number/index */
+                        if (!strncmp(this_opt, "panel:", 6)) {
+                                int i;
+                                long int li;
+                                char *endptr;
+                                this_opt += 6;
+                                /* First check for index, which allows
+                                 * to short circuit this mess */
+                                li = simple_strtol(this_opt, &endptr, 0);
+                                if (*endptr == '\0') {
+                                        panel_idx = (int)li;
+                                }
+                                else if (strcmp(this_opt, "bs") == 0) {
+                                        extern int board_au1200fb_panel(void);
+                                        panel_idx = board_au1200fb_panel();
+                                }
+
+                                else
+                                for (i = 0; i < num_panels; i++) {
+                                        if (!strcmp(this_opt, known_lcd_panels[i].name)) {
+                                                panel_idx = i;
+                                                break;
+                                        }
+                                }
+
+                                if ((panel_idx < 0) || (panel_idx >= num_panels)) {
+                                                print_warn("Panel %s not supported!", this_opt);
+                                }
+                                else
+                                        panel_index = panel_idx;
+                        }
+
+                        else if (strncmp(this_opt, "nohwcursor", 10) == 0) {
+                                nohwcursor = 1;
+                        }
+
+                        /* Unsupported option */
+                        else {
+                                print_warn("Unsupported option \"%s\"", this_opt);
+                        }
+                }
+        }
+}
+
+#ifdef CONFIG_PM
+static int au1200fb_pm_callback(au1xxx_power_dev_t *dev,
+                au1xxx_request_t request, void *data) {
+        int retval = -1;
+        unsigned int d = 0;
+        unsigned int brightness = 0;
+
+        if (request == AU1XXX_PM_SLEEP) {
+                board_au1200fb_panel_shutdown();
+        }
+        else if (request == AU1XXX_PM_WAKEUP) {
+                if(dev->prev_state == SLEEP_STATE)
+                {
+                        int plane;
+                        au1200_setpanel(panel);
+                        for (plane = 0; plane < CONFIG_FB_AU1200_DEVS; ++plane)         {
+                                struct au1200fb_device *fbdev;
+                                fbdev = &_au1200fb_devices[plane];
+                                au1200fb_fb_set_par(&fbdev->fb_info);
+                        }
+                }
+
+                d = *((unsigned int*)data);
+                if(d <=10) brightness = 26;
+                else if(d<=20) brightness = 51;
+                else if(d<=30) brightness = 77;
+                else if(d<=40) brightness = 102;
+                else if(d<=50) brightness = 128;
+                else if(d<=60) brightness = 153;
+                else if(d<=70) brightness = 179;
+                else if(d<=80) brightness = 204;
+                else if(d<=90) brightness = 230;
+                else brightness = 255;
+                set_brightness(brightness);
+        } else if (request == AU1XXX_PM_GETSTATUS) {
+                return dev->cur_state;
+        } else if (request == AU1XXX_PM_ACCESS) {
+                if (dev->cur_state != SLEEP_STATE)
+                        return retval;
+                else {
+                        au1200_setpanel(panel);
+                }
+        } else if (request == AU1XXX_PM_IDLE) {
+        } else if (request == AU1XXX_PM_CLEANUP) {
+        }
+
+        return retval;
+}
+#endif
+
+static int __init au1200fb_init(void)
+{
+        print_info("" DRIVER_DESC "");
+
+        /* Setup driver with options */
+        au1200fb_setup();
+
+        /* Point to the panel selected */
+        panel = &known_lcd_panels[panel_index];
+        win = &windows[window_index];
+
+        printk(DRIVER_NAME ": Panel %d %s\n", panel_index, panel->name);
+        printk(DRIVER_NAME ": Win %d %s\n", window_index, win->name);
+
+        /* Kickstart the panel, the framebuffers/windows come soon enough */
+        au1200_setpanel(panel);
+
+        #ifdef CONFIG_PM
+        LCD_pm_dev = new_au1xxx_power_device("LCD", &au1200fb_pm_callback, NULL);
+        if ( LCD_pm_dev == NULL)
+                printk(KERN_INFO "Unable to create a power management device entry for the au1200fb.\n");
+        else
+                printk(KERN_INFO "Power management device entry for the au1200fb loaded.\n");
+        #endif
+
+        return driver_register(&au1200fb_driver);
+}
+
+static void __exit au1200fb_cleanup(void)
+{
+        driver_unregister(&au1200fb_driver);
+}
+
+module_init(au1200fb_init);
+module_exit(au1200fb_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/au1200fb.h b/drivers/video/au1200fb.h
new file mode 100644
index 000000000000..e2672714d8d4
--- /dev/null
+++ b/drivers/video/au1200fb.h
@@ -0,0 +1,572 @@
+/*
+ * BRIEF MODULE DESCRIPTION
+ *      Hardware definitions for the Au1200 LCD controller
+ *
+ * Copyright 2004 AMD
+ * Author:      AMD
+ *
+ *  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  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  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 _AU1200LCD_H
+#define _AU1200LCD_H
+
+/********************************************************************/
+#define AU1200_LCD_ADDR         0xB5000000
+
+#define uint8 unsigned char
+#define uint32 unsigned int
+
+struct au1200_lcd {
+        volatile uint32 reserved0;
+        volatile uint32 screen;
+        volatile uint32 backcolor;
+        volatile uint32 horztiming;
+        volatile uint32 verttiming;
+        volatile uint32 clkcontrol;
+        volatile uint32 pwmdiv;
+        volatile uint32 pwmhi;
+        volatile uint32 reserved1;
+        volatile uint32 winenable;
+        volatile uint32 colorkey;
+        volatile uint32 colorkeymsk;
+        struct
+        {
+                volatile uint32 cursorctrl;
+                volatile uint32 cursorpos;
+                volatile uint32 cursorcolor0;
+                volatile uint32 cursorcolor1;
+                volatile uint32 cursorcolor2;
+                uint32  cursorcolor3;
+        } hwc;
+        volatile uint32 intstatus;
+        volatile uint32 intenable;
+        volatile uint32 outmask;
+        volatile uint32 fifoctrl;
+        uint32  reserved2[(0x0100-0x0058)/4];
+        struct
+        {
+                volatile uint32 winctrl0;
+                volatile uint32 winctrl1;
+                volatile uint32 winctrl2;
+                volatile uint32 winbuf0;
+                volatile uint32 winbuf1;
+                volatile uint32 winbufctrl;
+                uint32  winreserved0;
+                uint32  winreserved1;
+        } window[4];
+
+        uint32  reserved3[(0x0400-0x0180)/4];
+
+        volatile uint32 palette[(0x0800-0x0400)/4];
+
+        volatile uint8  cursorpattern[256];
+};
+
+/* lcd_screen */
+#define LCD_SCREEN_SEN          (1<<31)
+#define LCD_SCREEN_SX           (0x07FF<<19)
+#define LCD_SCREEN_SY           (0x07FF<< 8)
+#define LCD_SCREEN_SWP          (1<<7)
+#define LCD_SCREEN_SWD          (1<<6)
+#define LCD_SCREEN_PT           (7<<0)
+#define LCD_SCREEN_PT_TFT       (0<<0)
+#define LCD_SCREEN_SX_N(WIDTH)  ((WIDTH-1)<<19)
+#define LCD_SCREEN_SY_N(HEIGHT) ((HEIGHT-1)<<8)
+#define LCD_SCREEN_PT_CSTN      (1<<0)
+#define LCD_SCREEN_PT_CDSTN     (2<<0)
+#define LCD_SCREEN_PT_M8STN     (3<<0)
+#define LCD_SCREEN_PT_M4STN     (4<<0)
+
+/* lcd_backcolor */
+#define LCD_BACKCOLOR_SBGR              (0xFF<<16)
+#define LCD_BACKCOLOR_SBGG              (0xFF<<8)
+#define LCD_BACKCOLOR_SBGB              (0xFF<<0)
+#define LCD_BACKCOLOR_SBGR_N(N) ((N)<<16)
+#define LCD_BACKCOLOR_SBGG_N(N) ((N)<<8)
+#define LCD_BACKCOLOR_SBGB_N(N) ((N)<<0)
+
+/* lcd_winenable */
+#define LCD_WINENABLE_WEN3              (1<<3)
+#define LCD_WINENABLE_WEN2              (1<<2)
+#define LCD_WINENABLE_WEN1              (1<<1)
+#define LCD_WINENABLE_WEN0              (1<<0)
+
+/* lcd_colorkey */
+#define LCD_COLORKEY_CKR                (0xFF<<16)
+#define LCD_COLORKEY_CKG                (0xFF<<8)
+#define LCD_COLORKEY_CKB                (0xFF<<0)
+#define LCD_COLORKEY_CKR_N(N)   ((N)<<16)
+#define LCD_COLORKEY_CKG_N(N)   ((N)<<8)
+#define LCD_COLORKEY_CKB_N(N)   ((N)<<0)
+
+/* lcd_colorkeymsk */
+#define LCD_COLORKEYMSK_CKMR            (0xFF<<16)
+#define LCD_COLORKEYMSK_CKMG            (0xFF<<8)
+#define LCD_COLORKEYMSK_CKMB            (0xFF<<0)
+#define LCD_COLORKEYMSK_CKMR_N(N)       ((N)<<16)
+#define LCD_COLORKEYMSK_CKMG_N(N)       ((N)<<8)
+#define LCD_COLORKEYMSK_CKMB_N(N)       ((N)<<0)
+
+/* lcd windows control 0 */
+#define LCD_WINCTRL0_OX         (0x07FF<<21)
+#define LCD_WINCTRL0_OY         (0x07FF<<10)
+#define LCD_WINCTRL0_A          (0x00FF<<2)
+#define LCD_WINCTRL0_AEN        (1<<1)
+#define LCD_WINCTRL0_OX_N(N) ((N)<<21)
+#define LCD_WINCTRL0_OY_N(N) ((N)<<10)
+#define LCD_WINCTRL0_A_N(N) ((N)<<2)
+
+/* lcd windows control 1 */
+#define LCD_WINCTRL1_PRI        (3<<30)
+#define LCD_WINCTRL1_PIPE       (1<<29)
+#define LCD_WINCTRL1_FRM        (0xF<<25)
+#define LCD_WINCTRL1_CCO        (1<<24)
+#define LCD_WINCTRL1_PO         (3<<22)
+#define LCD_WINCTRL1_SZX        (0x07FF<<11)
+#define LCD_WINCTRL1_SZY        (0x07FF<<0)
+#define LCD_WINCTRL1_FRM_1BPP   (0<<25)
+#define LCD_WINCTRL1_FRM_2BPP   (1<<25)
+#define LCD_WINCTRL1_FRM_4BPP   (2<<25)
+#define LCD_WINCTRL1_FRM_8BPP   (3<<25)
+#define LCD_WINCTRL1_FRM_12BPP  (4<<25)
+#define LCD_WINCTRL1_FRM_16BPP655       (5<<25)
+#define LCD_WINCTRL1_FRM_16BPP565       (6<<25)
+#define LCD_WINCTRL1_FRM_16BPP556       (7<<25)
+#define LCD_WINCTRL1_FRM_16BPPI1555     (8<<25)
+#define LCD_WINCTRL1_FRM_16BPPI5551     (9<<25)
+#define LCD_WINCTRL1_FRM_16BPPA1555     (10<<25)
+#define LCD_WINCTRL1_FRM_16BPPA5551     (11<<25)
+#define LCD_WINCTRL1_FRM_24BPP          (12<<25)
+#define LCD_WINCTRL1_FRM_32BPP          (13<<25)
+#define LCD_WINCTRL1_PRI_N(N)   ((N)<<30)
+#define LCD_WINCTRL1_PO_00              (0<<22)
+#define LCD_WINCTRL1_PO_01              (1<<22)
+#define LCD_WINCTRL1_PO_10              (2<<22)
+#define LCD_WINCTRL1_PO_11              (3<<22)
+#define LCD_WINCTRL1_SZX_N(N)   ((N-1)<<11)
+#define LCD_WINCTRL1_SZY_N(N)   ((N-1)<<0)
+
+/* lcd windows control 2 */
+#define LCD_WINCTRL2_CKMODE             (3<<24)
+#define LCD_WINCTRL2_DBM                (1<<23)
+#define LCD_WINCTRL2_RAM                (3<<21)
+#define LCD_WINCTRL2_BX                 (0x1FFF<<8)
+#define LCD_WINCTRL2_SCX                (0xF<<4)
+#define LCD_WINCTRL2_SCY                (0xF<<0)
+#define LCD_WINCTRL2_CKMODE_00          (0<<24)
+#define LCD_WINCTRL2_CKMODE_01          (1<<24)
+#define LCD_WINCTRL2_CKMODE_10          (2<<24)
+#define LCD_WINCTRL2_CKMODE_11          (3<<24)
+#define LCD_WINCTRL2_RAM_NONE           (0<<21)
+#define LCD_WINCTRL2_RAM_PALETTE        (1<<21)
+#define LCD_WINCTRL2_RAM_GAMMA          (2<<21)
+#define LCD_WINCTRL2_RAM_BUFFER         (3<<21)
+#define LCD_WINCTRL2_BX_N(N)    ((N)<<8)
+#define LCD_WINCTRL2_SCX_1              (0<<4)
+#define LCD_WINCTRL2_SCX_2              (1<<4)
+#define LCD_WINCTRL2_SCX_4              (2<<4)
+#define LCD_WINCTRL2_SCY_1              (0<<0)
+#define LCD_WINCTRL2_SCY_2              (1<<0)
+#define LCD_WINCTRL2_SCY_4              (2<<0)
+
+/* lcd windows buffer control */
+#define LCD_WINBUFCTRL_DB               (1<<1)
+#define LCD_WINBUFCTRL_DBN              (1<<0)
+
+/* lcd_intstatus, lcd_intenable */
+#define LCD_INT_IFO                             (0xF<<14)
+#define LCD_INT_IFU                             (0xF<<10)
+#define LCD_INT_OFO                             (1<<9)
+#define LCD_INT_OFU                             (1<<8)
+#define LCD_INT_WAIT                    (1<<3)
+#define LCD_INT_SD                              (1<<2)
+#define LCD_INT_SA                              (1<<1)
+#define LCD_INT_SS                              (1<<0)
+
+/* lcd_horztiming */
+#define LCD_HORZTIMING_HND2             (0x1FF<<18)
+#define LCD_HORZTIMING_HND1             (0x1FF<<9)
+#define LCD_HORZTIMING_HPW              (0x1FF<<0)
+#define LCD_HORZTIMING_HND2_N(N)(((N)-1)<<18)
+#define LCD_HORZTIMING_HND1_N(N)(((N)-1)<<9)
+#define LCD_HORZTIMING_HPW_N(N) (((N)-1)<<0)
+
+/* lcd_verttiming */
+#define LCD_VERTTIMING_VND2             (0x1FF<<18)
+#define LCD_VERTTIMING_VND1             (0x1FF<<9)
+#define LCD_VERTTIMING_VPW              (0x1FF<<0)
+#define LCD_VERTTIMING_VND2_N(N)(((N)-1)<<18)
+#define LCD_VERTTIMING_VND1_N(N)(((N)-1)<<9)
+#define LCD_VERTTIMING_VPW_N(N) (((N)-1)<<0)
+
+/* lcd_clkcontrol */
+#define LCD_CLKCONTROL_EXT              (1<<22)
+#define LCD_CLKCONTROL_DELAY    (3<<20)
+#define LCD_CLKCONTROL_CDD              (1<<19)
+#define LCD_CLKCONTROL_IB               (1<<18)
+#define LCD_CLKCONTROL_IC               (1<<17)
+#define LCD_CLKCONTROL_IH               (1<<16)
+#define LCD_CLKCONTROL_IV               (1<<15)
+#define LCD_CLKCONTROL_BF               (0x1F<<10)
+#define LCD_CLKCONTROL_PCD              (0x3FF<<0)
+#define LCD_CLKCONTROL_BF_N(N)  (((N)-1)<<10)
+#define LCD_CLKCONTROL_PCD_N(N) ((N)<<0)
+
+/* lcd_pwmdiv */
+#define LCD_PWMDIV_EN                   (1<<31)
+#define LCD_PWMDIV_PWMDIV               (0x1FFFF<<0)
+#define LCD_PWMDIV_PWMDIV_N(N)  ((N)<<0)
+
+/* lcd_pwmhi */
+#define LCD_PWMHI_PWMHI1                (0xFFFF<<16)
+#define LCD_PWMHI_PWMHI0                (0xFFFF<<0)
+#define LCD_PWMHI_PWMHI1_N(N)   ((N)<<16)
+#define LCD_PWMHI_PWMHI0_N(N)   ((N)<<0)
+
+/* lcd_hwccon */
+#define LCD_HWCCON_EN                   (1<<0)
+
+/* lcd_cursorpos */
+#define LCD_CURSORPOS_HWCXOFF           (0x1F<<27)
+#define LCD_CURSORPOS_HWCXPOS           (0x07FF<<16)
+#define LCD_CURSORPOS_HWCYOFF           (0x1F<<11)
+#define LCD_CURSORPOS_HWCYPOS           (0x07FF<<0)
+#define LCD_CURSORPOS_HWCXOFF_N(N)      ((N)<<27)
+#define LCD_CURSORPOS_HWCXPOS_N(N)      ((N)<<16)
+#define LCD_CURSORPOS_HWCYOFF_N(N)      ((N)<<11)
+#define LCD_CURSORPOS_HWCYPOS_N(N)      ((N)<<0)
+
+/* lcd_cursorcolor */
+#define LCD_CURSORCOLOR_HWCA            (0xFF<<24)
+#define LCD_CURSORCOLOR_HWCR            (0xFF<<16)
+#define LCD_CURSORCOLOR_HWCG            (0xFF<<8)
+#define LCD_CURSORCOLOR_HWCB            (0xFF<<0)
+#define LCD_CURSORCOLOR_HWCA_N(N)       ((N)<<24)
+#define LCD_CURSORCOLOR_HWCR_N(N)       ((N)<<16)
+#define LCD_CURSORCOLOR_HWCG_N(N)       ((N)<<8)
+#define LCD_CURSORCOLOR_HWCB_N(N)       ((N)<<0)
+
+/* lcd_fifoctrl */
+#define LCD_FIFOCTRL_F3IF               (1<<29)
+#define LCD_FIFOCTRL_F3REQ              (0x1F<<24)
+#define LCD_FIFOCTRL_F2IF               (1<<29)
+#define LCD_FIFOCTRL_F2REQ              (0x1F<<16)
+#define LCD_FIFOCTRL_F1IF               (1<<29)
+#define LCD_FIFOCTRL_F1REQ              (0x1F<<8)
+#define LCD_FIFOCTRL_F0IF               (1<<29)
+#define LCD_FIFOCTRL_F0REQ              (0x1F<<0)
+#define LCD_FIFOCTRL_F3REQ_N(N) ((N-1)<<24)
+#define LCD_FIFOCTRL_F2REQ_N(N) ((N-1)<<16)
+#define LCD_FIFOCTRL_F1REQ_N(N) ((N-1)<<8)
+#define LCD_FIFOCTRL_F0REQ_N(N) ((N-1)<<0)
+
+/* lcd_outmask */
+#define LCD_OUTMASK_MASK                (0x00FFFFFF)
+
+/********************************************************************/
+#endif /* _AU1200LCD_H */
+/*
+ * BRIEF MODULE DESCRIPTION
+ *      Hardware definitions for the Au1200 LCD controller
+ *
+ * Copyright 2004 AMD
+ * Author:      AMD
+ *
+ *  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  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
+ *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
+ *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  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 _AU1200LCD_H
+#define _AU1200LCD_H
+
+/********************************************************************/
+#define AU1200_LCD_ADDR         0xB5000000
+
+#define uint8 unsigned char
+#define uint32 unsigned int
+
+struct au1200_lcd {
+        volatile uint32 reserved0;
+        volatile uint32 screen;
+        volatile uint32 backcolor;
+        volatile uint32 horztiming;
+        volatile uint32 verttiming;
+        volatile uint32 clkcontrol;
+        volatile uint32 pwmdiv;
+        volatile uint32 pwmhi;
+        volatile uint32 reserved1;
+        volatile uint32 winenable;
+        volatile uint32 colorkey;
+        volatile uint32 colorkeymsk;
+        struct
+        {
+                volatile uint32 cursorctrl;
+                volatile uint32 cursorpos;
+                volatile uint32 cursorcolor0;
+                volatile uint32 cursorcolor1;
+                volatile uint32 cursorcolor2;
+                uint32  cursorcolor3;
+        } hwc;
+        volatile uint32 intstatus;
+        volatile uint32 intenable;
+        volatile uint32 outmask;
+        volatile uint32 fifoctrl;
+        uint32  reserved2[(0x0100-0x0058)/4];
+        struct
+        {
+                volatile uint32 winctrl0;
+                volatile uint32 winctrl1;
+                volatile uint32 winctrl2;
+                volatile uint32 winbuf0;
+                volatile uint32 winbuf1;
+                volatile uint32 winbufctrl;
+                uint32  winreserved0;
+                uint32  winreserved1;
+        } window[4];
+
+        uint32  reserved3[(0x0400-0x0180)/4];
+
+        volatile uint32 palette[(0x0800-0x0400)/4];
+
+        volatile uint8  cursorpattern[256];
+};
+
+/* lcd_screen */
+#define LCD_SCREEN_SEN          (1<<31)
+#define LCD_SCREEN_SX           (0x07FF<<19)
+#define LCD_SCREEN_SY           (0x07FF<< 8)
+#define LCD_SCREEN_SWP          (1<<7)
+#define LCD_SCREEN_SWD          (1<<6)
+#define LCD_SCREEN_PT           (7<<0)
+#define LCD_SCREEN_PT_TFT       (0<<0)
+#define LCD_SCREEN_SX_N(WIDTH)  ((WIDTH-1)<<19)
+#define LCD_SCREEN_SY_N(HEIGHT) ((HEIGHT-1)<<8)
+#define LCD_SCREEN_PT_CSTN      (1<<0)
+#define LCD_SCREEN_PT_CDSTN     (2<<0)
+#define LCD_SCREEN_PT_M8STN     (3<<0)
+#define LCD_SCREEN_PT_M4STN     (4<<0)
+
+/* lcd_backcolor */
+#define LCD_BACKCOLOR_SBGR              (0xFF<<16)
+#define LCD_BACKCOLOR_SBGG              (0xFF<<8)
+#define LCD_BACKCOLOR_SBGB              (0xFF<<0)
+#define LCD_BACKCOLOR_SBGR_N(N) ((N)<<16)
+#define LCD_BACKCOLOR_SBGG_N(N) ((N)<<8)
+#define LCD_BACKCOLOR_SBGB_N(N) ((N)<<0)
+
+/* lcd_winenable */
+#define LCD_WINENABLE_WEN3              (1<<3)
+#define LCD_WINENABLE_WEN2              (1<<2)
+#define LCD_WINENABLE_WEN1              (1<<1)
+#define LCD_WINENABLE_WEN0              (1<<0)
+
+/* lcd_colorkey */
+#define LCD_COLORKEY_CKR                (0xFF<<16)
+#define LCD_COLORKEY_CKG                (0xFF<<8)
+#define LCD_COLORKEY_CKB                (0xFF<<0)
+#define LCD_COLORKEY_CKR_N(N)   ((N)<<16)
+#define LCD_COLORKEY_CKG_N(N)   ((N)<<8)
+#define LCD_COLORKEY_CKB_N(N)   ((N)<<0)
+
+/* lcd_colorkeymsk */
+#define LCD_COLORKEYMSK_CKMR            (0xFF<<16)
+#define LCD_COLORKEYMSK_CKMG            (0xFF<<8)
+#define LCD_COLORKEYMSK_CKMB            (0xFF<<0)
+#define LCD_COLORKEYMSK_CKMR_N(N)       ((N)<<16)
+#define LCD_COLORKEYMSK_CKMG_N(N)       ((N)<<8)
+#define LCD_COLORKEYMSK_CKMB_N(N)       ((N)<<0)
+
+/* lcd windows control 0 */
+#define LCD_WINCTRL0_OX         (0x07FF<<21)
+#define LCD_WINCTRL0_OY         (0x07FF<<10)
+#define LCD_WINCTRL0_A          (0x00FF<<2)
+#define LCD_WINCTRL0_AEN        (1<<1)
+#define LCD_WINCTRL0_OX_N(N) ((N)<<21)
+#define LCD_WINCTRL0_OY_N(N) ((N)<<10)
+#define LCD_WINCTRL0_A_N(N) ((N)<<2)
+
+/* lcd windows control 1 */
+#define LCD_WINCTRL1_PRI        (3<<30)
+#define LCD_WINCTRL1_PIPE       (1<<29)
+#define LCD_WINCTRL1_FRM        (0xF<<25)
+#define LCD_WINCTRL1_CCO        (1<<24)
+#define LCD_WINCTRL1_PO         (3<<22)
+#define LCD_WINCTRL1_SZX        (0x07FF<<11)
+#define LCD_WINCTRL1_SZY        (0x07FF<<0)
+#define LCD_WINCTRL1_FRM_1BPP   (0<<25)
+#define LCD_WINCTRL1_FRM_2BPP   (1<<25)
+#define LCD_WINCTRL1_FRM_4BPP   (2<<25)
+#define LCD_WINCTRL1_FRM_8BPP   (3<<25)
+#define LCD_WINCTRL1_FRM_12BPP  (4<<25)
+#define LCD_WINCTRL1_FRM_16BPP655       (5<<25)
+#define LCD_WINCTRL1_FRM_16BPP565       (6<<25)
+#define LCD_WINCTRL1_FRM_16BPP556       (7<<25)
+#define LCD_WINCTRL1_FRM_16BPPI1555     (8<<25)
+#define LCD_WINCTRL1_FRM_16BPPI5551     (9<<25)
+#define LCD_WINCTRL1_FRM_16BPPA1555     (10<<25)
+#define LCD_WINCTRL1_FRM_16BPPA5551     (11<<25)
+#define LCD_WINCTRL1_FRM_24BPP          (12<<25)
+#define LCD_WINCTRL1_FRM_32BPP          (13<<25)
+#define LCD_WINCTRL1_PRI_N(N)   ((N)<<30)
+#define LCD_WINCTRL1_PO_00              (0<<22)
+#define LCD_WINCTRL1_PO_01              (1<<22)
+#define LCD_WINCTRL1_PO_10              (2<<22)
+#define LCD_WINCTRL1_PO_11              (3<<22)
+#define LCD_WINCTRL1_SZX_N(N)   ((N-1)<<11)
+#define LCD_WINCTRL1_SZY_N(N)   ((N-1)<<0)
+
+/* lcd windows control 2 */
+#define LCD_WINCTRL2_CKMODE             (3<<24)
+#define LCD_WINCTRL2_DBM                (1<<23)
+#define LCD_WINCTRL2_RAM                (3<<21)
+#define LCD_WINCTRL2_BX                 (0x1FFF<<8)
+#define LCD_WINCTRL2_SCX                (0xF<<4)
+#define LCD_WINCTRL2_SCY                (0xF<<0)
+#define LCD_WINCTRL2_CKMODE_00          (0<<24)
+#define LCD_WINCTRL2_CKMODE_01          (1<<24)
+#define LCD_WINCTRL2_CKMODE_10          (2<<24)
+#define LCD_WINCTRL2_CKMODE_11          (3<<24)
+#define LCD_WINCTRL2_RAM_NONE           (0<<21)
+#define LCD_WINCTRL2_RAM_PALETTE        (1<<21)
+#define LCD_WINCTRL2_RAM_GAMMA          (2<<21)
+#define LCD_WINCTRL2_RAM_BUFFER         (3<<21)
+#define LCD_WINCTRL2_BX_N(N)    ((N)<<8)
+#define LCD_WINCTRL2_SCX_1              (0<<4)
+#define LCD_WINCTRL2_SCX_2              (1<<4)
+#define LCD_WINCTRL2_SCX_4              (2<<4)
+#define LCD_WINCTRL2_SCY_1              (0<<0)
+#define LCD_WINCTRL2_SCY_2              (1<<0)
+#define LCD_WINCTRL2_SCY_4              (2<<0)
+
+/* lcd windows buffer control */
+#define LCD_WINBUFCTRL_DB               (1<<1)
+#define LCD_WINBUFCTRL_DBN              (1<<0)
+
+/* lcd_intstatus, lcd_intenable */
+#define LCD_INT_IFO                             (0xF<<14)
+#define LCD_INT_IFU                             (0xF<<10)
+#define LCD_INT_OFO                             (1<<9)
+#define LCD_INT_OFU                             (1<<8)
+#define LCD_INT_WAIT                    (1<<3)
+#define LCD_INT_SD                              (1<<2)
+#define LCD_INT_SA                              (1<<1)
+#define LCD_INT_SS                              (1<<0)
+
+/* lcd_horztiming */
+#define LCD_HORZTIMING_HND2             (0x1FF<<18)
+#define LCD_HORZTIMING_HND1             (0x1FF<<9)
+#define LCD_HORZTIMING_HPW              (0x1FF<<0)
+#define LCD_HORZTIMING_HND2_N(N)(((N)-1)<<18)
+#define LCD_HORZTIMING_HND1_N(N)(((N)-1)<<9)
+#define LCD_HORZTIMING_HPW_N(N) (((N)-1)<<0)
+
+/* lcd_verttiming */
+#define LCD_VERTTIMING_VND2             (0x1FF<<18)
+#define LCD_VERTTIMING_VND1             (0x1FF<<9)
+#define LCD_VERTTIMING_VPW              (0x1FF<<0)
+#define LCD_VERTTIMING_VND2_N(N)(((N)-1)<<18)
+#define LCD_VERTTIMING_VND1_N(N)(((N)-1)<<9)
+#define LCD_VERTTIMING_VPW_N(N) (((N)-1)<<0)
+
+/* lcd_clkcontrol */
+#define LCD_CLKCONTROL_EXT              (1<<22)
+#define LCD_CLKCONTROL_DELAY    (3<<20)
+#define LCD_CLKCONTROL_CDD              (1<<19)
+#define LCD_CLKCONTROL_IB               (1<<18)
+#define LCD_CLKCONTROL_IC               (1<<17)
+#define LCD_CLKCONTROL_IH               (1<<16)
+#define LCD_CLKCONTROL_IV               (1<<15)
+#define LCD_CLKCONTROL_BF               (0x1F<<10)
+#define LCD_CLKCONTROL_PCD              (0x3FF<<0)
+#define LCD_CLKCONTROL_BF_N(N)  (((N)-1)<<10)
+#define LCD_CLKCONTROL_PCD_N(N) ((N)<<0)
+
+/* lcd_pwmdiv */
+#define LCD_PWMDIV_EN                   (1<<31)
+#define LCD_PWMDIV_PWMDIV               (0x1FFFF<<0)
+#define LCD_PWMDIV_PWMDIV_N(N)  ((N)<<0)
+
+/* lcd_pwmhi */
+#define LCD_PWMHI_PWMHI1                (0xFFFF<<16)
+#define LCD_PWMHI_PWMHI0                (0xFFFF<<0)
+#define LCD_PWMHI_PWMHI1_N(N)   ((N)<<16)
+#define LCD_PWMHI_PWMHI0_N(N)   ((N)<<0)
+
+/* lcd_hwccon */
+#define LCD_HWCCON_EN                   (1<<0)
+
+/* lcd_cursorpos */
+#define LCD_CURSORPOS_HWCXOFF           (0x1F<<27)
+#define LCD_CURSORPOS_HWCXPOS           (0x07FF<<16)
+#define LCD_CURSORPOS_HWCYOFF           (0x1F<<11)
+#define LCD_CURSORPOS_HWCYPOS           (0x07FF<<0)
+#define LCD_CURSORPOS_HWCXOFF_N(N)      ((N)<<27)
+#define LCD_CURSORPOS_HWCXPOS_N(N)      ((N)<<16)
+#define LCD_CURSORPOS_HWCYOFF_N(N)      ((N)<<11)
+#define LCD_CURSORPOS_HWCYPOS_N(N)      ((N)<<0)
+
+/* lcd_cursorcolor */
+#define LCD_CURSORCOLOR_HWCA            (0xFF<<24)
+#define LCD_CURSORCOLOR_HWCR            (0xFF<<16)
+#define LCD_CURSORCOLOR_HWCG            (0xFF<<8)
+#define LCD_CURSORCOLOR_HWCB            (0xFF<<0)
+#define LCD_CURSORCOLOR_HWCA_N(N)       ((N)<<24)
+#define LCD_CURSORCOLOR_HWCR_N(N)       ((N)<<16)
+#define LCD_CURSORCOLOR_HWCG_N(N)       ((N)<<8)
+#define LCD_CURSORCOLOR_HWCB_N(N)       ((N)<<0)
+
+/* lcd_fifoctrl */
+#define LCD_FIFOCTRL_F3IF               (1<<29)
+#define LCD_FIFOCTRL_F3REQ              (0x1F<<24)
+#define LCD_FIFOCTRL_F2IF               (1<<29)
+#define LCD_FIFOCTRL_F2REQ              (0x1F<<16)
+#define LCD_FIFOCTRL_F1IF               (1<<29)
+#define LCD_FIFOCTRL_F1REQ              (0x1F<<8)
+#define LCD_FIFOCTRL_F0IF               (1<<29)
+#define LCD_FIFOCTRL_F0REQ              (0x1F<<0)
+#define LCD_FIFOCTRL_F3REQ_N(N) ((N-1)<<24)
+#define LCD_FIFOCTRL_F2REQ_N(N) ((N-1)<<16)
+#define LCD_FIFOCTRL_F1REQ_N(N) ((N-1)<<8)
+#define LCD_FIFOCTRL_F0REQ_N(N) ((N-1)<<0)
+
+/* lcd_outmask */
+#define LCD_OUTMASK_MASK                (0x00FFFFFF)
+
+/********************************************************************/
+#endif /* _AU1200LCD_H */
diff --git a/drivers/video/chipsfb.c b/drivers/video/chipsfb.c
index bc061d4ec786..72ff6bf75e5e 100644
--- a/drivers/video/chipsfb.c
+++ b/drivers/video/chipsfb.c
@@ -178,8 +178,6 @@ struct chips_init_reg {
         unsigned char data;
 };
 
-#define N_ELTS(x)       (sizeof(x) / sizeof(x[0]))
-
 static struct chips_init_reg chips_init_sr[] = {
         { 0x00, 0x03 },
         { 0x01, 0x01 },
@@ -287,18 +285,18 @@ static void __init chips_hw_init(void)
 {
         int i;
 
-        for (i = 0; i < N_ELTS(chips_init_xr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_xr); ++i)
                 write_xr(chips_init_xr[i].addr, chips_init_xr[i].data);
         outb(0x29, 0x3c2); /* set misc output reg */
-        for (i = 0; i < N_ELTS(chips_init_sr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_sr); ++i)
                 write_sr(chips_init_sr[i].addr, chips_init_sr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_gr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_gr); ++i)
                 write_gr(chips_init_gr[i].addr, chips_init_gr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_ar); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_ar); ++i)
                 write_ar(chips_init_ar[i].addr, chips_init_ar[i].data);
-        for (i = 0; i < N_ELTS(chips_init_cr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_cr); ++i)
                 write_cr(chips_init_cr[i].addr, chips_init_cr[i].data);
-        for (i = 0; i < N_ELTS(chips_init_fr); ++i)
+        for (i = 0; i < ARRAY_SIZE(chips_init_fr); ++i)
                 write_fr(chips_init_fr[i].addr, chips_init_fr[i].data);
 }
 
diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
index 6ee449858a5c..4444bef68fba 100644
--- a/drivers/video/console/Kconfig
+++ b/drivers/video/console/Kconfig
@@ -26,6 +26,30 @@ config VGA_CONSOLE
 #          fi
 #       fi
 
+config VGACON_SOFT_SCROLLBACK
+       bool "Enable Scrollback Buffer in System RAM"
+       depends on VGA_CONSOLE
+       default n
+       help
+         The scrollback buffer of the standard VGA console is located in
+         the VGA RAM.  The size of this RAM is fixed and is quite small.
+         If you require a larger scrollback buffer, this can be placed in
+         System RAM which is dynamically allocated during intialization.
+         Placing the scrollback buffer in System RAM will slightly slow
+         down the console.
+
+         If you want this feature, say 'Y' here and enter the amount of
+         RAM to allocate for this buffer.  If unsure, say 'N'.
+
+config VGACON_SOFT_SCROLLBACK_SIZE
+       int "Scrollback Buffer Size (in KB)"
+       depends on VGACON_SOFT_SCROLLBACK
+       default "64"
+       help
+         Enter the amount of System RAM to allocate for the scrollback
+         buffer.  Each 64KB will give you approximately 16 80x25
+         screenfuls of scrollback buffer
+
 config VIDEO_SELECT
         bool "Video mode selection support"
         depends on  X86 && VGA_CONSOLE
diff --git a/drivers/video/console/fonts.c b/drivers/video/console/fonts.c
index 4fd07d9eca03..0cc1bfda76a6 100644
--- a/drivers/video/console/fonts.c
+++ b/drivers/video/console/fonts.c
@@ -66,7 +66,7 @@ static const struct font_desc *fonts[] = {
 #endif
 };
 
-#define num_fonts (sizeof(fonts)/sizeof(*fonts))
+#define num_fonts ARRAY_SIZE(fonts)
 
 #ifdef NO_FONTS
 #error No fonts configured.
diff --git a/drivers/video/console/newport_con.c b/drivers/video/console/newport_con.c
index 762c7a593141..e99fe30e568c 100644
--- a/drivers/video/console/newport_con.c
+++ b/drivers/video/console/newport_con.c
@@ -149,7 +149,7 @@ static inline void newport_clear_lines(int ystart, int yend, int ci)
         newport_clear_screen(0, ystart, 1280 + 63, yend, ci);
 }
 
-void newport_reset(void)
+static void newport_reset(void)
 {
         unsigned short treg;
         int i;
@@ -193,7 +193,7 @@ void newport_reset(void)
  * calculate the actual screen size by reading
  * the video timing out of the VC2
  */
-void newport_get_screensize(void)
+static void newport_get_screensize(void)
 {
         int i, cols;
         unsigned short ventry, treg;
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 5a86978537d2..d5a04b68c4d4 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -93,7 +93,6 @@ static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
 static unsigned long vgacon_uni_pagedir[2];
 
-
 /* Description of the hardware situation */
 static unsigned long    vga_vram_base;          /* Base of video memory */
 static unsigned long    vga_vram_end;           /* End of video memory */
@@ -161,6 +160,201 @@ static inline void write_vga(unsigned char reg, unsigned int val)
         spin_unlock_irqrestore(&vga_lock, flags);
 }
 
+static inline void vga_set_mem_top(struct vc_data *c)
+{
+        write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
+}
+
+#ifdef CONFIG_VGACON_SOFT_SCROLLBACK
+#include <linux/bootmem.h>
+/* software scrollback */
+static void *vgacon_scrollback;
+static int vgacon_scrollback_tail;
+static int vgacon_scrollback_size;
+static int vgacon_scrollback_rows;
+static int vgacon_scrollback_cnt;
+static int vgacon_scrollback_cur;
+static int vgacon_scrollback_save;
+static int vgacon_scrollback_restore;
+
+static void vgacon_scrollback_init(int pitch)
+{
+        int rows = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024/pitch;
+
+        if (vgacon_scrollback) {
+                vgacon_scrollback_cnt  = 0;
+                vgacon_scrollback_tail = 0;
+                vgacon_scrollback_cur  = 0;
+                vgacon_scrollback_rows = rows - 1;
+                vgacon_scrollback_size = rows * pitch;
+        }
+}
+
+static void __init vgacon_scrollback_startup(void)
+{
+        vgacon_scrollback = alloc_bootmem(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
+                                          * 1024);
+        vgacon_scrollback_init(vga_video_num_columns * 2);
+}
+
+static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
+{
+        void *p;
+
+        if (!vgacon_scrollback_size || c->vc_num != fg_console)
+                return;
+
+        p = (void *) (c->vc_origin + t * c->vc_size_row);
+
+        while (count--) {
+                scr_memcpyw(vgacon_scrollback + vgacon_scrollback_tail,
+                            p, c->vc_size_row);
+                vgacon_scrollback_cnt++;
+                p += c->vc_size_row;
+                vgacon_scrollback_tail += c->vc_size_row;
+
+                if (vgacon_scrollback_tail >= vgacon_scrollback_size)
+                        vgacon_scrollback_tail = 0;
+
+                if (vgacon_scrollback_cnt > vgacon_scrollback_rows)
+                        vgacon_scrollback_cnt = vgacon_scrollback_rows;
+
+                vgacon_scrollback_cur = vgacon_scrollback_cnt;
+        }
+}
+
+static void vgacon_restore_screen(struct vc_data *c)
+{
+        vgacon_scrollback_save = 0;
+
+        if (!vga_is_gfx && !vgacon_scrollback_restore) {
+                scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
+                            c->vc_screenbuf_size > vga_vram_size ?
+                            vga_vram_size : c->vc_screenbuf_size);
+                vgacon_scrollback_restore = 1;
+                vgacon_scrollback_cur = vgacon_scrollback_cnt;
+        }
+}
+
+static int vgacon_scrolldelta(struct vc_data *c, int lines)
+{
+        int start, end, count, soff, diff;
+        void *d, *s;
+
+        if (!lines) {
+                c->vc_visible_origin = c->vc_origin;
+                vga_set_mem_top(c);
+                return 1;
+        }
+
+        if (!vgacon_scrollback)
+                return 1;
+
+        if (!vgacon_scrollback_save) {
+                vgacon_cursor(c, CM_ERASE);
+                vgacon_save_screen(c);
+                vgacon_scrollback_save = 1;
+        }
+
+        vgacon_scrollback_restore = 0;
+        start = vgacon_scrollback_cur + lines;
+        end = start + abs(lines);
+
+        if (start < 0)
+                start = 0;
+
+        if (start > vgacon_scrollback_cnt)
+                start = vgacon_scrollback_cnt;
+
+        if (end < 0)
+                end = 0;
+
+        if (end > vgacon_scrollback_cnt)
+                end = vgacon_scrollback_cnt;
+
+        vgacon_scrollback_cur = start;
+        count = end - start;
+        soff = vgacon_scrollback_tail - ((vgacon_scrollback_cnt - end) *
+                                         c->vc_size_row);
+        soff -= count * c->vc_size_row;
+
+        if (soff < 0)
+                soff += vgacon_scrollback_size;
+
+        count = vgacon_scrollback_cnt - start;
+
+        if (count > c->vc_rows)
+                count = c->vc_rows;
+
+        diff = c->vc_rows - count;
+
+        d = (void *) c->vc_origin;
+        s = (void *) c->vc_screenbuf;
+
+        while (count--) {
+                scr_memcpyw(d, vgacon_scrollback + soff, c->vc_size_row);
+                d += c->vc_size_row;
+                soff += c->vc_size_row;
+
+                if (soff >= vgacon_scrollback_size)
+                        soff = 0;
+        }
+
+        if (diff == c->vc_rows) {
+                vgacon_cursor(c, CM_MOVE);
+        } else {
+                while (diff--) {
+                        scr_memcpyw(d, s, c->vc_size_row);
+                        d += c->vc_size_row;
+                        s += c->vc_size_row;
+                }
+        }
+
+        return 1;
+}
+#else
+#define vgacon_scrollback_startup(...) do { } while (0)
+#define vgacon_scrollback_init(...)    do { } while (0)
+#define vgacon_scrollback_update(...)  do { } while (0)
+
+static void vgacon_restore_screen(struct vc_data *c)
+{
+        if (c->vc_origin != c->vc_visible_origin)
+                vgacon_scrolldelta(c, 0);
+}
+
+static int vgacon_scrolldelta(struct vc_data *c, int lines)
+{
+        if (!lines)             /* Turn scrollback off */
+                c->vc_visible_origin = c->vc_origin;
+        else {
+                int margin = c->vc_size_row * 4;
+                int ul, we, p, st;
+
+                if (vga_rolled_over >
+                    (c->vc_scr_end - vga_vram_base) + margin) {
+                        ul = c->vc_scr_end - vga_vram_base;
+                        we = vga_rolled_over + c->vc_size_row;
+                } else {
+                        ul = 0;
+                        we = vga_vram_size;
+                }
+                p = (c->vc_visible_origin - vga_vram_base - ul + we) % we +
+                    lines * c->vc_size_row;
+                st = (c->vc_origin - vga_vram_base - ul + we) % we;
+                if (st < 2 * margin)
+                        margin = 0;
+                if (p < margin)
+                        p = 0;
+                if (p > st - margin)
+                        p = st;
+                c->vc_visible_origin = vga_vram_base + (p + ul) % we;
+        }
+        vga_set_mem_top(c);
+        return 1;
+}
+#endif /* CONFIG_VGACON_SOFT_SCROLLBACK */
+
 static const char __init *vgacon_startup(void)
 {
         const char *display_desc = NULL;
@@ -330,7 +524,7 @@ static const char __init *vgacon_startup(void)
 
         vgacon_xres = ORIG_VIDEO_COLS * VGA_FONTWIDTH;
         vgacon_yres = vga_scan_lines;
-
+        vgacon_scrollback_startup();
         return display_desc;
 }
 
@@ -357,11 +551,6 @@ static void vgacon_init(struct vc_data *c, int init)
                 con_set_default_unimap(c);
 }
 
-static inline void vga_set_mem_top(struct vc_data *c)
-{
-        write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
-}
-
 static void vgacon_deinit(struct vc_data *c)
 {
         /* When closing the last console, reset video origin */
@@ -433,29 +622,37 @@ static void vgacon_set_cursor_size(int xpos, int from, int to)
         cursor_size_lastto = to;
 
         spin_lock_irqsave(&vga_lock, flags);
-        outb_p(0x0a, vga_video_port_reg);       /* Cursor start */
-        curs = inb_p(vga_video_port_val);
-        outb_p(0x0b, vga_video_port_reg);       /* Cursor end */
-        cure = inb_p(vga_video_port_val);
+        if (vga_video_type >= VIDEO_TYPE_VGAC) {
+                outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
+                curs = inb_p(vga_video_port_val);
+                outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
+                cure = inb_p(vga_video_port_val);
+        } else {
+                curs = 0;
+                cure = 0;
+        }
 
         curs = (curs & 0xc0) | from;
         cure = (cure & 0xe0) | to;
 
-        outb_p(0x0a, vga_video_port_reg);       /* Cursor start */
+        outb_p(VGA_CRTC_CURSOR_START, vga_video_port_reg);
         outb_p(curs, vga_video_port_val);
-        outb_p(0x0b, vga_video_port_reg);       /* Cursor end */
+        outb_p(VGA_CRTC_CURSOR_END, vga_video_port_reg);
         outb_p(cure, vga_video_port_val);
         spin_unlock_irqrestore(&vga_lock, flags);
 }
 
 static void vgacon_cursor(struct vc_data *c, int mode)
 {
-        if (c->vc_origin != c->vc_visible_origin)
-                vgacon_scrolldelta(c, 0);
+        vgacon_restore_screen(c);
+
         switch (mode) {
         case CM_ERASE:
                 write_vga(14, (c->vc_pos - vga_vram_base) / 2);
-                vgacon_set_cursor_size(c->vc_x, 31, 30);
+                if (vga_video_type >= VIDEO_TYPE_VGAC)
+                        vgacon_set_cursor_size(c->vc_x, 31, 30);
+                else
+                        vgacon_set_cursor_size(c->vc_x, 31, 31);
                 break;
 
         case CM_MOVE:
@@ -493,7 +690,10 @@ static void vgacon_cursor(struct vc_data *c, int mode)
                                                 10 ? 1 : 2));
                         break;
                 case CUR_NONE:
-                        vgacon_set_cursor_size(c->vc_x, 31, 30);
+                        if (vga_video_type >= VIDEO_TYPE_VGAC)
+                                vgacon_set_cursor_size(c->vc_x, 31, 30);
+                        else
+                                vgacon_set_cursor_size(c->vc_x, 31, 31);
                         break;
                 default:
                         vgacon_set_cursor_size(c->vc_x, 1,
@@ -595,6 +795,7 @@ static int vgacon_switch(struct vc_data *c)
                         vgacon_doresize(c, c->vc_cols, c->vc_rows);
         }
 
+        vgacon_scrollback_init(c->vc_size_row);
         return 0;               /* Redrawing not needed */
 }
 
@@ -1062,37 +1263,6 @@ static int vgacon_resize(struct vc_data *c, unsigned int width,
         return 0;
 }
 
-static int vgacon_scrolldelta(struct vc_data *c, int lines)
-{
-        if (!lines)             /* Turn scrollback off */
-                c->vc_visible_origin = c->vc_origin;
-        else {
-                int margin = c->vc_size_row * 4;
-                int ul, we, p, st;
-
-                if (vga_rolled_over >
-                    (c->vc_scr_end - vga_vram_base) + margin) {
-                        ul = c->vc_scr_end - vga_vram_base;
-                        we = vga_rolled_over + c->vc_size_row;
-                } else {
-                        ul = 0;
-                        we = vga_vram_size;
-                }
-                p = (c->vc_visible_origin - vga_vram_base - ul + we) % we +
-                    lines * c->vc_size_row;
-                st = (c->vc_origin - vga_vram_base - ul + we) % we;
-                if (st < 2 * margin)
-                        margin = 0;
-                if (p < margin)
-                        p = 0;
-                if (p > st - margin)
-                        p = st;
-                c->vc_visible_origin = vga_vram_base + (p + ul) % we;
-        }
-        vga_set_mem_top(c);
-        return 1;
-}
-
 static int vgacon_set_origin(struct vc_data *c)
 {
         if (vga_is_gfx ||       /* We don't play origin tricks in graphic modes */
@@ -1135,15 +1305,14 @@ static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
         if (t || b != c->vc_rows || vga_is_gfx)
                 return 0;
 
-        if (c->vc_origin != c->vc_visible_origin)
-                vgacon_scrolldelta(c, 0);
-
         if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
                 return 0;
 
+        vgacon_restore_screen(c);
         oldo = c->vc_origin;
         delta = lines * c->vc_size_row;
         if (dir == SM_UP) {
+                vgacon_scrollback_update(c, t, lines);
                 if (c->vc_scr_end + delta >= vga_vram_end) {
                         scr_memcpyw((u16 *) vga_vram_base,
                                     (u16 *) (oldo + delta),
diff --git a/drivers/video/fbcmap.c b/drivers/video/fbcmap.c
index c32a2a50bfa2..1f98392a43b3 100644
--- a/drivers/video/fbcmap.c
+++ b/drivers/video/fbcmap.c
@@ -85,7 +85,7 @@ static struct fb_cmap default_16_colors = {
  *      Allocates memory for a colormap @cmap.  @len is the
  *      number of entries in the palette.
  *
- *      Returns -1 errno on error, or zero on success.
+ *      Returns negative errno on error, or zero on success.
  *
  */
 
@@ -116,7 +116,7 @@ int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp)
 
 fail:
     fb_dealloc_cmap(cmap);
-    return -1;
+    return -ENOMEM;
 }
 
 /**
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 07d882b14396..b1a8dca76430 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -55,7 +55,7 @@
 
 #define FBPIXMAPSIZE    (1024 * 8)
 
-static struct notifier_block *fb_notifier_list;
+static BLOCKING_NOTIFIER_HEAD(fb_notifier_list);
 struct fb_info *registered_fb[FB_MAX];
 int num_registered_fb;
 
@@ -784,7 +784,7 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
 
                     event.info = info;
                     event.data = &mode1;
-                    ret = notifier_call_chain(&fb_notifier_list,
+                    ret = blocking_notifier_call_chain(&fb_notifier_list,
                                               FB_EVENT_MODE_DELETE, &event);
                 }
 
@@ -830,8 +830,8 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
 
                                 info->flags &= ~FBINFO_MISC_USEREVENT;
                                 event.info = info;
-                                notifier_call_chain(&fb_notifier_list, evnt,
-                                                    &event);
+                                blocking_notifier_call_chain(&fb_notifier_list,
+                                                evnt, &event);
                         }
                 }
         }
@@ -854,7 +854,8 @@ fb_blank(struct fb_info *info, int blank)
 
                 event.info = info;
                 event.data = &blank;
-                notifier_call_chain(&fb_notifier_list, FB_EVENT_BLANK, &event);
+                blocking_notifier_call_chain(&fb_notifier_list,
+                                FB_EVENT_BLANK, &event);
         }
 
         return ret;
@@ -925,7 +926,7 @@ fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 con2fb.framebuffer = -1;
                 event.info = info;
                 event.data = &con2fb;
-                notifier_call_chain(&fb_notifier_list,
+                blocking_notifier_call_chain(&fb_notifier_list,
                                     FB_EVENT_GET_CONSOLE_MAP, &event);
                 return copy_to_user(argp, &con2fb,
                                     sizeof(con2fb)) ? -EFAULT : 0;
@@ -944,7 +945,7 @@ fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                     return -EINVAL;
                 event.info = info;
                 event.data = &con2fb;
-                return notifier_call_chain(&fb_notifier_list,
+                return blocking_notifier_call_chain(&fb_notifier_list,
                                            FB_EVENT_SET_CONSOLE_MAP,
                                            &event);
         case FBIOBLANK:
@@ -1324,7 +1325,7 @@ register_framebuffer(struct fb_info *fb_info)
         devfs_mk_cdev(MKDEV(FB_MAJOR, i),
                         S_IFCHR | S_IRUGO | S_IWUGO, "fb/%d", i);
         event.info = fb_info;
-        notifier_call_chain(&fb_notifier_list,
+        blocking_notifier_call_chain(&fb_notifier_list,
                             FB_EVENT_FB_REGISTERED, &event);
         return 0;
 }
@@ -1366,7 +1367,7 @@ unregister_framebuffer(struct fb_info *fb_info)
  */
 int fb_register_client(struct notifier_block *nb)
 {
-        return notifier_chain_register(&fb_notifier_list, nb);
+        return blocking_notifier_chain_register(&fb_notifier_list, nb);
 }
 
 /**
@@ -1375,7 +1376,7 @@ int fb_register_client(struct notifier_block *nb)
  */
 int fb_unregister_client(struct notifier_block *nb)
 {
-        return notifier_chain_unregister(&fb_notifier_list, nb);
+        return blocking_notifier_chain_unregister(&fb_notifier_list, nb);
 }
 
 /**
@@ -1393,11 +1394,13 @@ void fb_set_suspend(struct fb_info *info, int state)
 
         event.info = info;
         if (state) {
-                notifier_call_chain(&fb_notifier_list, FB_EVENT_SUSPEND, &event);
+                blocking_notifier_call_chain(&fb_notifier_list,
+                                FB_EVENT_SUSPEND, &event);
                 info->state = FBINFO_STATE_SUSPENDED;
         } else {
                 info->state = FBINFO_STATE_RUNNING;
-                notifier_call_chain(&fb_notifier_list, FB_EVENT_RESUME, &event);
+                blocking_notifier_call_chain(&fb_notifier_list,
+                                FB_EVENT_RESUME, &event);
         }
 }
 
@@ -1469,7 +1472,7 @@ int fb_new_modelist(struct fb_info *info)
 
         if (!list_empty(&info->modelist)) {
                 event.info = info;
-                err = notifier_call_chain(&fb_notifier_list,
+                err = blocking_notifier_call_chain(&fb_notifier_list,
                                            FB_EVENT_NEW_MODELIST,
                                            &event);
         }
@@ -1495,7 +1498,7 @@ int fb_con_duit(struct fb_info *info, int event, void *data)
         evnt.info = info;
         evnt.data = data;
 
-        return notifier_call_chain(&fb_notifier_list, event, &evnt);
+        return blocking_notifier_call_chain(&fb_notifier_list, event, &evnt);
 }
 EXPORT_SYMBOL(fb_con_duit);
 
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index 7c74e7325d95..53beeb4a9998 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -1281,7 +1281,7 @@ int fb_validate_mode(const struct fb_var_screeninfo *var, struct fb_info *info)
                 -EINVAL : 0;
 }
 
-#if defined(__i386__)
+#if defined(CONFIG_FB_FIRMWARE_EDID) && defined(__i386__)
 #include <linux/pci.h>
 
 /*
@@ -1311,11 +1311,11 @@ const unsigned char *fb_firmware_edid(struct device *device)
 {
         return NULL;
 }
-#endif /* _i386_ */
+#endif
+EXPORT_SYMBOL(fb_firmware_edid);
 
 EXPORT_SYMBOL(fb_parse_edid);
 EXPORT_SYMBOL(fb_edid_to_monspecs);
-EXPORT_SYMBOL(fb_firmware_edid);
 EXPORT_SYMBOL(fb_get_mode);
 EXPORT_SYMBOL(fb_validate_mode);
 EXPORT_SYMBOL(fb_destroy_modedb);
diff --git a/drivers/video/fbsysfs.c b/drivers/video/fbsysfs.c
index 6d26057337e2..b72b05250a9d 100644
--- a/drivers/video/fbsysfs.c
+++ b/drivers/video/fbsysfs.c
@@ -348,7 +348,7 @@ static ssize_t store_cmap(struct class_device *class_device, const char *buf,
                 fb_copy_cmap(&umap, &fb_info->cmap);
                 fb_dealloc_cmap(&umap);
 
-                return rc;
+                return rc ?: count;
         }
         for (i = 0; i < length; i++) {
                 u16 red, blue, green, tsp;
@@ -367,7 +367,7 @@ static ssize_t store_cmap(struct class_device *class_device, const char *buf,
                 if (transp)
                         fb_info->cmap.transp[i] = tsp;
         }
-        return 0;
+        return count;
 }
 
 static ssize_t show_cmap(struct class_device *class_device, char *buf)
diff --git a/drivers/video/geode/Kconfig b/drivers/video/geode/Kconfig
index 42fb9a89a792..4e173ef20a7d 100644
--- a/drivers/video/geode/Kconfig
+++ b/drivers/video/geode/Kconfig
@@ -8,9 +8,24 @@ config FB_GEODE
           Say 'Y' here to allow you to select framebuffer drivers for
           the AMD Geode family of processors.
 
+config FB_GEODE_GX
+        tristate "AMD Geode GX framebuffer support (EXPERIMENTAL)"
+        depends on FB && FB_GEODE && EXPERIMENTAL
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        ---help---
+          Framebuffer driver for the display controller integrated into the
+          AMD Geode GX processors.
+
+          To compile this driver as a module, choose M here: the module will be
+          called gxfb.
+
+          If unsure, say N.
+
 config FB_GEODE_GX1
         tristate "AMD Geode GX1 framebuffer support (EXPERIMENTAL)"
-        depends on FB_GEODE && EXPERIMENTAL
+        depends on FB && FB_GEODE && EXPERIMENTAL
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
diff --git a/drivers/video/geode/Makefile b/drivers/video/geode/Makefile
index 13ad501ea990..f896565bc312 100644
--- a/drivers/video/geode/Makefile
+++ b/drivers/video/geode/Makefile
@@ -1,5 +1,7 @@
 # Makefile for the Geode family framebuffer drivers
 
 obj-$(CONFIG_FB_GEODE_GX1) += gx1fb.o
+obj-$(CONFIG_FB_GEODE_GX)  += gxfb.o
 
-gx1fb-objs              := gx1fb_core.o display_gx1.o video_cs5530.o
+gx1fb-objs := gx1fb_core.o display_gx1.o video_cs5530.o
+gxfb-objs  := gxfb_core.o display_gx.o video_gx.o
diff --git a/drivers/video/geode/display_gx.c b/drivers/video/geode/display_gx.c
new file mode 100644
index 000000000000..825c3405f5c2
--- /dev/null
+++ b/drivers/video/geode/display_gx.c
@@ -0,0 +1,156 @@
+/*
+ * Geode GX display controller.
+ *
+ *   Copyright (C) 2005 Arcom Control Systems Ltd.
+ *
+ *   Portions from AMD's original 2.4 driver:
+ *     Copyright (C) 2004 Advanced Micro Devices, 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.
+ */
+#include <linux/spinlock.h>
+#include <linux/fb.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+#include <asm/div64.h>
+#include <asm/delay.h>
+
+#include "geodefb.h"
+#include "display_gx.h"
+
+int gx_frame_buffer_size(void)
+{
+        /* Assuming 16 MiB. */
+        return 16*1024*1024;
+}
+
+int gx_line_delta(int xres, int bpp)
+{
+        /* Must be a multiple of 8 bytes. */
+        return (xres * (bpp >> 3) + 7) & ~0x7;
+}
+
+static void gx_set_mode(struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+        u32 gcfg, dcfg;
+        int hactive, hblankstart, hsyncstart, hsyncend, hblankend, htotal;
+        int vactive, vblankstart, vsyncstart, vsyncend, vblankend, vtotal;
+
+        /* Unlock the display controller registers. */
+        readl(par->dc_regs + DC_UNLOCK);
+        writel(DC_UNLOCK_CODE, par->dc_regs + DC_UNLOCK);
+
+        gcfg = readl(par->dc_regs + DC_GENERAL_CFG);
+        dcfg = readl(par->dc_regs + DC_DISPLAY_CFG);
+
+        /* Disable the timing generator. */
+        dcfg &= ~(DC_DCFG_TGEN);
+        writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
+
+        /* Wait for pending memory requests before disabling the FIFO load. */
+        udelay(100);
+
+        /* Disable FIFO load and compression. */
+        gcfg &= ~(DC_GCFG_DFLE | DC_GCFG_CMPE | DC_GCFG_DECE);
+        writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
+
+        /* Setup DCLK and its divisor. */
+        par->vid_ops->set_dclk(info);
+
+        /*
+         * Setup new mode.
+         */
+
+        /* Clear all unused feature bits. */
+        gcfg &= DC_GCFG_YUVM | DC_GCFG_VDSE;
+        dcfg = 0;
+
+        /* Set FIFO priority (default 6/5) and enable. */
+        /* FIXME: increase fifo priority for 1280x1024 and higher modes? */
+        gcfg |= (6 << DC_GCFG_DFHPEL_POS) | (5 << DC_GCFG_DFHPSL_POS) | DC_GCFG_DFLE;
+
+        /* Framebuffer start offset. */
+        writel(0, par->dc_regs + DC_FB_ST_OFFSET);
+
+        /* Line delta and line buffer length. */
+        writel(info->fix.line_length >> 3, par->dc_regs + DC_GFX_PITCH);
+        writel(((info->var.xres * info->var.bits_per_pixel/8) >> 3) + 2,
+               par->dc_regs + DC_LINE_SIZE);
+
+        /* Enable graphics and video data and unmask address lines. */
+        dcfg |= DC_DCFG_GDEN | DC_DCFG_VDEN | DC_DCFG_A20M | DC_DCFG_A18M;
+
+        /* Set pixel format. */
+        switch (info->var.bits_per_pixel) {
+        case 8:
+                dcfg |= DC_DCFG_DISP_MODE_8BPP;
+                break;
+        case 16:
+                dcfg |= DC_DCFG_DISP_MODE_16BPP;
+                dcfg |= DC_DCFG_16BPP_MODE_565;
+                break;
+        case 32:
+                dcfg |= DC_DCFG_DISP_MODE_24BPP;
+                dcfg |= DC_DCFG_PALB;
+                break;
+        }
+
+        /* Enable timing generator. */
+        dcfg |= DC_DCFG_TGEN;
+
+        /* Horizontal and vertical timings. */
+        hactive = info->var.xres;
+        hblankstart = hactive;
+        hsyncstart = hblankstart + info->var.right_margin;
+        hsyncend =  hsyncstart + info->var.hsync_len;
+        hblankend = hsyncend + info->var.left_margin;
+        htotal = hblankend;
+
+        vactive = info->var.yres;
+        vblankstart = vactive;
+        vsyncstart = vblankstart + info->var.lower_margin;
+        vsyncend =  vsyncstart + info->var.vsync_len;
+        vblankend = vsyncend + info->var.upper_margin;
+        vtotal = vblankend;
+
+        writel((hactive - 1)     | ((htotal - 1) << 16),    par->dc_regs + DC_H_ACTIVE_TIMING);
+        writel((hblankstart - 1) | ((hblankend - 1) << 16), par->dc_regs + DC_H_BLANK_TIMING);
+        writel((hsyncstart - 1)  | ((hsyncend - 1) << 16),  par->dc_regs + DC_H_SYNC_TIMING);
+
+        writel((vactive - 1)     | ((vtotal - 1) << 16),    par->dc_regs + DC_V_ACTIVE_TIMING);
+        writel((vblankstart - 1) | ((vblankend - 1) << 16), par->dc_regs + DC_V_BLANK_TIMING);
+        writel((vsyncstart - 1)  | ((vsyncend - 1) << 16),  par->dc_regs + DC_V_SYNC_TIMING);
+
+        /* Write final register values. */
+        writel(dcfg, par->dc_regs + DC_DISPLAY_CFG);
+        writel(gcfg, par->dc_regs + DC_GENERAL_CFG);
+
+        par->vid_ops->configure_display(info);
+
+        /* Relock display controller registers */
+        writel(0, par->dc_regs + DC_UNLOCK);
+}
+
+static void gx_set_hw_palette_reg(struct fb_info *info, unsigned regno,
+                                   unsigned red, unsigned green, unsigned blue)
+{
+        struct geodefb_par *par = info->par;
+        int val;
+
+        /* Hardware palette is in RGB 8-8-8 format. */
+        val  = (red   << 8) & 0xff0000;
+        val |= (green)      & 0x00ff00;
+        val |= (blue  >> 8) & 0x0000ff;
+
+        writel(regno, par->dc_regs + DC_PAL_ADDRESS);
+        writel(val, par->dc_regs + DC_PAL_DATA);
+}
+
+struct geode_dc_ops gx_dc_ops = {
+        .set_mode        = gx_set_mode,
+        .set_palette_reg = gx_set_hw_palette_reg,
+};
diff --git a/drivers/video/geode/display_gx.h b/drivers/video/geode/display_gx.h
new file mode 100644
index 000000000000..86c623361305
--- /dev/null
+++ b/drivers/video/geode/display_gx.h
@@ -0,0 +1,96 @@
+/*
+ * Geode GX display controller
+ *
+ * Copyright (C) 2006 Arcom Control Systems Ltd.
+ *
+ * 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 __DISPLAY_GX_H__
+#define __DISPLAY_GX_H__
+
+int gx_frame_buffer_size(void);
+int gx_line_delta(int xres, int bpp);
+
+extern struct geode_dc_ops gx_dc_ops;
+
+/* Display controller registers */
+
+#define DC_UNLOCK 0x00
+#  define DC_UNLOCK_CODE 0x00004758
+
+#define DC_GENERAL_CFG 0x04
+#  define DC_GCFG_DFLE        0x00000001
+#  define DC_GCFG_CURE        0x00000002
+#  define DC_GCFG_ICNE        0x00000004
+#  define DC_GCFG_VIDE        0x00000008
+#  define DC_GCFG_CMPE        0x00000020
+#  define DC_GCFG_DECE        0x00000040
+#  define DC_GCFG_VGAE        0x00000080
+#  define DC_GCFG_DFHPSL_MASK 0x00000F00
+#  define DC_GCFG_DFHPSL_POS           8
+#  define DC_GCFG_DFHPEL_MASK 0x0000F000
+#  define DC_GCFG_DFHPEL_POS          12
+#  define DC_GCFG_STFM        0x00010000
+#  define DC_GCFG_FDTY        0x00020000
+#  define DC_GCFG_VGAFT       0x00040000
+#  define DC_GCFG_VDSE        0x00080000
+#  define DC_GCFG_YUVM        0x00100000
+#  define DC_GCFG_VFSL        0x00800000
+#  define DC_GCFG_SIGE        0x01000000
+#  define DC_GCFG_SGRE        0x02000000
+#  define DC_GCFG_SGFR        0x04000000
+#  define DC_GCFG_CRC_MODE    0x08000000
+#  define DC_GCFG_DIAG        0x10000000
+#  define DC_GCFG_CFRW        0x20000000
+
+#define DC_DISPLAY_CFG 0x08
+#  define DC_DCFG_TGEN            0x00000001
+#  define DC_DCFG_GDEN            0x00000008
+#  define DC_DCFG_VDEN            0x00000010
+#  define DC_DCFG_TRUP            0x00000040
+#  define DC_DCFG_DISP_MODE_MASK  0x00000300
+#  define DC_DCFG_DISP_MODE_8BPP  0x00000000
+#  define DC_DCFG_DISP_MODE_16BPP 0x00000100
+#  define DC_DCFG_DISP_MODE_24BPP 0x00000200
+#  define DC_DCFG_16BPP_MODE_MASK 0x00000c00
+#  define DC_DCFG_16BPP_MODE_565  0x00000000
+#  define DC_DCFG_16BPP_MODE_555  0x00000100
+#  define DC_DCFG_16BPP_MODE_444  0x00000200
+#  define DC_DCFG_DCEN            0x00080000
+#  define DC_DCFG_PALB            0x02000000
+#  define DC_DCFG_FRLK            0x04000000
+#  define DC_DCFG_VISL            0x08000000
+#  define DC_DCFG_FRSL            0x20000000
+#  define DC_DCFG_A18M            0x40000000
+#  define DC_DCFG_A20M            0x80000000
+
+#define DC_FB_ST_OFFSET 0x10
+
+#define DC_LINE_SIZE 0x30
+#  define DC_LINE_SIZE_FB_LINE_SIZE_MASK  0x000007ff
+#  define DC_LINE_SIZE_FB_LINE_SIZE_POS            0
+#  define DC_LINE_SIZE_CB_LINE_SIZE_MASK  0x007f0000
+#  define DC_LINE_SIZE_CB_LINE_SIZE_POS           16
+#  define DC_LINE_SIZE_VID_LINE_SIZE_MASK 0xff000000
+#  define DC_LINE_SIZE_VID_LINE_SIZE_POS          24
+
+#define DC_GFX_PITCH 0x34
+#  define DC_GFX_PITCH_FB_PITCH_MASK 0x0000ffff
+#  define DC_GFX_PITCH_FB_PITCH_POS           0
+#  define DC_GFX_PITCH_CB_PITCH_MASK 0xffff0000
+#  define DC_GFX_PITCH_CB_PITCH_POS          16
+
+#define DC_H_ACTIVE_TIMING 0x40
+#define DC_H_BLANK_TIMING  0x44
+#define DC_H_SYNC_TIMING   0x48
+#define DC_V_ACTIVE_TIMING 0x50
+#define DC_V_BLANK_TIMING  0x54
+#define DC_V_SYNC_TIMING   0x58
+
+#define DC_PAL_ADDRESS 0x70
+#define DC_PAL_DATA    0x74
+
+#endif /* !__DISPLAY_GX1_H__ */
diff --git a/drivers/video/geode/gxfb_core.c b/drivers/video/geode/gxfb_core.c
new file mode 100644
index 000000000000..89c34b15f5d4
--- /dev/null
+++ b/drivers/video/geode/gxfb_core.c
@@ -0,0 +1,423 @@
+/*
+ * Geode GX framebuffer driver.
+ *
+ *   Copyright (C) 2006 Arcom Control Systems Ltd.
+ *
+ *   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 driver assumes that the BIOS has created a virtual PCI device header
+ * for the video device. The PCI header is assumed to contain the following
+ * BARs:
+ *
+ *    BAR0 - framebuffer memory
+ *    BAR1 - graphics processor registers
+ *    BAR2 - display controller registers
+ *    BAR3 - video processor and flat panel control registers.
+ *
+ * 16 MiB of framebuffer memory is assumed to be available.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/tty.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+
+#include "geodefb.h"
+#include "display_gx.h"
+#include "video_gx.h"
+
+static char mode_option[32] = "640x480-16@60";
+
+/* Modes relevant to the GX (taken from modedb.c) */
+static const struct fb_videomode __initdata gx_modedb[] = {
+        /* 640x480-60 VESA */
+        { NULL, 60, 640, 480, 39682,  48, 16, 33, 10, 96, 2,
+          0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 640x480-75 VESA */
+        { NULL, 75, 640, 480, 31746, 120, 16, 16, 01, 64, 3,
+          0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 640x480-85 VESA */
+        { NULL, 85, 640, 480, 27777, 80, 56, 25, 01, 56, 3,
+          0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 800x600-60 VESA */
+        { NULL, 60, 800, 600, 25000, 88, 40, 23, 01, 128, 4,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 800x600-75 VESA */
+        { NULL, 75, 800, 600, 20202, 160, 16, 21, 01, 80, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 800x600-85 VESA */
+        { NULL, 85, 800, 600, 17761, 152, 32, 27, 01, 64, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1024x768-60 VESA */
+        { NULL, 60, 1024, 768, 15384, 160, 24, 29, 3, 136, 6,
+          0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1024x768-75 VESA */
+        { NULL, 75, 1024, 768, 12690, 176, 16, 28, 1, 96, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1024x768-85 VESA */
+        { NULL, 85, 1024, 768, 10582, 208, 48, 36, 1, 96, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x960-60 VESA */
+        { NULL, 60, 1280, 960, 9259, 312, 96, 36, 1, 112, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x960-85 VESA */
+        { NULL, 85, 1280, 960, 6734, 224, 64, 47, 1, 160, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x1024-60 VESA */
+        { NULL, 60, 1280, 1024, 9259, 248, 48, 38, 1, 112, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x1024-75 VESA */
+        { NULL, 75, 1280, 1024, 7407, 248, 16, 38, 1, 144, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1280x1024-85 VESA */
+        { NULL, 85, 1280, 1024, 6349, 224, 64, 44, 1, 160, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1600x1200-60 VESA */
+        { NULL, 60, 1600, 1200, 6172, 304, 64, 46, 1, 192, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1600x1200-75 VESA */
+        { NULL, 75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+        /* 1600x1200-85 VESA */
+        { NULL, 85, 1600, 1200, 4357, 304, 64, 46, 1, 192, 3,
+          FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
+          FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
+};
+
+static int gxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        if (var->xres > 1600 || var->yres > 1200)
+                return -EINVAL;
+        if ((var->xres > 1280 || var->yres > 1024) && var->bits_per_pixel > 16)
+                return -EINVAL;
+
+        if (var->bits_per_pixel == 32) {
+                var->red.offset   = 16; var->red.length   = 8;
+                var->green.offset =  8; var->green.length = 8;
+                var->blue.offset  =  0; var->blue.length  = 8;
+        } else if (var->bits_per_pixel == 16) {
+                var->red.offset   = 11; var->red.length   = 5;
+                var->green.offset =  5; var->green.length = 6;
+                var->blue.offset  =  0; var->blue.length  = 5;
+        } else if (var->bits_per_pixel == 8) {
+                var->red.offset   = 0; var->red.length   = 8;
+                var->green.offset = 0; var->green.length = 8;
+                var->blue.offset  = 0; var->blue.length  = 8;
+        } else
+                return -EINVAL;
+        var->transp.offset = 0; var->transp.length = 0;
+
+        /* Enough video memory? */
+        if (gx_line_delta(var->xres, var->bits_per_pixel) * var->yres > info->fix.smem_len)
+                return -EINVAL;
+
+        /* FIXME: Check timing parameters here? */
+
+        return 0;
+}
+
+static int gxfb_set_par(struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+
+        if (info->var.bits_per_pixel > 8) {
+                info->fix.visual = FB_VISUAL_TRUECOLOR;
+                fb_dealloc_cmap(&info->cmap);
+        } else {
+                info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+                fb_alloc_cmap(&info->cmap, 1<<info->var.bits_per_pixel, 0);
+        }
+
+        info->fix.line_length = gx_line_delta(info->var.xres, info->var.bits_per_pixel);
+
+        par->dc_ops->set_mode(info);
+
+        return 0;
+}
+
+static inline u_int chan_to_field(u_int chan, struct fb_bitfield *bf)
+{
+        chan &= 0xffff;
+        chan >>= 16 - bf->length;
+        return chan << bf->offset;
+}
+
+static int gxfb_setcolreg(unsigned regno, unsigned red, unsigned green,
+                           unsigned blue, unsigned transp,
+                           struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+
+        if (info->var.grayscale) {
+                /* grayscale = 0.30*R + 0.59*G + 0.11*B */
+                red = green = blue = (red * 77 + green * 151 + blue * 28) >> 8;
+        }
+
+        /* Truecolor has hardware independent palette */
+        if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
+                u32 *pal = info->pseudo_palette;
+                u32 v;
+
+                if (regno >= 16)
+                        return -EINVAL;
+
+                v  = chan_to_field(red, &info->var.red);
+                v |= chan_to_field(green, &info->var.green);
+                v |= chan_to_field(blue, &info->var.blue);
+
+                pal[regno] = v;
+        } else {
+                if (regno >= 256)
+                        return -EINVAL;
+
+                par->dc_ops->set_palette_reg(info, regno, red, green, blue);
+        }
+
+        return 0;
+}
+
+static int gxfb_blank(int blank_mode, struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+
+        return par->vid_ops->blank_display(info, blank_mode);
+}
+
+static int __init gxfb_map_video_memory(struct fb_info *info, struct pci_dev *dev)
+{
+        struct geodefb_par *par = info->par;
+        int fb_len;
+        int ret;
+
+        ret = pci_enable_device(dev);
+        if (ret < 0)
+                return ret;
+
+        ret = pci_request_region(dev, 3, "gxfb (video processor)");
+        if (ret < 0)
+                return ret;
+        par->vid_regs = ioremap(pci_resource_start(dev, 3),
+                                pci_resource_len(dev, 3));
+        if (!par->vid_regs)
+                return -ENOMEM;
+
+        ret = pci_request_region(dev, 2, "gxfb (display controller)");
+        if (ret < 0)
+                return ret;
+        par->dc_regs = ioremap(pci_resource_start(dev, 2), pci_resource_len(dev, 2));
+        if (!par->dc_regs)
+                return -ENOMEM;
+
+        ret = pci_request_region(dev, 0, "gxfb (framebuffer)");
+        if (ret < 0)
+                return ret;
+        if ((fb_len = gx_frame_buffer_size()) < 0)
+                return -ENOMEM;
+        info->fix.smem_start = pci_resource_start(dev, 0);
+        info->fix.smem_len = fb_len;
+        info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
+        if (!info->screen_base)
+                return -ENOMEM;
+
+        dev_info(&dev->dev, "%d Kibyte of video memory at 0x%lx\n",
+                 info->fix.smem_len / 1024, info->fix.smem_start);
+
+        return 0;
+}
+
+static struct fb_ops gxfb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_check_var   = gxfb_check_var,
+        .fb_set_par     = gxfb_set_par,
+        .fb_setcolreg   = gxfb_setcolreg,
+        .fb_blank       = gxfb_blank,
+        /* No HW acceleration for now. */
+        .fb_fillrect    = cfb_fillrect,
+        .fb_copyarea    = cfb_copyarea,
+        .fb_imageblit   = cfb_imageblit,
+};
+
+static struct fb_info * __init gxfb_init_fbinfo(struct device *dev)
+{
+        struct geodefb_par *par;
+        struct fb_info *info;
+
+        /* Alloc enough space for the pseudo palette. */
+        info = framebuffer_alloc(sizeof(struct geodefb_par) + sizeof(u32) * 16, dev);
+        if (!info)
+                return NULL;
+
+        par = info->par;
+
+        strcpy(info->fix.id, "Geode GX");
+
+        info->fix.type          = FB_TYPE_PACKED_PIXELS;
+        info->fix.type_aux      = 0;
+        info->fix.xpanstep      = 0;
+        info->fix.ypanstep      = 0;
+        info->fix.ywrapstep     = 0;
+        info->fix.accel         = FB_ACCEL_NONE;
+
+        info->var.nonstd        = 0;
+        info->var.activate      = FB_ACTIVATE_NOW;
+        info->var.height        = -1;
+        info->var.width = -1;
+        info->var.accel_flags = 0;
+        info->var.vmode = FB_VMODE_NONINTERLACED;
+
+        info->fbops             = &gxfb_ops;
+        info->flags             = FBINFO_DEFAULT;
+        info->node              = -1;
+
+        info->pseudo_palette    = (void *)par + sizeof(struct geodefb_par);
+
+        info->var.grayscale     = 0;
+
+        return info;
+}
+
+static int __init gxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        struct geodefb_par *par;
+        struct fb_info *info;
+        int ret;
+
+        info = gxfb_init_fbinfo(&pdev->dev);
+        if (!info)
+                return -ENOMEM;
+        par = info->par;
+
+        /* GX display controller and GX video device. */
+        par->dc_ops  = &gx_dc_ops;
+        par->vid_ops = &gx_vid_ops;
+
+        if ((ret = gxfb_map_video_memory(info, pdev)) < 0) {
+                dev_err(&pdev->dev, "failed to map frame buffer or controller registers\n");
+                goto err;
+        }
+
+        ret = fb_find_mode(&info->var, info, mode_option,
+                           gx_modedb, ARRAY_SIZE(gx_modedb), NULL, 16);
+        if (ret == 0 || ret == 4) {
+                dev_err(&pdev->dev, "could not find valid video mode\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* Clear the frame buffer of garbage. */
+        memset_io(info->screen_base, 0, info->fix.smem_len);
+
+        gxfb_check_var(&info->var, info);
+        gxfb_set_par(info);
+
+        if (register_framebuffer(info) < 0) {
+                ret = -EINVAL;
+                goto err;
+        }
+        pci_set_drvdata(pdev, info);
+        printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id);
+        return 0;
+
+  err:
+        if (info->screen_base) {
+                iounmap(info->screen_base);
+                pci_release_region(pdev, 0);
+        }
+        if (par->vid_regs) {
+                iounmap(par->vid_regs);
+                pci_release_region(pdev, 3);
+        }
+        if (par->dc_regs) {
+                iounmap(par->dc_regs);
+                pci_release_region(pdev, 2);
+        }
+
+        pci_disable_device(pdev);
+
+        if (info)
+                framebuffer_release(info);
+        return ret;
+}
+
+static void gxfb_remove(struct pci_dev *pdev)
+{
+        struct fb_info *info = pci_get_drvdata(pdev);
+        struct geodefb_par *par = info->par;
+
+        unregister_framebuffer(info);
+
+        iounmap((void __iomem *)info->screen_base);
+        pci_release_region(pdev, 0);
+
+        iounmap(par->vid_regs);
+        pci_release_region(pdev, 3);
+
+        iounmap(par->dc_regs);
+        pci_release_region(pdev, 2);
+
+        pci_disable_device(pdev);
+        pci_set_drvdata(pdev, NULL);
+
+        framebuffer_release(info);
+}
+
+static struct pci_device_id gxfb_id_table[] = {
+        { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_VIDEO,
+          PCI_ANY_ID, PCI_ANY_ID, PCI_BASE_CLASS_DISPLAY << 16,
+          0xff0000, 0 },
+        { 0, }
+};
+
+MODULE_DEVICE_TABLE(pci, gxfb_id_table);
+
+static struct pci_driver gxfb_driver = {
+        .name           = "gxfb",
+        .id_table       = gxfb_id_table,
+        .probe          = gxfb_probe,
+        .remove         = gxfb_remove,
+};
+
+static int __init gxfb_init(void)
+{
+#ifndef MODULE
+        if (fb_get_options("gxfb", NULL))
+                return -ENODEV;
+#endif
+        return pci_register_driver(&gxfb_driver);
+}
+
+static void __exit gxfb_cleanup(void)
+{
+        pci_unregister_driver(&gxfb_driver);
+}
+
+module_init(gxfb_init);
+module_exit(gxfb_cleanup);
+
+module_param_string(mode, mode_option, sizeof(mode_option), 0444);
+MODULE_PARM_DESC(mode, "video mode (<x>x<y>[-<bpp>][@<refr>])");
+
+MODULE_DESCRIPTION("Framebuffer driver for the AMD Geode GX");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/geode/video_gx.c b/drivers/video/geode/video_gx.c
new file mode 100644
index 000000000000..2b2a7880ea75
--- /dev/null
+++ b/drivers/video/geode/video_gx.c
@@ -0,0 +1,262 @@
+/*
+ * Geode GX video processor device.
+ *
+ *   Copyright (C) 2006 Arcom Control Systems Ltd.
+ *
+ *   Portions from AMD's original 2.4 driver:
+ *     Copyright (C) 2004 Advanced Micro Devices, 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.
+ */
+#include <linux/fb.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+#include <asm/delay.h>
+#include <asm/msr.h>
+
+#include "geodefb.h"
+#include "video_gx.h"
+
+
+/*
+ * Tables of register settings for various DOTCLKs.
+ */
+struct gx_pll_entry {
+        long pixclock; /* ps */
+        u32 sys_rstpll_bits;
+        u32 dotpll_value;
+};
+
+#define POSTDIV3 ((u32)MSR_GLCP_SYS_RSTPLL_DOTPOSTDIV3)
+#define PREMULT2 ((u32)MSR_GLCP_SYS_RSTPLL_DOTPREMULT2)
+#define PREDIV2  ((u32)MSR_GLCP_SYS_RSTPLL_DOTPOSTDIV3)
+
+static const struct gx_pll_entry gx_pll_table_48MHz[] = {
+        { 40123, POSTDIV3,          0x00000BF2 },       /*  24.9230 */
+        { 39721, 0,                 0x00000037 },       /*  25.1750 */
+        { 35308, POSTDIV3|PREMULT2, 0x00000B1A },       /*  28.3220 */
+        { 31746, POSTDIV3,          0x000002D2 },       /*  31.5000 */
+        { 27777, POSTDIV3|PREMULT2, 0x00000FE2 },       /*  36.0000 */
+        { 26666, POSTDIV3,          0x0000057A },       /*  37.5000 */
+        { 25000, POSTDIV3,          0x0000030A },       /*  40.0000 */
+        { 22271, 0,                 0x00000063 },       /*  44.9000 */
+        { 20202, 0,                 0x0000054B },       /*  49.5000 */
+        { 20000, 0,                 0x0000026E },       /*  50.0000 */
+        { 19860, PREMULT2,          0x00000037 },       /*  50.3500 */
+        { 18518, POSTDIV3|PREMULT2, 0x00000B0D },       /*  54.0000 */
+        { 17777, 0,                 0x00000577 },       /*  56.2500 */
+        { 17733, 0,                 0x000007F7 },       /*  56.3916 */
+        { 17653, 0,                 0x0000057B },       /*  56.6444 */
+        { 16949, PREMULT2,          0x00000707 },       /*  59.0000 */
+        { 15873, POSTDIV3|PREMULT2, 0x00000B39 },       /*  63.0000 */
+        { 15384, POSTDIV3|PREMULT2, 0x00000B45 },       /*  65.0000 */
+        { 14814, POSTDIV3|PREMULT2, 0x00000FC1 },       /*  67.5000 */
+        { 14124, POSTDIV3,          0x00000561 },       /*  70.8000 */
+        { 13888, POSTDIV3,          0x000007E1 },       /*  72.0000 */
+        { 13426, PREMULT2,          0x00000F4A },       /*  74.4810 */
+        { 13333, 0,                 0x00000052 },       /*  75.0000 */
+        { 12698, 0,                 0x00000056 },       /*  78.7500 */
+        { 12500, POSTDIV3|PREMULT2, 0x00000709 },       /*  80.0000 */
+        { 11135, PREMULT2,          0x00000262 },       /*  89.8000 */
+        { 10582, 0,                 0x000002D2 },       /*  94.5000 */
+        { 10101, PREMULT2,          0x00000B4A },       /*  99.0000 */
+        { 10000, PREMULT2,          0x00000036 },       /* 100.0000 */
+        {  9259, 0,                 0x000007E2 },       /* 108.0000 */
+        {  8888, 0,                 0x000007F6 },       /* 112.5000 */
+        {  7692, POSTDIV3|PREMULT2, 0x00000FB0 },       /* 130.0000 */
+        {  7407, POSTDIV3|PREMULT2, 0x00000B50 },       /* 135.0000 */
+        {  6349, 0,                 0x00000055 },       /* 157.5000 */
+        {  6172, 0,                 0x000009C1 },       /* 162.0000 */
+        {  5787, PREMULT2,          0x0000002D },       /* 172.798  */
+        {  5698, 0,                 0x000002C1 },       /* 175.5000 */
+        {  5291, 0,                 0x000002D1 },       /* 189.0000 */
+        {  4938, 0,                 0x00000551 },       /* 202.5000 */
+        {  4357, 0,                 0x0000057D },       /* 229.5000 */
+};
+
+static const struct gx_pll_entry gx_pll_table_14MHz[] = {
+        { 39721, 0, 0x00000037 },       /*  25.1750 */
+        { 35308, 0, 0x00000B7B },       /*  28.3220 */
+        { 31746, 0, 0x000004D3 },       /*  31.5000 */
+        { 27777, 0, 0x00000BE3 },       /*  36.0000 */
+        { 26666, 0, 0x0000074F },       /*  37.5000 */
+        { 25000, 0, 0x0000050B },       /*  40.0000 */
+        { 22271, 0, 0x00000063 },       /*  44.9000 */
+        { 20202, 0, 0x0000054B },       /*  49.5000 */
+        { 20000, 0, 0x0000026E },       /*  50.0000 */
+        { 19860, 0, 0x000007C3 },       /*  50.3500 */
+        { 18518, 0, 0x000007E3 },       /*  54.0000 */
+        { 17777, 0, 0x00000577 },       /*  56.2500 */
+        { 17733, 0, 0x000002FB },       /*  56.3916 */
+        { 17653, 0, 0x0000057B },       /*  56.6444 */
+        { 16949, 0, 0x0000058B },       /*  59.0000 */
+        { 15873, 0, 0x0000095E },       /*  63.0000 */
+        { 15384, 0, 0x0000096A },       /*  65.0000 */
+        { 14814, 0, 0x00000BC2 },       /*  67.5000 */
+        { 14124, 0, 0x0000098A },       /*  70.8000 */
+        { 13888, 0, 0x00000BE2 },       /*  72.0000 */
+        { 13333, 0, 0x00000052 },       /*  75.0000 */
+        { 12698, 0, 0x00000056 },       /*  78.7500 */
+        { 12500, 0, 0x0000050A },       /*  80.0000 */
+        { 11135, 0, 0x0000078E },       /*  89.8000 */
+        { 10582, 0, 0x000002D2 },       /*  94.5000 */
+        { 10101, 0, 0x000011F6 },       /*  99.0000 */
+        { 10000, 0, 0x0000054E },       /* 100.0000 */
+        {  9259, 0, 0x000007E2 },       /* 108.0000 */
+        {  8888, 0, 0x000002FA },       /* 112.5000 */
+        {  7692, 0, 0x00000BB1 },       /* 130.0000 */
+        {  7407, 0, 0x00000975 },       /* 135.0000 */
+        {  6349, 0, 0x00000055 },       /* 157.5000 */
+        {  6172, 0, 0x000009C1 },       /* 162.0000 */
+        {  5698, 0, 0x000002C1 },       /* 175.5000 */
+        {  5291, 0, 0x00000539 },       /* 189.0000 */
+        {  4938, 0, 0x00000551 },       /* 202.5000 */
+        {  4357, 0, 0x0000057D },       /* 229.5000 */
+};
+
+static void gx_set_dclk_frequency(struct fb_info *info)
+{
+        const struct gx_pll_entry *pll_table;
+        int pll_table_len;
+        int i, best_i;
+        long min, diff;
+        u64 dotpll, sys_rstpll;
+        int timeout = 1000;
+
+        /* Rev. 1 Geode GXs use a 14 MHz reference clock instead of 48 MHz. */
+        if (cpu_data->x86_mask == 1) {
+                pll_table = gx_pll_table_14MHz;
+                pll_table_len = ARRAY_SIZE(gx_pll_table_14MHz);
+        } else {
+                pll_table = gx_pll_table_48MHz;
+                pll_table_len = ARRAY_SIZE(gx_pll_table_48MHz);
+        }
+
+        /* Search the table for the closest pixclock. */
+        best_i = 0;
+        min = abs(pll_table[0].pixclock - info->var.pixclock);
+        for (i = 1; i < pll_table_len; i++) {
+                diff = abs(pll_table[i].pixclock - info->var.pixclock);
+                if (diff < min) {
+                        min = diff;
+                        best_i = i;
+                }
+        }
+
+        rdmsrl(MSR_GLCP_SYS_RSTPLL, sys_rstpll);
+        rdmsrl(MSR_GLCP_DOTPLL, dotpll);
+
+        /* Program new M, N and P. */
+        dotpll &= 0x00000000ffffffffull;
+        dotpll |= (u64)pll_table[best_i].dotpll_value << 32;
+        dotpll |= MSR_GLCP_DOTPLL_DOTRESET;
+        dotpll &= ~MSR_GLCP_DOTPLL_BYPASS;
+
+        wrmsrl(MSR_GLCP_DOTPLL, dotpll);
+
+        /* Program dividers. */
+        sys_rstpll &= ~( MSR_GLCP_SYS_RSTPLL_DOTPREDIV2
+                         | MSR_GLCP_SYS_RSTPLL_DOTPREMULT2
+                         | MSR_GLCP_SYS_RSTPLL_DOTPOSTDIV3 );
+        sys_rstpll |= pll_table[best_i].sys_rstpll_bits;
+
+        wrmsrl(MSR_GLCP_SYS_RSTPLL, sys_rstpll);
+
+        /* Clear reset bit to start PLL. */
+        dotpll &= ~(MSR_GLCP_DOTPLL_DOTRESET);
+        wrmsrl(MSR_GLCP_DOTPLL, dotpll);
+
+        /* Wait for LOCK bit. */
+        do {
+                rdmsrl(MSR_GLCP_DOTPLL, dotpll);
+        } while (timeout-- && !(dotpll & MSR_GLCP_DOTPLL_LOCK));
+}
+
+static void gx_configure_display(struct fb_info *info)
+{
+        struct geodefb_par *par = info->par;
+        u32 dcfg, fp_pm;
+
+        dcfg = readl(par->vid_regs + GX_DCFG);
+
+        /* Clear bits from existing mode. */
+        dcfg &= ~(GX_DCFG_CRT_SYNC_SKW_MASK
+                  | GX_DCFG_CRT_HSYNC_POL   | GX_DCFG_CRT_VSYNC_POL
+                  | GX_DCFG_VSYNC_EN        | GX_DCFG_HSYNC_EN);
+
+        /* Set default sync skew.  */
+        dcfg |= GX_DCFG_CRT_SYNC_SKW_DFLT;
+
+        /* Enable hsync and vsync. */
+        dcfg |= GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN;
+
+        /* Sync polarities. */
+        if (info->var.sync & FB_SYNC_HOR_HIGH_ACT)
+                dcfg |= GX_DCFG_CRT_HSYNC_POL;
+        if (info->var.sync & FB_SYNC_VERT_HIGH_ACT)
+                dcfg |= GX_DCFG_CRT_VSYNC_POL;
+
+        writel(dcfg, par->vid_regs + GX_DCFG);
+
+        /* Power on flat panel. */
+        fp_pm = readl(par->vid_regs + GX_FP_PM);
+        fp_pm |= GX_FP_PM_P;
+        writel(fp_pm, par->vid_regs + GX_FP_PM);
+}
+
+static int gx_blank_display(struct fb_info *info, int blank_mode)
+{
+        struct geodefb_par *par = info->par;
+        u32 dcfg, fp_pm;
+        int blank, hsync, vsync;
+
+        /* CRT power saving modes. */
+        switch (blank_mode) {
+        case FB_BLANK_UNBLANK:
+                blank = 0; hsync = 1; vsync = 1;
+                break;
+        case FB_BLANK_NORMAL:
+                blank = 1; hsync = 1; vsync = 1;
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+                blank = 1; hsync = 1; vsync = 0;
+                break;
+        case FB_BLANK_HSYNC_SUSPEND:
+                blank = 1; hsync = 0; vsync = 1;
+                break;
+        case FB_BLANK_POWERDOWN:
+                blank = 1; hsync = 0; vsync = 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+        dcfg = readl(par->vid_regs + GX_DCFG);
+        dcfg &= ~(GX_DCFG_DAC_BL_EN
+                  | GX_DCFG_HSYNC_EN | GX_DCFG_VSYNC_EN);
+        if (!blank)
+                dcfg |= GX_DCFG_DAC_BL_EN;
+        if (hsync)
+                dcfg |= GX_DCFG_HSYNC_EN;
+        if (vsync)
+                dcfg |= GX_DCFG_VSYNC_EN;
+        writel(dcfg, par->vid_regs + GX_DCFG);
+
+        /* Power on/off flat panel. */
+        fp_pm = readl(par->vid_regs + GX_FP_PM);
+        if (blank_mode == FB_BLANK_POWERDOWN)
+                fp_pm &= ~GX_FP_PM_P;
+        else
+                fp_pm |= GX_FP_PM_P;
+        writel(fp_pm, par->vid_regs + GX_FP_PM);
+
+        return 0;
+}
+
+struct geode_vid_ops gx_vid_ops = {
+        .set_dclk          = gx_set_dclk_frequency,
+        .configure_display = gx_configure_display,
+        .blank_display     = gx_blank_display,
+};
diff --git a/drivers/video/geode/video_gx.h b/drivers/video/geode/video_gx.h
new file mode 100644
index 000000000000..2d9211f3ed84
--- /dev/null
+++ b/drivers/video/geode/video_gx.h
@@ -0,0 +1,47 @@
+/*
+ * Geode GX video device
+ *
+ * Copyright (C) 2006 Arcom Control Systems Ltd.
+ *
+ * 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 __VIDEO_GX_H__
+#define __VIDEO_GX_H__
+
+extern struct geode_vid_ops gx_vid_ops;
+
+/* Geode GX video processor registers */
+
+#define GX_DCFG         0x0008
+#  define GX_DCFG_CRT_EN                0x00000001
+#  define GX_DCFG_HSYNC_EN              0x00000002
+#  define GX_DCFG_VSYNC_EN              0x00000004
+#  define GX_DCFG_DAC_BL_EN             0x00000008
+#  define GX_DCFG_CRT_HSYNC_POL         0x00000100
+#  define GX_DCFG_CRT_VSYNC_POL         0x00000200
+#  define GX_DCFG_CRT_SYNC_SKW_MASK     0x0001C000
+#  define GX_DCFG_CRT_SYNC_SKW_DFLT     0x00010000
+#  define GX_DCFG_VG_CK                 0x00100000
+#  define GX_DCFG_GV_GAM                0x00200000
+#  define GX_DCFG_DAC_VREF              0x04000000
+
+/* Geode GX flat panel display control registers */
+#define GX_FP_PM 0x410
+#  define GX_FP_PM_P 0x01000000
+
+/* Geode GX clock control MSRs */
+
+#define MSR_GLCP_SYS_RSTPLL     0x4c000014
+#  define MSR_GLCP_SYS_RSTPLL_DOTPREDIV2        (0x0000000000000002ull)
+#  define MSR_GLCP_SYS_RSTPLL_DOTPREMULT2       (0x0000000000000004ull)
+#  define MSR_GLCP_SYS_RSTPLL_DOTPOSTDIV3       (0x0000000000000008ull)
+
+#define MSR_GLCP_DOTPLL         0x4c000015
+#  define MSR_GLCP_DOTPLL_DOTRESET              (0x0000000000000001ull)
+#  define MSR_GLCP_DOTPLL_BYPASS                (0x0000000000008000ull)
+#  define MSR_GLCP_DOTPLL_LOCK                  (0x0000000002000000ull)
+
+#endif /* !__VIDEO_GX_H__ */
diff --git a/drivers/video/i810/i810-i2c.c b/drivers/video/i810/i810-i2c.c
index e3c8b5f1ca76..3fe3ae1aff12 100644
--- a/drivers/video/i810/i810-i2c.c
+++ b/drivers/video/i810/i810-i2c.c
@@ -210,8 +210,7 @@ int i810_probe_i2c_connector(struct fb_info *info, u8 **out_edid, int conn)
                 }
         }
 
-        if (out_edid)
-                *out_edid = edid;
+        *out_edid = edid;
 
         return (edid) ? 0 : 1;
 }
diff --git a/drivers/video/imsttfb.c b/drivers/video/imsttfb.c
index 7db42542eb19..f73c642b50c2 100644
--- a/drivers/video/imsttfb.c
+++ b/drivers/video/imsttfb.c
@@ -440,9 +440,9 @@ getclkMHz(struct imstt_par *par)
 static void
 setclkMHz(struct imstt_par *par, __u32 MHz)
 {
-        __u32 clk_m, clk_n, clk_p, x, stage, spilled;
+        __u32 clk_m, clk_n, x, stage, spilled;
 
-        clk_m = clk_n = clk_p = 0;
+        clk_m = clk_n = 0;
         stage = spilled = 0;
         for (;;) {
                 switch (stage) {
@@ -453,7 +453,7 @@ setclkMHz(struct imstt_par *par, __u32 MHz)
                                 clk_n++;
                                 break;
                 }
-                x = 20 * (clk_m + 1) / ((clk_n + 1) * (clk_p ? 2 * clk_p : 1));
+                x = 20 * (clk_m + 1) / (clk_n + 1);
                 if (x == MHz)
                         break;
                 if (x > MHz) {
@@ -466,7 +466,7 @@ setclkMHz(struct imstt_par *par, __u32 MHz)
 
         par->init.pclk_m = clk_m;
         par->init.pclk_n = clk_n;
-        par->init.pclk_p = clk_p;
+        par->init.pclk_p = 0;
 }
 
 static struct imstt_regvals *
@@ -1372,18 +1372,24 @@ init_imstt(struct fb_info *info)
         write_reg_le32(par->dc_regs, STGCTL, tmp & ~0x1);
         write_reg_le32(par->dc_regs, SSR, 0);
 
-        /* set default values for DAC registers */ 
+        /* set default values for DAC registers */
         if (par->ramdac == IBM) {
-                par->cmap_regs[PPMASK] = 0xff;  eieio();
-                par->cmap_regs[PIDXHI] = 0;     eieio();
-                for (i = 0; i < sizeof(ibm_initregs) / sizeof(*ibm_initregs); i++) {
-                        par->cmap_regs[PIDXLO] = ibm_initregs[i].addr;  eieio();
-                        par->cmap_regs[PIDXDATA] = ibm_initregs[i].value;       eieio();
+                par->cmap_regs[PPMASK] = 0xff;
+                eieio();
+                par->cmap_regs[PIDXHI] = 0;
+                eieio();
+                for (i = 0; i < ARRAY_SIZE(ibm_initregs); i++) {
+                        par->cmap_regs[PIDXLO] = ibm_initregs[i].addr;
+                        eieio();
+                        par->cmap_regs[PIDXDATA] = ibm_initregs[i].value;
+                        eieio();
                 }
         } else {
-                for (i = 0; i < sizeof(tvp_initregs) / sizeof(*tvp_initregs); i++) {
-                        par->cmap_regs[TVPADDRW] = tvp_initregs[i].addr;        eieio();
-                        par->cmap_regs[TVPIDATA] = tvp_initregs[i].value;       eieio();
+                for (i = 0; i < ARRAY_SIZE(tvp_initregs); i++) {
+                        par->cmap_regs[TVPADDRW] = tvp_initregs[i].addr;
+                        eieio();
+                        par->cmap_regs[TVPIDATA] = tvp_initregs[i].value;
+                        eieio();
                 }
         }
 
diff --git a/drivers/video/macmodes.c b/drivers/video/macmodes.c
index 2fc71081f7e7..c0385c6f7db5 100644
--- a/drivers/video/macmodes.c
+++ b/drivers/video/macmodes.c
@@ -380,7 +380,7 @@ int __init mac_find_mode(struct fb_var_screeninfo *var, struct fb_info *info,
     if (mode_option && !strncmp(mode_option, "mac", 3)) {
         mode_option += 3;
         db = mac_modedb;
-        dbsize = sizeof(mac_modedb)/sizeof(*mac_modedb);
+        dbsize = ARRAY_SIZE(mac_modedb);
     }
     return fb_find_mode(var, info, mode_option, db, dbsize,
                         &mac_modedb[DEFAULT_MODEDB_INDEX], default_bpp);
diff --git a/drivers/video/matrox/matroxfb_g450.c b/drivers/video/matrox/matroxfb_g450.c
index c122d8743dd2..4d610b405d45 100644
--- a/drivers/video/matrox/matroxfb_g450.c
+++ b/drivers/video/matrox/matroxfb_g450.c
@@ -59,7 +59,7 @@ static const struct mctl g450_controls[] =
         }, offsetof(struct matrox_fb_info, altout.tvo_params.testout) },
 };
 
-#define G450CTRLS (sizeof(g450_controls)/sizeof(g450_controls[0]))
+#define G450CTRLS ARRAY_SIZE(g450_controls)
 
 /* Return: positive number: id found
            -EINVAL:         id not found, return failure
diff --git a/drivers/video/matrox/matroxfb_maven.c b/drivers/video/matrox/matroxfb_maven.c
index 6019710dc298..5d29a26b8cdf 100644
--- a/drivers/video/matrox/matroxfb_maven.c
+++ b/drivers/video/matrox/matroxfb_maven.c
@@ -89,12 +89,12 @@ static const struct mctl maven_controls[] =
         }, offsetof(struct matrox_fb_info, altout.tvo_params.hue) },
         { { V4L2_CID_GAMMA, V4L2_CTRL_TYPE_INTEGER,
           "gamma",
-          0, sizeof(maven_gamma)/sizeof(maven_gamma[0])-1, 1, 3,
+          0, ARRAY_SIZE(maven_gamma) - 1, 1, 3,
           0,
         }, offsetof(struct matrox_fb_info, altout.tvo_params.gamma) },
         { { MATROXFB_CID_TESTOUT, V4L2_CTRL_TYPE_BOOLEAN,
           "test output",
-          0, 1, 1, 0, 
+          0, 1, 1, 0,
           0,
         }, offsetof(struct matrox_fb_info, altout.tvo_params.testout) },
         { { MATROXFB_CID_DEFLICKER, V4L2_CTRL_TYPE_INTEGER,
@@ -105,7 +105,7 @@ static const struct mctl maven_controls[] =
 
 };
 
-#define MAVCTRLS (sizeof(maven_controls)/sizeof(maven_controls[0]))
+#define MAVCTRLS ARRAY_SIZE(maven_controls)
 
 /* Return: positive number: id found
            -EINVAL:         id not found, return failure
@@ -129,7 +129,7 @@ static int get_ctrl_id(__u32 v4l2_id) {
 
 struct maven_data {
         struct matrox_fb_info*          primary_head;
-        struct i2c_client*              client;
+        struct i2c_client               client;
         int                             version;
 };
 
@@ -970,7 +970,7 @@ static inline int maven_compute_timming(struct maven_data* md,
 
 static int maven_program_timming(struct maven_data* md,
                 const struct mavenregs* m) {
-        struct i2c_client* c = md->client;
+        struct i2c_client* c = &md->client;
 
         if (m->mode == MATROXFB_OUTPUT_MODE_MONITOR) {
                 LR(0x80);
@@ -1007,7 +1007,7 @@ static int maven_program_timming(struct maven_data* md,
 }
 
 static inline int maven_resync(struct maven_data* md) {
-        struct i2c_client* c = md->client;
+        struct i2c_client* c = &md->client;
         maven_set_reg(c, 0x95, 0x20);   /* start whole thing */
         return 0;
 }
@@ -1065,48 +1065,48 @@ static int maven_set_control (struct maven_data* md,
                   maven_compute_bwlevel(md, &blacklevel, &whitelevel);
                   blacklevel = (blacklevel >> 2) | ((blacklevel & 3) << 8);
                   whitelevel = (whitelevel >> 2) | ((whitelevel & 3) << 8);
-                  maven_set_reg_pair(md->client, 0x0e, blacklevel);
-                  maven_set_reg_pair(md->client, 0x1e, whitelevel);
+                  maven_set_reg_pair(&md->client, 0x0e, blacklevel);
+                  maven_set_reg_pair(&md->client, 0x1e, whitelevel);
                 }
                 break;
                 case V4L2_CID_SATURATION:
                 {
-                  maven_set_reg(md->client, 0x20, p->value);
-                  maven_set_reg(md->client, 0x22, p->value);
+                  maven_set_reg(&md->client, 0x20, p->value);
+                  maven_set_reg(&md->client, 0x22, p->value);
                 }
                 break;
                 case V4L2_CID_HUE:
                 {
-                  maven_set_reg(md->client, 0x25, p->value);
+                  maven_set_reg(&md->client, 0x25, p->value);
                 }
                 break;
                 case V4L2_CID_GAMMA:
                 {
                   const struct maven_gamma* g;
                   g = maven_compute_gamma(md);
-                  maven_set_reg(md->client, 0x83, g->reg83);
-                  maven_set_reg(md->client, 0x84, g->reg84);
-                  maven_set_reg(md->client, 0x85, g->reg85);
-                  maven_set_reg(md->client, 0x86, g->reg86);
-                  maven_set_reg(md->client, 0x87, g->reg87);
-                  maven_set_reg(md->client, 0x88, g->reg88);
-                  maven_set_reg(md->client, 0x89, g->reg89);
-                  maven_set_reg(md->client, 0x8a, g->reg8a);
-                  maven_set_reg(md->client, 0x8b, g->reg8b);
+                  maven_set_reg(&md->client, 0x83, g->reg83);
+                  maven_set_reg(&md->client, 0x84, g->reg84);
+                  maven_set_reg(&md->client, 0x85, g->reg85);
+                  maven_set_reg(&md->client, 0x86, g->reg86);
+                  maven_set_reg(&md->client, 0x87, g->reg87);
+                  maven_set_reg(&md->client, 0x88, g->reg88);
+                  maven_set_reg(&md->client, 0x89, g->reg89);
+                  maven_set_reg(&md->client, 0x8a, g->reg8a);
+                  maven_set_reg(&md->client, 0x8b, g->reg8b);
                 }
                 break;
                 case MATROXFB_CID_TESTOUT:
                 {
                         unsigned char val 
-                          = maven_get_reg (md->client,0x8d);
+                          = maven_get_reg(&md->client,0x8d);
                         if (p->value) val |= 0x10;
                         else          val &= ~0x10;
-                        maven_set_reg (md->client, 0x8d, val);
+                        maven_set_reg(&md->client, 0x8d, val);
                 }
                 break;
                 case MATROXFB_CID_DEFLICKER:
                 {
-                  maven_set_reg(md->client, 0x93, maven_compute_deflicker(md));
+                  maven_set_reg(&md->client, 0x93, maven_compute_deflicker(md));
                 }
                 break;
         }
@@ -1185,7 +1185,6 @@ static int maven_init_client(struct i2c_client* clnt) {
         MINFO_FROM(container_of(clnt->adapter, struct i2c_bit_adapter, adapter)->minfo);
 
         md->primary_head = MINFO;
-        md->client = clnt;
         down_write(&ACCESS_FBINFO(altout.lock));
         ACCESS_FBINFO(outputs[1]).output = &maven_altout;
         ACCESS_FBINFO(outputs[1]).src = ACCESS_FBINFO(outputs[1]).default_src;
@@ -1243,19 +1242,17 @@ static int maven_detect_client(struct i2c_adapter* adapter, int address, int kin
                                               I2C_FUNC_SMBUS_BYTE_DATA |
                                               I2C_FUNC_PROTOCOL_MANGLING))
                 goto ERROR0;
-        if (!(new_client = (struct i2c_client*)kmalloc(sizeof(*new_client) + sizeof(*data),
-                        GFP_KERNEL))) {
+        if (!(data = kzalloc(sizeof(*data), GFP_KERNEL))) {
                 err = -ENOMEM;
                 goto ERROR0;
         }
-        memset(new_client, 0, sizeof(*new_client) + sizeof(*data));
-        data = (struct maven_data*)(new_client + 1);
+        new_client = &data->client;
         i2c_set_clientdata(new_client, data);
         new_client->addr = address;
         new_client->adapter = adapter;
         new_client->driver = &maven_driver;
         new_client->flags = 0;
-        strcpy(new_client->name, "maven client");
+        strlcpy(new_client->name, "maven", I2C_NAME_SIZE);
         if ((err = i2c_attach_client(new_client)))
                 goto ERROR3;
         err = maven_init_client(new_client);
@@ -1279,12 +1276,10 @@ static int maven_attach_adapter(struct i2c_adapter* adapter) {
 static int maven_detach_client(struct i2c_client* client) {
         int err;
 
-        if ((err = i2c_detach_client(client))) {
-                printk(KERN_ERR "maven: Cannot deregister client\n");
+        if ((err = i2c_detach_client(client)))
                 return err;
-        }
         maven_shutdown_client(client);
-        kfree(client);
+        kfree(i2c_get_clientdata(client));
         return 0;
 }
 
@@ -1297,20 +1292,13 @@ static struct i2c_driver maven_driver={
         .detach_client  = maven_detach_client,
 };
 
-/* ************************** */
-
-static int matroxfb_maven_init(void) {
-        int err;
-
-        err = i2c_add_driver(&maven_driver);
-        if (err) {
-                printk(KERN_ERR "maven: Maven driver failed to register (%d).\n", err);
-                return err;
-        }
-        return 0;
+static int __init matroxfb_maven_init(void)
+{
+        return i2c_add_driver(&maven_driver);
 }
 
-static void matroxfb_maven_exit(void) {
+static void __exit matroxfb_maven_exit(void)
+{
         i2c_del_driver(&maven_driver);
 }
 
diff --git a/drivers/video/modedb.c b/drivers/video/modedb.c
index 1da2f84bdc25..26a1c618a205 100644
--- a/drivers/video/modedb.c
+++ b/drivers/video/modedb.c
@@ -183,6 +183,10 @@ static const struct fb_videomode modedb[] = {
         NULL, 75, 1600, 1200, 4938, 304, 64, 46, 1, 192, 3,
         FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
     }, {
+        /* 1680x1050 @ 60 Hz, 65.191 kHz hsync */
+        NULL, 60, 1680, 1050, 6848, 280, 104, 30, 3, 176, 6,
+        FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
+    }, {
         /* 1600x1200 @ 85 Hz, 105.77 kHz hsync */
         NULL, 85, 1600, 1200, 4545, 272, 16, 37, 4, 192, 3,
         FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
@@ -496,7 +500,7 @@ int fb_find_mode(struct fb_var_screeninfo *var,
     /* Set up defaults */
     if (!db) {
         db = modedb;
-        dbsize = sizeof(modedb)/sizeof(*modedb);
+        dbsize = ARRAY_SIZE(modedb);
     }
     if (!default_mode)
         default_mode = &modedb[DEFAULT_MODEDB_INDEX];
diff --git a/drivers/video/neofb.c b/drivers/video/neofb.c
index b961d5601bd9..24b12f71d5a8 100644
--- a/drivers/video/neofb.c
+++ b/drivers/video/neofb.c
@@ -165,20 +165,20 @@ static int neoFindMode(int xres, int yres, int depth)
 
         switch (depth) {
         case 8:
-                size = sizeof(bios8) / sizeof(biosMode);
+                size = ARRAY_SIZE(bios8);
                 mode = bios8;
                 break;
         case 16:
-                size = sizeof(bios16) / sizeof(biosMode);
+                size = ARRAY_SIZE(bios16);
                 mode = bios16;
                 break;
         case 24:
-                size = sizeof(bios24) / sizeof(biosMode);
+                size = ARRAY_SIZE(bios24);
                 mode = bios24;
                 break;
 #ifdef NO_32BIT_SUPPORT_YET
         case 32:
-                size = sizeof(bios32) / sizeof(biosMode);
+                size = ARRAY_SIZE(bios32);
                 mode = bios32;
                 break;
 #endif
diff --git a/drivers/video/nvidia/nv_accel.c b/drivers/video/nvidia/nv_accel.c
index f377a29ec97a..4aefb8f41637 100644
--- a/drivers/video/nvidia/nv_accel.c
+++ b/drivers/video/nvidia/nv_accel.c
@@ -300,6 +300,9 @@ int nvidiafb_sync(struct fb_info *info)
 {
         struct nvidia_par *par = info->par;
 
+        if (info->state != FBINFO_STATE_RUNNING)
+                return 0;
+
         if (!par->lockup)
                 NVFlush(par);
 
@@ -313,6 +316,9 @@ void nvidiafb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
 {
         struct nvidia_par *par = info->par;
 
+        if (info->state != FBINFO_STATE_RUNNING)
+                return;
+
         if (par->lockup)
                 return cfb_copyarea(info, region);
 
@@ -329,6 +335,9 @@ void nvidiafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
         struct nvidia_par *par = info->par;
         u32 color;
 
+        if (info->state != FBINFO_STATE_RUNNING)
+                return;
+
         if (par->lockup)
                 return cfb_fillrect(info, rect);
 
@@ -412,6 +421,9 @@ void nvidiafb_imageblit(struct fb_info *info, const struct fb_image *image)
 {
         struct nvidia_par *par = info->par;
 
+        if (info->state != FBINFO_STATE_RUNNING)
+                return;
+
         if (image->depth == 1 && !par->lockup)
                 nvidiafb_mono_color_expand(info, image);
         else
diff --git a/drivers/video/nvidia/nv_i2c.c b/drivers/video/nvidia/nv_i2c.c
index bd9eca05e146..1edb1c432b75 100644
--- a/drivers/video/nvidia/nv_i2c.c
+++ b/drivers/video/nvidia/nv_i2c.c
@@ -218,8 +218,7 @@ int nvidia_probe_i2c_connector(struct fb_info *info, int conn, u8 **out_edid)
                 }
         }
 
-        if (out_edid)
-                *out_edid = edid;
+        *out_edid = edid;
 
         return (edid) ? 0 : 1;
 }
diff --git a/drivers/video/nvidia/nv_type.h b/drivers/video/nvidia/nv_type.h
index e4a5b1da71c4..acdc26693402 100644
--- a/drivers/video/nvidia/nv_type.h
+++ b/drivers/video/nvidia/nv_type.h
@@ -129,6 +129,7 @@ struct nvidia_par {
         int fpHeight;
         int PanelTweak;
         int paneltweak;
+        int pm_state;
         u32 crtcSync_read;
         u32 fpSyncs;
         u32 dmaPut;
diff --git a/drivers/video/nvidia/nvidia.c b/drivers/video/nvidia/nvidia.c
index 7258b3245316..093ab9977c7c 100644
--- a/drivers/video/nvidia/nvidia.c
+++ b/drivers/video/nvidia/nvidia.c
@@ -21,6 +21,7 @@
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/pci.h>
+#include <linux/console.h>
 #ifdef CONFIG_MTRR
 #include <asm/mtrr.h>
 #endif
@@ -297,6 +298,8 @@ static struct pci_device_id nvidiafb_pci_tbl[] = {
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_NVIDIA, PCIE_DEVICE_ID_NVIDIA_GEFORCE_6800_GT,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        {PCI_VENDOR_ID_NVIDIA, PCIE_DEVICE_ID_NVIDIA_QUADRO_NVS280,
+         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_NVIDIA, 0x0252,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_NVIDIA, 0x0313,
@@ -616,6 +619,30 @@ static int nvidia_panel_tweak(struct nvidia_par *par,
    return tweak;
 }
 
+static void nvidia_vga_protect(struct nvidia_par *par, int on)
+{
+        unsigned char tmp;
+
+        if (on) {
+                /*
+                 * Turn off screen and disable sequencer.
+                 */
+                tmp = NVReadSeq(par, 0x01);
+
+                NVWriteSeq(par, 0x00, 0x01);            /* Synchronous Reset */
+                NVWriteSeq(par, 0x01, tmp | 0x20);      /* disable the display */
+        } else {
+                /*
+                 * Reenable sequencer, then turn on screen.
+                 */
+
+                tmp = NVReadSeq(par, 0x01);
+
+                NVWriteSeq(par, 0x01, tmp & ~0x20);     /* reenable display */
+                NVWriteSeq(par, 0x00, 0x03);            /* End Reset */
+        }
+}
+
 static void nvidia_save_vga(struct nvidia_par *par,
                             struct _riva_hw_state *state)
 {
@@ -644,9 +671,9 @@ static void nvidia_save_vga(struct nvidia_par *par,
 
 #undef DUMP_REG
 
-static void nvidia_write_regs(struct nvidia_par *par)
+static void nvidia_write_regs(struct nvidia_par *par,
+                              struct _riva_hw_state *state)
 {
-        struct _riva_hw_state *state = &par->ModeReg;
         int i;
 
         NVTRACE_ENTER();
@@ -695,32 +722,6 @@ static void nvidia_write_regs(struct nvidia_par *par)
         NVTRACE_LEAVE();
 }
 
-static void nvidia_vga_protect(struct nvidia_par *par, int on)
-{
-        unsigned char tmp;
-
-        if (on) {
-                /*
-                 * Turn off screen and disable sequencer.
-                 */
-                tmp = NVReadSeq(par, 0x01);
-
-                NVWriteSeq(par, 0x00, 0x01);            /* Synchronous Reset */
-                NVWriteSeq(par, 0x01, tmp | 0x20);      /* disable the display */
-        } else {
-                /*
-                 * Reenable sequencer, then turn on screen.
-                 */
-
-                tmp = NVReadSeq(par, 0x01);
-
-                NVWriteSeq(par, 0x01, tmp & ~0x20);     /* reenable display */
-                NVWriteSeq(par, 0x00, 0x03);            /* End Reset */
-        }
-}
-
-
-
 static int nvidia_calc_regs(struct fb_info *info)
 {
         struct nvidia_par *par = info->par;
@@ -1069,7 +1070,8 @@ static int nvidiafb_set_par(struct fb_info *info)
 
         nvidia_vga_protect(par, 1);
 
-        nvidia_write_regs(par);
+        nvidia_write_regs(par, &par->ModeReg);
+        NVSetStartAddress(par, 0);
 
 #if defined (__BIG_ENDIAN)
         /* turn on LFB swapping */
@@ -1378,6 +1380,57 @@ static struct fb_ops nvidia_fb_ops = {
         .fb_sync        = nvidiafb_sync,
 };
 
+#ifdef CONFIG_PM
+static int nvidiafb_suspend(struct pci_dev *dev, pm_message_t state)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct nvidia_par *par = info->par;
+
+        acquire_console_sem();
+        par->pm_state = state.event;
+
+        if (state.event == PM_EVENT_FREEZE) {
+                dev->dev.power.power_state = state;
+        } else {
+                fb_set_suspend(info, 1);
+                nvidiafb_blank(FB_BLANK_POWERDOWN, info);
+                nvidia_write_regs(par, &par->SavedReg);
+                pci_save_state(dev);
+                pci_disable_device(dev);
+                pci_set_power_state(dev, pci_choose_state(dev, state));
+        }
+
+        release_console_sem();
+        return 0;
+}
+
+static int nvidiafb_resume(struct pci_dev *dev)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct nvidia_par *par = info->par;
+
+        acquire_console_sem();
+        pci_set_power_state(dev, PCI_D0);
+
+        if (par->pm_state != PM_EVENT_FREEZE) {
+                pci_restore_state(dev);
+                pci_enable_device(dev);
+                pci_set_master(dev);
+        }
+
+        par->pm_state = PM_EVENT_ON;
+        nvidiafb_set_par(info);
+        fb_set_suspend (info, 0);
+        nvidiafb_blank(FB_BLANK_UNBLANK, info);
+
+        release_console_sem();
+        return 0;
+}
+#else
+#define nvidiafb_suspend NULL
+#define nvidiafb_resume NULL
+#endif
+
 static int __devinit nvidia_set_fbinfo(struct fb_info *info)
 {
         struct fb_monspecs *specs = &info->monspecs;
@@ -1721,8 +1774,6 @@ static void __exit nvidiafb_remove(struct pci_dev *pd)
         struct nvidia_par *par = info->par;
 
         NVTRACE_ENTER();
-        if (!info)
-                return;
 
         unregister_framebuffer(info);
 #ifdef CONFIG_MTRR
@@ -1799,8 +1850,10 @@ static int __devinit nvidiafb_setup(char *options)
 static struct pci_driver nvidiafb_driver = {
         .name = "nvidiafb",
         .id_table = nvidiafb_pci_tbl,
-        .probe = nvidiafb_probe,
-        .remove = __exit_p(nvidiafb_remove),
+        .probe    = nvidiafb_probe,
+        .suspend  = nvidiafb_suspend,
+        .resume   = nvidiafb_resume,
+        .remove   = __exit_p(nvidiafb_remove),
 };
 
 /* ------------------------------------------------------------------------- *
diff --git a/drivers/video/pmagb-b-fb.c b/drivers/video/pmagb-b-fb.c
index eeeac924b500..73e2d7d16608 100644
--- a/drivers/video/pmagb-b-fb.c
+++ b/drivers/video/pmagb-b-fb.c
@@ -228,7 +228,7 @@ static void __init pmagbbfb_osc_setup(struct fb_info *info)
 
         freq1 = (par->osc0 * count1 + count0 / 2) / count0;
         par->osc1 = freq1;
-        for (i = 0; i < sizeof(pmagbbfb_freqs) / sizeof(*pmagbbfb_freqs); i++)
+        for (i = 0; i < ARRAY_SIZE(pmagbbfb_freqs); i++)
                 if (freq1 >= pmagbbfb_freqs[i] -
                              (pmagbbfb_freqs[i] + 128) / 256 &&
                     freq1 <= pmagbbfb_freqs[i] +
diff --git a/drivers/video/radeonfb.c b/drivers/video/radeonfb.c
index 04820fab964c..afb6c2ead599 100644
--- a/drivers/video/radeonfb.c
+++ b/drivers/video/radeonfb.c
@@ -759,7 +759,7 @@ static void __iomem *radeon_find_rom(struct radeonfb_info *rinfo)
                 rom = rom_base;
         
                 for (i = 0; (i < 512) && (stage != 4); i++) {
-                    for(j = 0;j < sizeof(radeon_sig)/sizeof(char *);j++) {
+                    for (j = 0; j < ARRAY_SIZE(radeon_sig); j++) {
                         if (radeon_sig[j][0] == *rom)
                                 if (strncmp(radeon_sig[j], rom,
                                             strlen(radeon_sig[j])) == 0) {
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index b7bd6bb2c77c..3e9308f0f165 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -2073,8 +2073,6 @@ static void __exit rivafb_remove(struct pci_dev *pd)
         struct riva_par *par = info->par;
         
         NVTRACE_ENTER();
-        if (!info)
-                return;
 
 #ifdef CONFIG_FB_RIVA_I2C
         riva_delete_i2c_busses(par);
diff --git a/drivers/video/savage/savagefb-i2c.c b/drivers/video/savage/savagefb-i2c.c
index 00719a91479f..21debed863ac 100644
--- a/drivers/video/savage/savagefb-i2c.c
+++ b/drivers/video/savage/savagefb-i2c.c
@@ -273,8 +273,7 @@ int savagefb_probe_i2c_connector(struct fb_info *info, u8 **out_edid)
                 }
         }
 
-        if (out_edid)
-                *out_edid = edid;
+        *out_edid = edid;
 
         return (edid) ? 0 : 1;
 }
diff --git a/drivers/video/sis/init301.c b/drivers/video/sis/init301.c
index 2d88f908170a..c3e070a6effd 100644
--- a/drivers/video/sis/init301.c
+++ b/drivers/video/sis/init301.c
@@ -8564,11 +8564,9 @@ SiS_ChrontelDoSomething3(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
 static void
 SiS_ChrontelDoSomething2(struct SiS_Private *SiS_Pr)
 {
-     unsigned short temp,tempcl,tempch;
+     unsigned short temp;
 
      SiS_LongDelay(SiS_Pr, 1);
-     tempcl = 3;
-     tempch = 0;
 
      do {
        temp = SiS_GetCH701x(SiS_Pr,0x66);
@@ -8582,13 +8580,6 @@ SiS_ChrontelDoSomething2(struct SiS_Private *SiS_Pr)
 
        SiS_SetCH701xForLCD(SiS_Pr);
 
-       if(tempcl == 0) {
-           if(tempch == 3) break;
-           SiS_ChrontelResetDB(SiS_Pr);
-           tempcl = 3;
-           tempch++;
-       }
-       tempcl--;
        temp = SiS_GetCH701x(SiS_Pr,0x76);
        temp &= 0xfb;  /* Reset PLL */
        SiS_SetCH701x(SiS_Pr,0x76,temp);
diff --git a/drivers/video/sstfb.c b/drivers/video/sstfb.c
index 8c1a8b5135c6..c44de90ca12e 100644
--- a/drivers/video/sstfb.c
+++ b/drivers/video/sstfb.c
@@ -1194,10 +1194,11 @@ static struct dac_switch dacs[] __devinitdata = {
 static int __devinit sst_detect_dactype(struct fb_info *info, struct sstfb_par *par)
 {
         int i, ret = 0;
-        
-        for (i=0; i<sizeof(dacs)/sizeof(dacs[0]); i++) {
+
+        for (i = 0; i < ARRAY_SIZE(dacs); i++) {
                 ret = dacs[i].detect(info);
-                if (ret) break;
+                if (ret)
+                        break;
         }
         if (!ret)
                 return 0;
@@ -1604,8 +1605,8 @@ static int sstfb_dump_regs(struct fb_info *info)
                 {FBZMODE,"fbzmode"},
         };
 
-        const int pci_s = sizeof(pci_regs)/sizeof(pci_regs[0]);
-        const int sst_s = sizeof(sst_regs)/sizeof(sst_regs[0]);
+        const int pci_s = ARRAY_SIZE(pci_regs);
+        const int sst_s = ARRAY_SIZE(sst_regs);
         struct sstfb_par *par = info->par;
         struct pci_dev *dev = par->dev;
         u32 pci_res[pci_s];
diff --git a/drivers/video/virgefb.c b/drivers/video/virgefb.c
index ed78747487e2..5ea2345dab99 100644
--- a/drivers/video/virgefb.c
+++ b/drivers/video/virgefb.c
@@ -616,8 +616,7 @@ static struct {
 #endif
 };
 
-#define arraysize(x)    (sizeof(x)/sizeof(*(x)))
-#define NUM_TOTAL_MODES arraysize(virgefb_predefined)
+#define NUM_TOTAL_MODES ARRAY_SIZE(virgefb_predefined)
 
 /*
  *    Default to 800x600 for video=virge8:, virge16: or virge32: