313 files changed, 14177 insertions, 7025 deletions

diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 4334c208841a..41427a41f620 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -245,6 +245,35 @@ arch_initcall(init_acpi_device_notify);
 
 #if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
 
+#ifdef CONFIG_PM
+static u32 rtc_handler(void *context)
+{
+        acpi_clear_event(ACPI_EVENT_RTC);
+        acpi_disable_event(ACPI_EVENT_RTC, 0);
+        return ACPI_INTERRUPT_HANDLED;
+}
+
+static inline void rtc_wake_setup(void)
+{
+        acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
+}
+
+static void rtc_wake_on(struct device *dev)
+{
+        acpi_clear_event(ACPI_EVENT_RTC);
+        acpi_enable_event(ACPI_EVENT_RTC, 0);
+}
+
+static void rtc_wake_off(struct device *dev)
+{
+        acpi_disable_event(ACPI_EVENT_RTC, 0);
+}
+#else
+#define rtc_wake_setup()        do{}while(0)
+#define rtc_wake_on             NULL
+#define rtc_wake_off            NULL
+#endif
+
 /* Every ACPI platform has a mc146818 compatible "cmos rtc".  Here we find
  * its device node and pass extra config data.  This helps its driver use
  * capabilities that the now-obsolete mc146818 didn't have, and informs it
@@ -283,11 +312,24 @@ static int __init acpi_rtc_init(void)
         struct device *dev = get_rtc_dev();
 
         if (dev) {
+                rtc_wake_setup();
+                rtc_info.wake_on = rtc_wake_on;
+                rtc_info.wake_off = rtc_wake_off;
+
+                /* workaround bug in some ACPI tables */
+                if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
+                        DBG("bogus FADT month_alarm\n");
+                        acpi_gbl_FADT.month_alarm = 0;
+                }
+
                 rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
                 rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
                 rtc_info.rtc_century = acpi_gbl_FADT.century;
 
-                /* NOTE:  acpi_gbl_FADT->rtcs4 is NOT currently useful */
+                /* NOTE:  S4_RTC_WAKE is NOT currently useful to Linux */
+                if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
+                        printk(PREFIX "RTC can wake from S4\n");
+
 
                 dev->platform_data = &rtc_info;
 
@@ -296,7 +338,7 @@ static int __init acpi_rtc_init(void)
 
                 put_device(dev);
         } else
-                pr_debug("ACPI: RTC unavailable?\n");
+                DBG("RTC unavailable?\n");
         return 0;
 }
 /* do this between RTC subsys_initcall() and rtc_cmos driver_initcall() */
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index 8fcd6a15517f..4dd0dabe81cb 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -228,7 +228,7 @@ int __init acpi_numa_init(void)
         return 0;
 }
 
-int acpi_get_pxm(acpi_handle h)
+int __meminit acpi_get_pxm(acpi_handle h)
 {
         unsigned long pxm;
         acpi_status status;
@@ -246,7 +246,7 @@ int acpi_get_pxm(acpi_handle h)
 }
 EXPORT_SYMBOL(acpi_get_pxm);
 
-int acpi_get_node(acpi_handle *handle)
+int __meminit acpi_get_node(acpi_handle *handle)
 {
         int pxm, node = -1;
 
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 971eca4864fa..c2bed56915e1 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -30,7 +30,6 @@
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/pci.h>
-#include <linux/smp_lock.h>
 #include <linux/interrupt.h>
 #include <linux/kmod.h>
 #include <linux/delay.h>
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index d80dd84e5bfd..6b3b8a522476 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -302,7 +302,7 @@ static void acpi_device_shutdown(struct device *dev)
         return ;
 }
 
-static struct bus_type acpi_bus_type = {
+struct bus_type acpi_bus_type = {
         .name           = "acpi",
         .suspend        = acpi_device_suspend,
         .resume         = acpi_device_resume,
diff --git a/drivers/acpi/sleep/proc.c b/drivers/acpi/sleep/proc.c
index dcde9ddd105a..5a76e5be61d5 100644
--- a/drivers/acpi/sleep/proc.c
+++ b/drivers/acpi/sleep/proc.c
@@ -70,6 +70,14 @@ acpi_system_write_sleep(struct file *file,
 }
 #endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
 
+#if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
+/* use /sys/class/rtc/rtcX/wakealarm instead; it's not ACPI-specific */
+#else
+#define HAVE_ACPI_LEGACY_ALARM
+#endif
+
+#ifdef  HAVE_ACPI_LEGACY_ALARM
+
 static int acpi_system_alarm_seq_show(struct seq_file *seq, void *offset)
 {
         u32 sec, min, hr;
@@ -341,6 +349,8 @@ acpi_system_write_alarm(struct file *file,
       end:
         return_VALUE(result ? result : count);
 }
+#endif  /* HAVE_ACPI_LEGACY_ALARM */
+
 
 extern struct list_head acpi_wakeup_device_list;
 extern spinlock_t acpi_device_lock;
@@ -464,6 +474,7 @@ static const struct file_operations acpi_system_sleep_fops = {
 };
 #endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
 
+#ifdef  HAVE_ACPI_LEGACY_ALARM
 static const struct file_operations acpi_system_alarm_fops = {
         .open = acpi_system_alarm_open_fs,
         .read = seq_read,
@@ -479,8 +490,9 @@ static u32 rtc_handler(void *context)
 
         return ACPI_INTERRUPT_HANDLED;
 }
+#endif  /* HAVE_ACPI_LEGACY_ALARM */
 
-static int acpi_sleep_proc_init(void)
+static int __init acpi_sleep_proc_init(void)
 {
         struct proc_dir_entry *entry = NULL;
 
@@ -496,6 +508,7 @@ static int acpi_sleep_proc_init(void)
                 entry->proc_fops = &acpi_system_sleep_fops;
 #endif
 
+#ifdef  HAVE_ACPI_LEGACY_ALARM
         /* 'alarm' [R/W] */
         entry =
             create_proc_entry("alarm", S_IFREG | S_IRUGO | S_IWUSR,
@@ -503,6 +516,9 @@ static int acpi_sleep_proc_init(void)
         if (entry)
                 entry->proc_fops = &acpi_system_alarm_fops;
 
+        acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
+#endif  /* HAVE_ACPI_LEGACY_ALARM */
+
         /* 'wakeup device' [R/W] */
         entry =
             create_proc_entry("wakeup", S_IFREG | S_IRUGO | S_IWUSR,
@@ -510,7 +526,6 @@ static int acpi_sleep_proc_init(void)
         if (entry)
                 entry->proc_fops = &acpi_system_wakeup_device_fops;
 
-        acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
         return 0;
 }
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 17b5ece8f82c..eb84d9d44645 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -160,6 +160,11 @@ static void platform_device_release(struct device *dev)
  *
  *      Create a platform device object which can have other objects attached
  *      to it, and which will have attached objects freed when it is released.
+ *
+ *      This device will be marked as not supporting hotpluggable drivers; no
+ *      device add/remove uevents will be generated.  In the unusual case that
+ *      the device isn't being dynamically allocated as a legacy "probe the
+ *      hardware" driver, infrastructure code should reverse this marking.
  */
 struct platform_device *platform_device_alloc(const char *name, unsigned int id)
 {
@@ -172,6 +177,12 @@ struct platform_device *platform_device_alloc(const char *name, unsigned int id)
                 pa->pdev.id = id;
                 device_initialize(&pa->pdev.dev);
                 pa->pdev.dev.release = platform_device_release;
+
+                /* prevent hotplug "modprobe $(MODALIAS)" from causing trouble in
+                 * legacy probe-the-hardware drivers, which don't properly split
+                 * out device enumeration logic from drivers.
+                 */
+                pa->pdev.dev.uevent_suppress = 1;
         }
 
         return pa ? &pa->pdev : NULL;
@@ -351,6 +362,13 @@ EXPORT_SYMBOL_GPL(platform_device_unregister);
  *      memory allocated for the device allows drivers using such devices
  *      to be unloaded iwithout waiting for the last reference to the device
  *      to be dropped.
+ *
+ *      This interface is primarily intended for use with legacy drivers
+ *      which probe hardware directly.  Because such drivers create sysfs
+ *      device nodes themselves, rather than letting system infrastructure
+ *      handle such device enumeration tasks, they don't fully conform to
+ *      the Linux driver model.  In particular, when such drivers are built
+ *      as modules, they can't be "hotplugged".
  */
 struct platform_device *platform_device_register_simple(char *name, unsigned int id,
                                                         struct resource *res, unsigned int num)
diff --git a/drivers/block/acsi_slm.c b/drivers/block/acsi_slm.c
index e2e043290963..1d9d9b4f48cc 100644
--- a/drivers/block/acsi_slm.c
+++ b/drivers/block/acsi_slm.c
@@ -65,7 +65,6 @@ not be guaranteed. There are several ways to assure this:
 #include <linux/time.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 
 #include <asm/pgtable.h>
 #include <asm/system.h>
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 65a725cd3422..370dfe1c422e 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -45,6 +45,10 @@
 #include <linux/blkdev.h>
 #include <linux/genhd.h>
 #include <linux/completion.h>
+#include <scsi/scsi.h>
+#include <scsi/sg.h>
+#include <scsi/scsi_ioctl.h>
+#include <linux/cdrom.h>
 
 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
 #define DRIVER_NAME "HP CISS Driver (v 3.6.14)"
@@ -1152,6 +1156,30 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                         kfree(ioc);
                         return status;
                 }
+
+        /* scsi_cmd_ioctl handles these, below, though some are not */
+        /* very meaningful for cciss.  SG_IO is the main one people want. */
+
+        case SG_GET_VERSION_NUM:
+        case SG_SET_TIMEOUT:
+        case SG_GET_TIMEOUT:
+        case SG_GET_RESERVED_SIZE:
+        case SG_SET_RESERVED_SIZE:
+        case SG_EMULATED_HOST:
+        case SG_IO:
+        case SCSI_IOCTL_SEND_COMMAND:
+                return scsi_cmd_ioctl(filep, disk, cmd, argp);
+
+        /* scsi_cmd_ioctl would normally handle these, below, but */
+        /* they aren't a good fit for cciss, as CD-ROMs are */
+        /* not supported, and we don't have any bus/target/lun */
+        /* which we present to the kernel. */
+
+        case CDROM_SEND_PACKET:
+        case CDROMCLOSETRAY:
+        case CDROMEJECT:
+        case SCSI_IOCTL_GET_IDLUN:
+        case SCSI_IOCTL_GET_BUS_NUMBER:
         default:
                 return -ENOTTY;
         }
@@ -1234,7 +1262,7 @@ static void cciss_softirq_done(struct request *rq)
                 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
         }
 
-        complete_buffers(rq->bio, rq->errors);
+        complete_buffers(rq->bio, (rq->errors == 0));
 
         if (blk_fs_request(rq)) {
                 const int rw = rq_data_dir(rq);
@@ -1248,7 +1276,7 @@ static void cciss_softirq_done(struct request *rq)
 
         add_disk_randomness(rq->rq_disk);
         spin_lock_irqsave(&h->lock, flags);
-        end_that_request_last(rq, rq->errors);
+        end_that_request_last(rq, (rq->errors == 0));
         cmd_free(h, cmd, 1);
         cciss_check_queues(h);
         spin_unlock_irqrestore(&h->lock, flags);
@@ -2336,6 +2364,44 @@ static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
         start_io(h);
 }
 
+static inline int evaluate_target_status(CommandList_struct *cmd)
+{
+        unsigned char sense_key;
+        int error_count = 1;
+
+        if (cmd->err_info->ScsiStatus != 0x02) { /* not check condition? */
+                if (!blk_pc_request(cmd->rq))
+                        printk(KERN_WARNING "cciss: cmd %p "
+                               "has SCSI Status 0x%x\n",
+                               cmd, cmd->err_info->ScsiStatus);
+                return error_count;
+        }
+
+        /* check the sense key */
+        sense_key = 0xf & cmd->err_info->SenseInfo[2];
+        /* no status or recovered error */
+        if ((sense_key == 0x0) || (sense_key == 0x1))
+                error_count = 0;
+
+        if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
+                if (error_count != 0)
+                        printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
+                               " sense key = 0x%x\n", cmd, sense_key);
+                return error_count;
+        }
+
+        /* SG_IO or similar, copy sense data back */
+        if (cmd->rq->sense) {
+                if (cmd->rq->sense_len > cmd->err_info->SenseLen)
+                        cmd->rq->sense_len = cmd->err_info->SenseLen;
+                memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
+                        cmd->rq->sense_len);
+        } else
+                cmd->rq->sense_len = 0;
+
+        return error_count;
+}
+
 /* checks the status of the job and calls complete buffers to mark all
  * buffers for the completed job. Note that this function does not need
  * to hold the hba/queue lock.
@@ -2343,109 +2409,99 @@ static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                                     int timeout)
 {
-        int status = 1;
         int retry_cmd = 0;
+        struct request *rq = cmd->rq;
+
+        rq->errors = 0;
 
         if (timeout)
-                status = 0;
+                rq->errors = 1;
 
-        if (cmd->err_info->CommandStatus != 0) {        /* an error has occurred */
-                switch (cmd->err_info->CommandStatus) {
-                        unsigned char sense_key;
-                case CMD_TARGET_STATUS:
-                        status = 0;
+        if (cmd->err_info->CommandStatus == 0)  /* no error has occurred */
+                goto after_error_processing;
 
-                        if (cmd->err_info->ScsiStatus == 0x02) {
-                                printk(KERN_WARNING "cciss: cmd %p "
-                                       "has CHECK CONDITION "
-                                       " byte 2 = 0x%x\n", cmd,
-                                       cmd->err_info->SenseInfo[2]
-                                    );
-                                /* check the sense key */
-                                sense_key = 0xf & cmd->err_info->SenseInfo[2];
-                                /* no status or recovered error */
-                                if ((sense_key == 0x0) || (sense_key == 0x1)) {
-                                        status = 1;
-                                }
-                        } else {
-                                printk(KERN_WARNING "cciss: cmd %p "
-                                       "has SCSI Status 0x%x\n",
-                                       cmd, cmd->err_info->ScsiStatus);
-                        }
-                        break;
-                case CMD_DATA_UNDERRUN:
+        switch (cmd->err_info->CommandStatus) {
+        case CMD_TARGET_STATUS:
+                rq->errors = evaluate_target_status(cmd);
+                break;
+        case CMD_DATA_UNDERRUN:
+                if (blk_fs_request(cmd->rq)) {
                         printk(KERN_WARNING "cciss: cmd %p has"
                                " completed with data underrun "
                                "reported\n", cmd);
-                        break;
-                case CMD_DATA_OVERRUN:
+                        cmd->rq->data_len = cmd->err_info->ResidualCnt;
+                }
+                break;
+        case CMD_DATA_OVERRUN:
+                if (blk_fs_request(cmd->rq))
                         printk(KERN_WARNING "cciss: cmd %p has"
                                " completed with data overrun "
                                "reported\n", cmd);
-                        break;
-                case CMD_INVALID:
-                        printk(KERN_WARNING "cciss: cmd %p is "
-                               "reported invalid\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_PROTOCOL_ERR:
-                        printk(KERN_WARNING "cciss: cmd %p has "
-                               "protocol error \n", cmd);
-                        status = 0;
-                        break;
-                case CMD_HARDWARE_ERR:
-                        printk(KERN_WARNING "cciss: cmd %p had "
-                               " hardware error\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_CONNECTION_LOST:
-                        printk(KERN_WARNING "cciss: cmd %p had "
-                               "connection lost\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_ABORTED:
-                        printk(KERN_WARNING "cciss: cmd %p was "
-                               "aborted\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_ABORT_FAILED:
-                        printk(KERN_WARNING "cciss: cmd %p reports "
-                               "abort failed\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_UNSOLICITED_ABORT:
-                        printk(KERN_WARNING "cciss%d: unsolicited "
-                               "abort %p\n", h->ctlr, cmd);
-                        if (cmd->retry_count < MAX_CMD_RETRIES) {
-                                retry_cmd = 1;
-                                printk(KERN_WARNING
-                                       "cciss%d: retrying %p\n", h->ctlr, cmd);
-                                cmd->retry_count++;
-                        } else
-                                printk(KERN_WARNING
-                                       "cciss%d: %p retried too "
-                                       "many times\n", h->ctlr, cmd);
-                        status = 0;
-                        break;
-                case CMD_TIMEOUT:
-                        printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
-                        status = 0;
-                        break;
-                default:
-                        printk(KERN_WARNING "cciss: cmd %p returned "
-                               "unknown status %x\n", cmd,
-                               cmd->err_info->CommandStatus);
-                        status = 0;
-                }
+                break;
+        case CMD_INVALID:
+                printk(KERN_WARNING "cciss: cmd %p is "
+                       "reported invalid\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_PROTOCOL_ERR:
+                printk(KERN_WARNING "cciss: cmd %p has "
+                       "protocol error \n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_HARDWARE_ERR:
+                printk(KERN_WARNING "cciss: cmd %p had "
+                       " hardware error\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_CONNECTION_LOST:
+                printk(KERN_WARNING "cciss: cmd %p had "
+                       "connection lost\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_ABORTED:
+                printk(KERN_WARNING "cciss: cmd %p was "
+                       "aborted\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_ABORT_FAILED:
+                printk(KERN_WARNING "cciss: cmd %p reports "
+                       "abort failed\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_UNSOLICITED_ABORT:
+                printk(KERN_WARNING "cciss%d: unsolicited "
+                       "abort %p\n", h->ctlr, cmd);
+                if (cmd->retry_count < MAX_CMD_RETRIES) {
+                        retry_cmd = 1;
+                        printk(KERN_WARNING
+                               "cciss%d: retrying %p\n", h->ctlr, cmd);
+                        cmd->retry_count++;
+                } else
+                        printk(KERN_WARNING
+                               "cciss%d: %p retried too "
+                               "many times\n", h->ctlr, cmd);
+                rq->errors = 1;
+                break;
+        case CMD_TIMEOUT:
+                printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
+                rq->errors = 1;
+                break;
+        default:
+                printk(KERN_WARNING "cciss: cmd %p returned "
+                       "unknown status %x\n", cmd,
+                       cmd->err_info->CommandStatus);
+                rq->errors = 1;
         }
+
+after_error_processing:
+
         /* We need to return this command */
         if (retry_cmd) {
                 resend_cciss_cmd(h, cmd);
                 return;
         }
-
+        cmd->rq->data_len = 0;
         cmd->rq->completion_data = cmd;
-        cmd->rq->errors = status;
         blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
         blk_complete_request(cmd->rq);
 }
@@ -2539,32 +2595,40 @@ static void do_cciss_request(request_queue_t *q)
 #endif                          /* CCISS_DEBUG */
 
         c->Header.SGList = c->Header.SGTotal = seg;
-        if(h->cciss_read == CCISS_READ_10) {
-                c->Request.CDB[1] = 0;
-                c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
-                c->Request.CDB[3] = (start_blk >> 16) & 0xff;
-                c->Request.CDB[4] = (start_blk >> 8) & 0xff;
-                c->Request.CDB[5] = start_blk & 0xff;
-                c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
-                c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
-                c->Request.CDB[8] = creq->nr_sectors & 0xff;
-                c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
+        if (likely(blk_fs_request(creq))) {
+                if(h->cciss_read == CCISS_READ_10) {
+                        c->Request.CDB[1] = 0;
+                        c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
+                        c->Request.CDB[3] = (start_blk >> 16) & 0xff;
+                        c->Request.CDB[4] = (start_blk >> 8) & 0xff;
+                        c->Request.CDB[5] = start_blk & 0xff;
+                        c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
+                        c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
+                        c->Request.CDB[8] = creq->nr_sectors & 0xff;
+                        c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
+                } else {
+                        c->Request.CDBLen = 16;
+                        c->Request.CDB[1]= 0;
+                        c->Request.CDB[2]= (start_blk >> 56) & 0xff;    //MSB
+                        c->Request.CDB[3]= (start_blk >> 48) & 0xff;
+                        c->Request.CDB[4]= (start_blk >> 40) & 0xff;
+                        c->Request.CDB[5]= (start_blk >> 32) & 0xff;
+                        c->Request.CDB[6]= (start_blk >> 24) & 0xff;
+                        c->Request.CDB[7]= (start_blk >> 16) & 0xff;
+                        c->Request.CDB[8]= (start_blk >>  8) & 0xff;
+                        c->Request.CDB[9]= start_blk & 0xff;
+                        c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
+                        c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
+                        c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
+                        c->Request.CDB[13]= creq->nr_sectors & 0xff;
+                        c->Request.CDB[14] = c->Request.CDB[15] = 0;
+                }
+        } else if (blk_pc_request(creq)) {
+                c->Request.CDBLen = creq->cmd_len;
+                memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
         } else {
-                c->Request.CDBLen = 16;
-                c->Request.CDB[1]= 0;
-                c->Request.CDB[2]= (start_blk >> 56) & 0xff;    //MSB
-                c->Request.CDB[3]= (start_blk >> 48) & 0xff;
-                c->Request.CDB[4]= (start_blk >> 40) & 0xff;
-                c->Request.CDB[5]= (start_blk >> 32) & 0xff;
-                c->Request.CDB[6]= (start_blk >> 24) & 0xff;
-                c->Request.CDB[7]= (start_blk >> 16) & 0xff;
-                c->Request.CDB[8]= (start_blk >>  8) & 0xff;
-                c->Request.CDB[9]= start_blk & 0xff;
-                c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
-                c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
-                c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
-                c->Request.CDB[13]= creq->nr_sectors & 0xff;
-                c->Request.CDB[14] = c->Request.CDB[15] = 0;
+                printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
+                BUG();
         }
 
         spin_lock_irq(q->queue_lock);
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index bb15051ffbe0..90961a8ea895 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -35,7 +35,6 @@
 
 #include <asm/atomic.h>
 
-#include <scsi/scsi.h> 
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h> 
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 5231ed7e723f..3587cb434371 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4334,7 +4334,10 @@ static int __init floppy_init(void)
                 if (err)
                         goto out_flush_work;
 
-                device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
+                err = device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
+                if (err)
+                        goto out_unreg_platform_dev;
+
                 /* to be cleaned up... */
                 disks[drive]->private_data = (void *)(long)drive;
                 disks[drive]->queue = floppy_queue;
@@ -4345,6 +4348,8 @@ static int __init floppy_init(void)
 
         return 0;
 
+out_unreg_platform_dev:
+        platform_device_unregister(&floppy_device[drive]);
 out_flush_work:
         flush_scheduled_work();
         if (usage_count)
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 0d4ccd4a0957..af6d7274a7cc 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -77,9 +77,8 @@
 
 #include <asm/uaccess.h>
 
-static int max_loop = 8;
-static struct loop_device *loop_dev;
-static struct gendisk **disks;
+static LIST_HEAD(loop_devices);
+static DEFINE_MUTEX(loop_devices_mutex);
 
 /*
  * Transfer functions
@@ -183,7 +182,7 @@ figure_loop_size(struct loop_device *lo)
         if (unlikely((loff_t)x != size))
                 return -EFBIG;
 
-        set_capacity(disks[lo->lo_number], x);
+        set_capacity(lo->lo_disk, x);
         return 0;                                       
 }
 
@@ -812,7 +811,7 @@ static int loop_set_fd(struct loop_device *lo, struct file *lo_file,
         lo->lo_queue->queuedata = lo;
         lo->lo_queue->unplug_fn = loop_unplug;
 
-        set_capacity(disks[lo->lo_number], size);
+        set_capacity(lo->lo_disk, size);
         bd_set_size(bdev, size << 9);
 
         set_blocksize(bdev, lo_blocksize);
@@ -832,7 +831,7 @@ out_clr:
         lo->lo_device = NULL;
         lo->lo_backing_file = NULL;
         lo->lo_flags = 0;
-        set_capacity(disks[lo->lo_number], 0);
+        set_capacity(lo->lo_disk, 0);
         invalidate_bdev(bdev);
         bd_set_size(bdev, 0);
         mapping_set_gfp_mask(mapping, lo->old_gfp_mask);
@@ -918,7 +917,7 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
         memset(lo->lo_crypt_name, 0, LO_NAME_SIZE);
         memset(lo->lo_file_name, 0, LO_NAME_SIZE);
         invalidate_bdev(bdev);
-        set_capacity(disks[lo->lo_number], 0);
+        set_capacity(lo->lo_disk, 0);
         bd_set_size(bdev, 0);
         mapping_set_gfp_mask(filp->f_mapping, gfp);
         lo->lo_state = Lo_unbound;
@@ -1322,6 +1321,18 @@ static long lo_compat_ioctl(struct file *file, unsigned int cmd, unsigned long a
 }
 #endif
 
+static struct loop_device *loop_find_dev(int number)
+{
+        struct loop_device *lo;
+
+        list_for_each_entry(lo, &loop_devices, lo_list) {
+                if (lo->lo_number == number)
+                        return lo;
+        }
+        return NULL;
+}
+
+static struct loop_device *loop_init_one(int i);
 static int lo_open(struct inode *inode, struct file *file)
 {
         struct loop_device *lo = inode->i_bdev->bd_disk->private_data;
@@ -1330,6 +1341,11 @@ static int lo_open(struct inode *inode, struct file *file)
         lo->lo_refcnt++;
         mutex_unlock(&lo->lo_ctl_mutex);
 
+        mutex_lock(&loop_devices_mutex);
+        if (!loop_find_dev(lo->lo_number + 1))
+                loop_init_one(lo->lo_number + 1);
+        mutex_unlock(&loop_devices_mutex);
+
         return 0;
 }
 
@@ -1357,8 +1373,9 @@ static struct block_device_operations lo_fops = {
 /*
  * And now the modules code and kernel interface.
  */
+static int max_loop;
 module_param(max_loop, int, 0);
-MODULE_PARM_DESC(max_loop, "Maximum number of loop devices (1-256)");
+MODULE_PARM_DESC(max_loop, "obsolete, loop device is created on-demand");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR);
 
@@ -1383,7 +1400,7 @@ int loop_unregister_transfer(int number)
 
         xfer_funcs[n] = NULL;
 
-        for (lo = &loop_dev[0]; lo < &loop_dev[max_loop]; lo++) {
+        list_for_each_entry(lo, &loop_devices, lo_list) {
                 mutex_lock(&lo->lo_ctl_mutex);
 
                 if (lo->lo_encryption == xfer)
@@ -1398,91 +1415,110 @@ int loop_unregister_transfer(int number)
 EXPORT_SYMBOL(loop_register_transfer);
 EXPORT_SYMBOL(loop_unregister_transfer);
 
-static int __init loop_init(void)
+static struct loop_device *loop_init_one(int i)
+{
+        struct loop_device *lo;
+        struct gendisk *disk;
+
+        lo = kzalloc(sizeof(*lo), GFP_KERNEL);
+        if (!lo)
+                goto out;
+
+        lo->lo_queue = blk_alloc_queue(GFP_KERNEL);
+        if (!lo->lo_queue)
+                goto out_free_dev;
+
+        disk = lo->lo_disk = alloc_disk(1);
+        if (!disk)
+                goto out_free_queue;
+
+        mutex_init(&lo->lo_ctl_mutex);
+        lo->lo_number           = i;
+        lo->lo_thread           = NULL;
+        init_waitqueue_head(&lo->lo_event);
+        spin_lock_init(&lo->lo_lock);
+        disk->major             = LOOP_MAJOR;
+        disk->first_minor       = i;
+        disk->fops              = &lo_fops;
+        disk->private_data      = lo;
+        disk->queue             = lo->lo_queue;
+        sprintf(disk->disk_name, "loop%d", i);
+        add_disk(disk);
+        list_add_tail(&lo->lo_list, &loop_devices);
+        return lo;
+
+out_free_queue:
+        blk_cleanup_queue(lo->lo_queue);
+out_free_dev:
+        kfree(lo);
+out:
+        return ERR_PTR(-ENOMEM);
+}
+
+static void loop_del_one(struct loop_device *lo)
 {
-        int     i;
+        del_gendisk(lo->lo_disk);
+        blk_cleanup_queue(lo->lo_queue);
+        put_disk(lo->lo_disk);
+        list_del(&lo->lo_list);
+        kfree(lo);
+}
 
-        if (max_loop < 1 || max_loop > 256) {
-                printk(KERN_WARNING "loop: invalid max_loop (must be between"
-                                    " 1 and 256), using default (8)\n");
-                max_loop = 8;
-        }
+static struct kobject *loop_probe(dev_t dev, int *part, void *data)
+{
+        unsigned int number = dev & MINORMASK;
+        struct loop_device *lo;
+
+        mutex_lock(&loop_devices_mutex);
+        lo = loop_find_dev(number);
+        if (lo == NULL)
+                lo = loop_init_one(number);
+        mutex_unlock(&loop_devices_mutex);
+
+        *part = 0;
+        if (IS_ERR(lo))
+                return (void *)lo;
+        else
+                return &lo->lo_disk->kobj;
+}
+
+static int __init loop_init(void)
+{
+        struct loop_device *lo;
 
         if (register_blkdev(LOOP_MAJOR, "loop"))
                 return -EIO;
+        blk_register_region(MKDEV(LOOP_MAJOR, 0), 1UL << MINORBITS,
+                                  THIS_MODULE, loop_probe, NULL, NULL);
 
-        loop_dev = kmalloc(max_loop * sizeof(struct loop_device), GFP_KERNEL);
-        if (!loop_dev)
-                goto out_mem1;
-        memset(loop_dev, 0, max_loop * sizeof(struct loop_device));
+        lo = loop_init_one(0);
+        if (IS_ERR(lo))
+                goto out;
 
-        disks = kmalloc(max_loop * sizeof(struct gendisk *), GFP_KERNEL);
-        if (!disks)
-                goto out_mem2;
+        if (max_loop) {
+                printk(KERN_INFO "loop: the max_loop option is obsolete "
+                                 "and will be removed in March 2008\n");
 
-        for (i = 0; i < max_loop; i++) {
-                disks[i] = alloc_disk(1);
-                if (!disks[i])
-                        goto out_mem3;
         }
-
-        for (i = 0; i < max_loop; i++) {
-                struct loop_device *lo = &loop_dev[i];
-                struct gendisk *disk = disks[i];
-
-                memset(lo, 0, sizeof(*lo));
-                lo->lo_queue = blk_alloc_queue(GFP_KERNEL);
-                if (!lo->lo_queue)
-                        goto out_mem4;
-                mutex_init(&lo->lo_ctl_mutex);
-                lo->lo_number = i;
-                lo->lo_thread = NULL;
-                init_waitqueue_head(&lo->lo_event);
-                spin_lock_init(&lo->lo_lock);
-                disk->major = LOOP_MAJOR;
-                disk->first_minor = i;
-                disk->fops = &lo_fops;
-                sprintf(disk->disk_name, "loop%d", i);
-                disk->private_data = lo;
-                disk->queue = lo->lo_queue;
-        }
-
-        /* We cannot fail after we call this, so another loop!*/
-        for (i = 0; i < max_loop; i++)
-                add_disk(disks[i]);
-        printk(KERN_INFO "loop: loaded (max %d devices)\n", max_loop);
+        printk(KERN_INFO "loop: module loaded\n");
         return 0;
 
-out_mem4:
-        while (i--)
-                blk_cleanup_queue(loop_dev[i].lo_queue);
-        i = max_loop;
-out_mem3:
-        while (i--)
-                put_disk(disks[i]);
-        kfree(disks);
-out_mem2:
-        kfree(loop_dev);
-out_mem1:
+out:
         unregister_blkdev(LOOP_MAJOR, "loop");
         printk(KERN_ERR "loop: ran out of memory\n");
         return -ENOMEM;
 }
 
-static void loop_exit(void)
+static void __exit loop_exit(void)
 {
-        int i;
+        struct loop_device *lo, *next;
 
-        for (i = 0; i < max_loop; i++) {
-                del_gendisk(disks[i]);
-                blk_cleanup_queue(loop_dev[i].lo_queue);
-                put_disk(disks[i]);
-        }
+        list_for_each_entry_safe(lo, next, &loop_devices, lo_list)
+                loop_del_one(lo);
+
+        blk_unregister_region(MKDEV(LOOP_MAJOR, 0), 1UL << MINORBITS);
         if (unregister_blkdev(LOOP_MAJOR, "loop"))
                 printk(KERN_WARNING "loop: cannot unregister blkdev\n");
-
-        kfree(disks);
-        kfree(loop_dev);
 }
 
 module_init(loop_init);
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index 5872036e8ae6..6f5d6203d725 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -44,7 +44,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/smp_lock.h>
 #include <linux/timer.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index a26d91743b24..1e32fb834eb8 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -127,7 +127,7 @@ config ROCKETPORT
 
 config CYCLADES
         tristate "Cyclades async mux support"
-        depends on SERIAL_NONSTANDARD
+        depends on SERIAL_NONSTANDARD && (PCI || ISA)
         ---help---
           This driver supports Cyclades Z and Y multiserial boards.
           You would need something like this to connect more than two modems to
@@ -1071,5 +1071,11 @@ config TELCLOCK
           /sys/devices/platform/telco_clock, with a number of files for
           controlling the behavior of this hardware.
 
+config DEVPORT
+        bool
+        depends on !M68K
+        depends on ISA || PCI
+        default y
+
 endmenu
 
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index 0e2b72f2b887..4eaceabd8cea 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -1574,7 +1574,7 @@ static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
                 if (timeout && time_after(jiffies, orig_jiffies + timeout))
                         break;
         }
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
         printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);
 #endif
@@ -1700,7 +1700,7 @@ static int block_til_ready(struct tty_struct *tty, struct file * filp,
 #endif
                 schedule();
         }
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&info->open_wait, &wait);
         if (extra_count)
                 state->count++;
diff --git a/drivers/char/consolemap.c b/drivers/char/consolemap.c
index b99b7561260d..fd40b959afdd 100644
--- a/drivers/char/consolemap.c
+++ b/drivers/char/consolemap.c
@@ -626,10 +626,10 @@ conv_uni_to_pc(struct vc_data *conp, long ucs)
   
         /* Only 16-bit codes supported at this time */
         if (ucs > 0xffff)
-                ucs = 0xfffd;           /* U+FFFD: REPLACEMENT CHARACTER */
-        else if (ucs < 0x20 || ucs >= 0xfffe)
+                return -4;              /* Not found */
+        else if (ucs < 0x20)
                 return -1;              /* Not a printable character */
-        else if (ucs == 0xfeff || (ucs >= 0x200a && ucs <= 0x200f))
+        else if (ucs == 0xfeff || (ucs >= 0x200b && ucs <= 0x200f))
                 return -2;                      /* Zero-width space */
         /*
          * UNI_DIRECT_BASE indicates the start of the region in the User Zone
diff --git a/drivers/char/cs5535_gpio.c b/drivers/char/cs5535_gpio.c
index c02d9e99e050..fe6d2407baed 100644
--- a/drivers/char/cs5535_gpio.c
+++ b/drivers/char/cs5535_gpio.c
@@ -44,6 +44,7 @@ static struct pci_device_id divil_pci[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA) },
         { } /* NULL entry */
 };
+MODULE_DEVICE_TABLE(pci, divil_pci);
 
 static struct cdev cs5535_gpio_cdev;
 
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index 16dc5d1d3cb4..c72ee97d3892 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -10,15 +10,14 @@
  *
  * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
  * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
- * Currently maintained by Cyclades team <async@cyclades.com>.
  *
- * For Technical support and installation problems, please send e-mail
- * to support@cyclades.com.
+ * Copyright (C) 2007 Jiri Slaby <jirislaby@gmail.com>
  *
  * Much of the design and some of the code came from serial.c
  * which was copyright (C) 1991, 1992  Linus Torvalds.  It was
  * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
  * and then fixed as suggested by Michael K. Johnson 12/12/92.
+ * Converted to pci probing and cleaned up by Jiri Slaby.
  *
  * This version supports shared IRQ's (only for PCI boards).
  *
@@ -591,7 +590,7 @@
  *
  */
 
-#define CY_VERSION      "2.4"
+#define CY_VERSION      "2.5"
 
 /* If you need to install more boards than NR_CARDS, change the constant
    in the definition below. No other change is necessary to support up to
@@ -624,12 +623,6 @@
 #undef  CY_ENABLE_MONITORING
 #undef  CY_PCI_DEBUG
 
-#if 0
-#define PAUSE __asm__("nop")
-#else
-#define PAUSE do {} while (0)
-#endif
-
 /*
  * Include section 
  */
@@ -659,17 +652,6 @@
 #include <asm/irq.h>
 #include <asm/uaccess.h>
 
-#define CY_LOCK(info,flags)                                     \
-                do {                                            \
-                spin_lock_irqsave(&cy_card[info->card].card_lock, flags); \
-                } while (0)
-
-#define CY_UNLOCK(info,flags)                                   \
-                do {                                            \
-                spin_unlock_irqrestore(&cy_card[info->card].card_lock, flags); \
-                } while (0)
-
-#include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/pci.h>
 
@@ -682,13 +664,13 @@ static void cy_send_xchar(struct tty_struct *tty, char ch);
 #define IS_CYC_Z(card) ((card).num_chips == -1)
 
 #define Z_FPGA_CHECK(card) \
-        ((cy_readl(&((struct RUNTIME_9060 __iomem *) \
+        ((readl(&((struct RUNTIME_9060 __iomem *) \
                 ((card).ctl_addr))->init_ctrl) & (1<<17)) != 0)
 
-#define ISZLOADED(card) (((ZO_V1==cy_readl(&((struct RUNTIME_9060 __iomem *) \
+#define ISZLOADED(card) (((ZO_V1==readl(&((struct RUNTIME_9060 __iomem *) \
                         ((card).ctl_addr))->mail_box_0)) || \
                         Z_FPGA_CHECK(card)) && \
-                        (ZFIRM_ID==cy_readl(&((struct FIRM_ID __iomem *) \
+                        (ZFIRM_ID==readl(&((struct FIRM_ID __iomem *) \
                         ((card).base_addr+ID_ADDRESS))->signature)))
 
 #ifndef SERIAL_XMIT_SIZE
@@ -725,8 +707,8 @@ static unsigned int cy_isa_addresses[] = {
 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
 
 #ifdef MODULE
-static long maddr[NR_CARDS] = { 0, };
-static int irq[NR_CARDS] = { 0, };
+static long maddr[NR_CARDS];
+static int irq[NR_CARDS];
 
 module_param_array(maddr, long, NULL, 0);
 module_param_array(irq, int, NULL, 0);
@@ -739,11 +721,6 @@ module_param_array(irq, int, NULL, 0);
 */
 static struct cyclades_card cy_card[NR_CARDS];
 
-/* This is the per-channel data structure containing pointers, flags
- and variables for the port. This driver supports a maximum of NR_PORTS.
-*/
-static struct cyclades_port cy_port[NR_PORTS];
-
 static int cy_next_channel;     /* next minor available */
 
 /*
@@ -825,9 +802,6 @@ static int cy_chip_offset[] = { 0x0000,
 
 /* PCI related definitions */
 
-static unsigned short cy_pci_nboard;
-static unsigned short cy_isa_nboard;
-static unsigned short cy_nboard;
 #ifdef CONFIG_PCI
 static struct pci_device_id cy_pci_dev_id[] __devinitdata = {
         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },      /* PCI < 1Mb */
@@ -845,7 +819,7 @@ MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
 
 static void cy_start(struct tty_struct *);
 static void set_line_char(struct cyclades_port *);
-static int cyz_issue_cmd(struct cyclades_card *, uclong, ucchar, uclong);
+static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
 #ifdef CONFIG_ISA
 static unsigned detect_isa_irq(void __iomem *);
 #endif                          /* CONFIG_ISA */
@@ -858,7 +832,6 @@ static void cyz_poll(unsigned long);
 /* The Cyclades-Z polling cycle is defined by this variable */
 static long cyz_polling_cycle = CZ_DEF_POLL;
 
-static int cyz_timeron = 0;
 static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
 
 #else                           /* CONFIG_CYZ_INTR */
@@ -871,21 +844,14 @@ static inline int serial_paranoia_check(struct cyclades_port *info,
 {
 #ifdef SERIAL_PARANOIA_CHECK
         if (!info) {
-                printk("cyc Warning: null cyclades_port for (%s) in %s\n",
-                                name, routine);
-                return 1;
-        }
-
-        if ((long)info < (long)(&cy_port[0]) ||
-                        (long)(&cy_port[NR_PORTS]) < (long)info) {
-                printk("cyc Warning: cyclades_port out of range for (%s) in "
-                                "%s\n", name, routine);
+                printk(KERN_WARNING "cyc Warning: null cyclades_port for (%s) "
+                                "in %s\n", name, routine);
                 return 1;
         }
 
         if (info->magic != CYCLADES_MAGIC) {
-                printk("cyc Warning: bad magic number for serial struct (%s) "
-                                "in %s\n", name, routine);
+                printk(KERN_WARNING "cyc Warning: bad magic number for serial "
+                                "struct (%s) in %s\n", name, routine);
                 return 1;
         }
 #endif
@@ -943,22 +909,16 @@ do_softint(struct work_struct *work)
         if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event))
                 wake_up_interruptible(&info->open_wait);
 #ifdef CONFIG_CYZ_INTR
-        if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event)) {
-                if (cyz_rx_full_timer[info->line].function == NULL) {
-                        cyz_rx_full_timer[info->line].expires = jiffies + 1;
-                        cyz_rx_full_timer[info->line].function = cyz_rx_restart;
-                        cyz_rx_full_timer[info->line].data =
-                                                (unsigned long)info;
-                        add_timer(&cyz_rx_full_timer[info->line]);
-                }
-        }
+        if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event) &&
+                        !timer_pending(&cyz_rx_full_timer[info->line]))
+                mod_timer(&cyz_rx_full_timer[info->line], jiffies + 1);
 #endif
         if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event))
                 wake_up_interruptible(&info->delta_msr_wait);
         tty_wakeup(tty);
 #ifdef Z_WAKE
         if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event))
-                wake_up_interruptible(&info->shutdown_wait);
+                complete(&info->shutdown_wait);
 #endif
 } /* do_softint */
 
@@ -975,11 +935,11 @@ do_softint(struct work_struct *work)
  */
 static int cyy_issue_cmd(void __iomem * base_addr, u_char cmd, int index)
 {
-        volatile int i;
+        unsigned int i;
 
         /* Check to see that the previous command has completed */
         for (i = 0; i < 100; i++) {
-                if (cy_readb(base_addr + (CyCCR << index)) == 0) {
+                if (readb(base_addr + (CyCCR << index)) == 0) {
                         break;
                 }
                 udelay(10L);
@@ -1022,7 +982,7 @@ static unsigned detect_isa_irq(void __iomem * address)
 
         cy_writeb(address + (CyCAR << index), 0);
         cy_writeb(address + (CySRER << index),
-                  cy_readb(address + (CySRER << index)) | CyTxRdy);
+                  readb(address + (CySRER << index)) | CyTxRdy);
         local_irq_restore(flags);
 
         /* Wait ... */
@@ -1032,11 +992,11 @@ static unsigned detect_isa_irq(void __iomem * address)
         irq = probe_irq_off(irqs);
 
         /* Clean up */
-        save_xir = (u_char) cy_readb(address + (CyTIR << index));
-        save_car = cy_readb(address + (CyCAR << index));
+        save_xir = (u_char) readb(address + (CyTIR << index));
+        save_car = readb(address + (CyCAR << index));
         cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
         cy_writeb(address + (CySRER << index),
-                  cy_readb(address + (CySRER << index)) & ~CyTxRdy);
+                  readb(address + (CySRER << index)) & ~CyTxRdy);
         cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
         cy_writeb(address + (CyCAR << index), (save_car));
         cy_writeb(address + (Cy_ClrIntr << index), 0);
@@ -1051,45 +1011,43 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
 {
         struct cyclades_port *info;
         struct tty_struct *tty;
-        volatile int char_count;
-        int i, j, len, mdm_change, mdm_status, outch;
+        int char_count;
+        int j, len, mdm_change, mdm_status, outch;
         int save_xir, channel, save_car;
         char data;
 
         if (status & CySRReceive) {     /* reception interrupt */
 #ifdef CY_DEBUG_INTERRUPTS
-                printk("cyy_interrupt: rcvd intr, chip %d\n\r", chip);
+                printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
 #endif
                 /* determine the channel & change to that context */
                 spin_lock(&cinfo->card_lock);
-                save_xir = (u_char) cy_readb(base_addr + (CyRIR << index));
+                save_xir = (u_char) readb(base_addr + (CyRIR << index));
                 channel = (u_short) (save_xir & CyIRChannel);
-                i = channel + chip * 4 + cinfo->first_line;
-                info = &cy_port[i];
-                info->last_active = jiffies;
-                save_car = cy_readb(base_addr + (CyCAR << index));
+                info = &cinfo->ports[channel + chip * 4];
+                save_car = readb(base_addr + (CyCAR << index));
                 cy_writeb(base_addr + (CyCAR << index), save_xir);
 
                 /* if there is nowhere to put the data, discard it */
-                if (info->tty == 0) {
-                        j = (cy_readb(base_addr + (CyRIVR << index)) &
+                if (info->tty == NULL) {
+                        j = (readb(base_addr + (CyRIVR << index)) &
                                 CyIVRMask);
                         if (j == CyIVRRxEx) {   /* exception */
-                                data = cy_readb(base_addr + (CyRDSR << index));
+                                data = readb(base_addr + (CyRDSR << index));
                         } else {        /* normal character reception */
-                                char_count = cy_readb(base_addr +
+                                char_count = readb(base_addr +
                                                 (CyRDCR << index));
                                 while (char_count--) {
-                                        data = cy_readb(base_addr +
+                                        data = readb(base_addr +
                                                 (CyRDSR << index));
                                 }
                         }
                 } else {        /* there is an open port for this data */
                         tty = info->tty;
-                        j = (cy_readb(base_addr + (CyRIVR << index)) &
+                        j = (readb(base_addr + (CyRIVR << index)) &
                                         CyIVRMask);
                         if (j == CyIVRRxEx) {   /* exception */
-                                data = cy_readb(base_addr + (CyRDSR << index));
+                                data = readb(base_addr + (CyRDSR << index));
 
                                 /* For statistics only */
                                 if (data & CyBREAK)
@@ -1110,7 +1068,7 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
                                                 if (data & CyBREAK) {
                                                         tty_insert_flip_char(
                                                                 tty,
-                                                                cy_readb(
+                                                                readb(
                                                                 base_addr +
                                                                 (CyRDSR <<
                                                                         index)),
@@ -1123,7 +1081,7 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
                                                 } else if (data & CyFRAME) {
                                                         tty_insert_flip_char(
                                                                 tty,
-                                                                cy_readb(
+                                                                readb(
                                                                 base_addr +
                                                                 (CyRDSR <<
                                                                         index)),
@@ -1135,7 +1093,7 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
                                                         /* Pieces of seven... */
                                                         tty_insert_flip_char(
                                                                 tty,
-                                                                cy_readb(
+                                                                readb(
                                                                 base_addr +
                                                                 (CyRDSR <<
                                                                         index)),
@@ -1154,7 +1112,7 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
                                                  */
                                                         tty_insert_flip_char(
                                                                 tty,
-                                                                cy_readb(
+                                                                readb(
                                                                 base_addr +
                                                                 (CyRDSR <<
                                                                         index)),
@@ -1186,7 +1144,7 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
                                 }
                         } else {        /* normal character reception */
                                 /* load # chars available from the chip */
-                                char_count = cy_readb(base_addr +
+                                char_count = readb(base_addr +
                                                 (CyRDCR << index));
 
 #ifdef CY_ENABLE_MONITORING
@@ -1198,7 +1156,7 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
 #endif
                                 len = tty_buffer_request_room(tty, char_count);
                                 while (len--) {
-                                        data = cy_readb(base_addr +
+                                        data = readb(base_addr +
                                                         (CyRDSR << index));
                                         tty_insert_flip_char(tty, data,
                                                         TTY_NORMAL);
@@ -1223,29 +1181,27 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
                    is empty, we know we can always stuff a dozen
                    characters. */
 #ifdef CY_DEBUG_INTERRUPTS
-                printk("cyy_interrupt: xmit intr, chip %d\n\r", chip);
+                printk(KERN_DEBUG "cyy_interrupt: xmit intr, chip %d\n", chip);
 #endif
 
                 /* determine the channel & change to that context */
                 spin_lock(&cinfo->card_lock);
-                save_xir = (u_char) cy_readb(base_addr + (CyTIR << index));
+                save_xir = (u_char) readb(base_addr + (CyTIR << index));
                 channel = (u_short) (save_xir & CyIRChannel);
-                i = channel + chip * 4 + cinfo->first_line;
-                save_car = cy_readb(base_addr + (CyCAR << index));
+                save_car = readb(base_addr + (CyCAR << index));
                 cy_writeb(base_addr + (CyCAR << index), save_xir);
 
                 /* validate the port# (as configured and open) */
-                if ((i < 0) || (NR_PORTS <= i)) {
+                if (channel + chip * 4 >= cinfo->nports) {
                         cy_writeb(base_addr + (CySRER << index),
-                                  cy_readb(base_addr + (CySRER << index)) &
+                                  readb(base_addr + (CySRER << index)) &
                                   ~CyTxRdy);
                         goto txend;
                 }
-                info = &cy_port[i];
-                info->last_active = jiffies;
-                if (info->tty == 0) {
+                info = &cinfo->ports[channel + chip * 4];
+                if (info->tty == NULL) {
                         cy_writeb(base_addr + (CySRER << index),
-                                  cy_readb(base_addr + (CySRER << index)) &
+                                  readb(base_addr + (CySRER << index)) &
                                   ~CyTxRdy);
                         goto txdone;
                 }
@@ -1278,29 +1234,29 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
 
                 while (char_count-- > 0) {
                         if (!info->xmit_cnt) {
-                                if (cy_readb(base_addr + (CySRER << index)) &
+                                if (readb(base_addr + (CySRER << index)) &
                                                 CyTxMpty) {
                                         cy_writeb(base_addr + (CySRER << index),
-                                                cy_readb(base_addr +
+                                                readb(base_addr +
                                                         (CySRER << index)) &
                                                 ~CyTxMpty);
                                 } else {
                                         cy_writeb(base_addr + (CySRER << index),
-                                                (cy_readb(base_addr +
+                                                (readb(base_addr +
                                                         (CySRER << index)) &
                                                 ~CyTxRdy) | CyTxMpty);
                                 }
                                 goto txdone;
                         }
-                        if (info->xmit_buf == 0) {
+                        if (info->xmit_buf == NULL) {
                                 cy_writeb(base_addr + (CySRER << index),
-                                        cy_readb(base_addr + (CySRER << index))&
+                                        readb(base_addr + (CySRER << index)) &
                                         ~CyTxRdy);
                                 goto txdone;
                         }
                         if (info->tty->stopped || info->tty->hw_stopped) {
                                 cy_writeb(base_addr + (CySRER << index),
-                                        cy_readb(base_addr + (CySRER << index))&
+                                        readb(base_addr + (CySRER << index)) &
                                         ~CyTxRdy);
                                 goto txdone;
                         }
@@ -1333,7 +1289,6 @@ static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
                                                 0);
                                         info->icount.tx++;
                                         char_count--;
-                                } else {
                                 }
                         }
                 }
@@ -1353,19 +1308,16 @@ txend:
 
                 /* determine the channel & change to that context */
                 spin_lock(&cinfo->card_lock);
-                save_xir = (u_char) cy_readb(base_addr + (CyMIR << index));
+                save_xir = (u_char) readb(base_addr + (CyMIR << index));
                 channel = (u_short) (save_xir & CyIRChannel);
-                info = &cy_port[channel + chip * 4 + cinfo->first_line];
-                info->last_active = jiffies;
-                save_car = cy_readb(base_addr + (CyCAR << index));
+                info = &cinfo->ports[channel + chip * 4];
+                save_car = readb(base_addr + (CyCAR << index));
                 cy_writeb(base_addr + (CyCAR << index), save_xir);
 
-                mdm_change = cy_readb(base_addr + (CyMISR << index));
-                mdm_status = cy_readb(base_addr + (CyMSVR1 << index));
+                mdm_change = readb(base_addr + (CyMISR << index));
+                mdm_status = readb(base_addr + (CyMSVR1 << index));
 
-                if (info->tty == 0) {   /* no place for data, ignore it */
-                        ;
-                } else {
+                if (info->tty) {
                         if (mdm_change & CyANY_DELTA) {
                                 /* For statistics only */
                                 if (mdm_change & CyDCD)
@@ -1398,7 +1350,7 @@ txend:
                                                 info->tty->hw_stopped = 0;
                                                 cy_writeb(base_addr +
                                                         (CySRER << index),
-                                                        cy_readb(base_addr +
+                                                        readb(base_addr +
                                                                 (CySRER <<
                                                                         index))|
                                                         CyTxRdy);
@@ -1412,17 +1364,17 @@ txend:
                                                 info->tty->hw_stopped = 1;
                                                 cy_writeb(base_addr +
                                                         (CySRER << index),
-                                                        cy_readb(base_addr +
+                                                        readb(base_addr +
                                                                 (CySRER <<
                                                                 index)) &
                                                         ~CyTxRdy);
                                         }
                                 }
                         }
-                        if (mdm_change & CyDSR) {
+/*                      if (mdm_change & CyDSR) {
                         }
                         if (mdm_change & CyRI) {
-                        }
+                        }*/
                 }
                 /* end of service */
                 cy_writeb(base_addr + (CyMIR << index), (save_xir & 0x3f));
@@ -1438,16 +1390,16 @@ txend:
 static irqreturn_t cyy_interrupt(int irq, void *dev_id)
 {
         int status;
-        struct cyclades_card *cinfo;
+        struct cyclades_card *cinfo = dev_id;
         void __iomem *base_addr, *card_base_addr;
         int chip;
         int index;
         int too_many;
         int had_work;
 
-        if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
+        if (unlikely(cinfo == NULL)) {
 #ifdef CY_DEBUG_INTERRUPTS
-                printk("cyy_interrupt: spurious interrupt %d\n\r", irq);
+                printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",irq);
 #endif
                 return IRQ_NONE;        /* spurious interrupt */
         }
@@ -1455,6 +1407,10 @@ static irqreturn_t cyy_interrupt(int irq, void *dev_id)
         card_base_addr = cinfo->base_addr;
         index = cinfo->bus_index;
 
+        /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
+        if (unlikely(card_base_addr == NULL))
+                return IRQ_HANDLED;
+
         /* This loop checks all chips in the card.  Make a note whenever
            _any_ chip had some work to do, as this is considered an
            indication that there will be more to do.  Only when no chip
@@ -1466,7 +1422,7 @@ static irqreturn_t cyy_interrupt(int irq, void *dev_id)
                         base_addr = cinfo->base_addr +
                                         (cy_chip_offset[chip] << index);
                         too_many = 0;
-                        while ((status = cy_readb(base_addr +
+                        while ((status = readb(base_addr +
                                                 (CySVRR << index))) != 0x00) {
                                 had_work++;
                         /* The purpose of the following test is to ensure that
@@ -1498,7 +1454,7 @@ static irqreturn_t cyy_interrupt(int irq, void *dev_id)
 
 static int
 cyz_fetch_msg(struct cyclades_card *cinfo,
-                uclong * channel, ucchar * cmd, uclong * param)
+                __u32 * channel, __u8 * cmd, __u32 * param)
 {
         struct FIRM_ID __iomem *firm_id;
         struct ZFW_CTRL __iomem *zfw_ctrl;
@@ -1509,16 +1465,15 @@ cyz_fetch_msg(struct cyclades_card *cinfo,
         if (!ISZLOADED(*cinfo)) {
                 return -1;
         }
-        zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
-                        0xfffff);
+        zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
         board_ctrl = &zfw_ctrl->board_ctrl;
 
-        loc_doorbell = cy_readl(&((struct RUNTIME_9060 __iomem *)
+        loc_doorbell = readl(&((struct RUNTIME_9060 __iomem *)
                                   (cinfo->ctl_addr))->loc_doorbell);
         if (loc_doorbell) {
                 *cmd = (char)(0xff & loc_doorbell);
-                *channel = cy_readl(&board_ctrl->fwcmd_channel);
-                *param = (uclong) cy_readl(&board_ctrl->fwcmd_param);
+                *channel = readl(&board_ctrl->fwcmd_channel);
+                *param = (__u32) readl(&board_ctrl->fwcmd_param);
                 cy_writel(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
                           loc_doorbell, 0xffffffff);
                 return 1;
@@ -1528,28 +1483,27 @@ cyz_fetch_msg(struct cyclades_card *cinfo,
 
 static int
 cyz_issue_cmd(struct cyclades_card *cinfo,
-                uclong channel, ucchar cmd, uclong param)
+                __u32 channel, __u8 cmd, __u32 param)
 {
         struct FIRM_ID __iomem *firm_id;
         struct ZFW_CTRL __iomem *zfw_ctrl;
         struct BOARD_CTRL __iomem *board_ctrl;
-        unsigned long __iomem *pci_doorbell;
+        __u32 __iomem *pci_doorbell;
         int index;
 
         firm_id = cinfo->base_addr + ID_ADDRESS;
         if (!ISZLOADED(*cinfo)) {
                 return -1;
         }
-        zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
-                        0xfffff);
+        zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
         board_ctrl = &zfw_ctrl->board_ctrl;
 
         index = 0;
         pci_doorbell =
             &((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->pci_doorbell;
-        while ((cy_readl(pci_doorbell) & 0xff) != 0) {
+        while ((readl(pci_doorbell) & 0xff) != 0) {
                 if (index++ == 1000) {
-                        return (int)(cy_readl(pci_doorbell) & 0xff);
+                        return (int)(readl(pci_doorbell) & 0xff);
                 }
                 udelay(50L);
         }
@@ -1561,34 +1515,30 @@ cyz_issue_cmd(struct cyclades_card *cinfo,
 }                               /* cyz_issue_cmd */
 
 static void
-cyz_handle_rx(struct cyclades_port *info,
-                volatile struct CH_CTRL __iomem * ch_ctrl,
-                volatile struct BUF_CTRL __iomem * buf_ctrl)
+cyz_handle_rx(struct cyclades_port *info, struct CH_CTRL __iomem *ch_ctrl,
+                struct BUF_CTRL __iomem *buf_ctrl)
 {
-        struct cyclades_card *cinfo = &cy_card[info->card];
+        struct cyclades_card *cinfo = info->card;
         struct tty_struct *tty = info->tty;
-        volatile int char_count;
+        int char_count;
         int len;
 #ifdef BLOCKMOVE
-        int small_count;
+        unsigned char *buf;
 #else
         char data;
 #endif
-        volatile uclong rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
+        __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
 
-        rx_get = new_rx_get = cy_readl(&buf_ctrl->rx_get);
-        rx_put = cy_readl(&buf_ctrl->rx_put);
-        rx_bufsize = cy_readl(&buf_ctrl->rx_bufsize);
-        rx_bufaddr = cy_readl(&buf_ctrl->rx_bufaddr);
+        rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
+        rx_put = readl(&buf_ctrl->rx_put);
+        rx_bufsize = readl(&buf_ctrl->rx_bufsize);
+        rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
         if (rx_put >= rx_get)
                 char_count = rx_put - rx_get;
         else
                 char_count = rx_put - rx_get + rx_bufsize;
 
         if (char_count) {
-                info->last_active = jiffies;
-                info->jiffies[1] = jiffies;
-
 #ifdef CY_ENABLE_MONITORING
                 info->mon.int_count++;
                 info->mon.char_count += char_count;
@@ -1596,7 +1546,7 @@ cyz_handle_rx(struct cyclades_port *info,
                         info->mon.char_max = char_count;
                 info->mon.char_last = char_count;
 #endif
-                if (tty == 0) {
+                if (tty == NULL) {
                         /* flush received characters */
                         new_rx_get = (new_rx_get + char_count) &
                                         (rx_bufsize - 1);
@@ -1606,30 +1556,28 @@ cyz_handle_rx(struct cyclades_port *info,
                 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
                    for performance, but because of buffer boundaries, there
                    may be several steps to the operation */
-                        while (0 < (small_count = min_t(unsigned int,
-                                        rx_bufsize - new_rx_get,
-                                        min_t(unsigned int, TTY_FLIPBUF_SIZE -
-                                                tty->flip.count, char_count)))){
-                                memcpy_fromio(tty->flip.char_buf_ptr,
-                                        (char *)(cinfo->base_addr + rx_bufaddr +
-                                                new_rx_get),
-                                        small_count);
+                        while (1) {
+                                len = tty_prepare_flip_string(tty, &buf,
+                                                char_count);
+                                if (!len)
+                                        break;
 
-                                tty->flip.char_buf_ptr += small_count;
-                                memset(tty->flip.flag_buf_ptr, TTY_NORMAL,
-                                        small_count);
-                                tty->flip.flag_buf_ptr += small_count;
-                                new_rx_get = (new_rx_get + small_count) &
+                                len = min_t(unsigned int, min(len, char_count),
+                                                rx_bufsize - new_rx_get);
+
+                                memcpy_fromio(buf, cinfo->base_addr +
+                                                rx_bufaddr + new_rx_get, len);
+
+                                new_rx_get = (new_rx_get + len) &
                                                 (rx_bufsize - 1);
-                                char_count -= small_count;
-                                info->icount.rx += small_count;
-                                info->idle_stats.recv_bytes += small_count;
-                                tty->flip.count += small_count;
+                                char_count -= len;
+                                info->icount.rx += len;
+                                info->idle_stats.recv_bytes += len;
                         }
 #else
                         len = tty_buffer_request_room(tty, char_count);
                         while (len--) {
-                                data = cy_readb(cinfo->base_addr + rx_bufaddr +
+                                data = readb(cinfo->base_addr + rx_bufaddr +
                                                 new_rx_get);
                                 new_rx_get = (new_rx_get + 1)& (rx_bufsize - 1);
                                 tty_insert_flip_char(tty, data, TTY_NORMAL);
@@ -1640,13 +1588,12 @@ cyz_handle_rx(struct cyclades_port *info,
 #ifdef CONFIG_CYZ_INTR
                 /* Recalculate the number of chars in the RX buffer and issue
                    a cmd in case it's higher than the RX high water mark */
-                        rx_put = cy_readl(&buf_ctrl->rx_put);
+                        rx_put = readl(&buf_ctrl->rx_put);
                         if (rx_put >= rx_get)
                                 char_count = rx_put - rx_get;
                         else
                                 char_count = rx_put - rx_get + rx_bufsize;
-                        if (char_count >= (int)cy_readl(&buf_ctrl->
-                                        rx_threshold)) {
+                        if (char_count >= (int)readl(&buf_ctrl->rx_threshold)) {
                                 cy_sched_event(info, Cy_EVENT_Z_RX_FULL);
                         }
 #endif
@@ -1659,26 +1606,25 @@ cyz_handle_rx(struct cyclades_port *info,
 }
 
 static void
-cyz_handle_tx(struct cyclades_port *info,
-                volatile struct CH_CTRL __iomem * ch_ctrl,
-                volatile struct BUF_CTRL __iomem * buf_ctrl)
+cyz_handle_tx(struct cyclades_port *info, struct CH_CTRL __iomem *ch_ctrl,
+                struct BUF_CTRL __iomem *buf_ctrl)
 {
-        struct cyclades_card *cinfo = &cy_card[info->card];
+        struct cyclades_card *cinfo = info->card;
         struct tty_struct *tty = info->tty;
         char data;
-        volatile int char_count;
+        int char_count;
 #ifdef BLOCKMOVE
         int small_count;
 #endif
-        volatile uclong tx_put, tx_get, tx_bufsize, tx_bufaddr;
+        __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
 
         if (info->xmit_cnt <= 0)        /* Nothing to transmit */
                 return;
 
-        tx_get = cy_readl(&buf_ctrl->tx_get);
-        tx_put = cy_readl(&buf_ctrl->tx_put);
-        tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
-        tx_bufaddr = cy_readl(&buf_ctrl->tx_bufaddr);
+        tx_get = readl(&buf_ctrl->tx_get);
+        tx_put = readl(&buf_ctrl->tx_put);
+        tx_bufsize = readl(&buf_ctrl->tx_bufsize);
+        tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
         if (tx_put >= tx_get)
                 char_count = tx_get - tx_put - 1 + tx_bufsize;
         else
@@ -1686,9 +1632,8 @@ cyz_handle_tx(struct cyclades_port *info,
 
         if (char_count) {
 
-                if (tty == 0) {
+                if (tty == NULL)
                         goto ztxdone;
-                }
 
                 if (info->x_char) {     /* send special char */
                         data = info->x_char;
@@ -1698,8 +1643,6 @@ cyz_handle_tx(struct cyclades_port *info,
                         info->x_char = 0;
                         char_count--;
                         info->icount.tx++;
-                        info->last_active = jiffies;
-                        info->jiffies[2] = jiffies;
                 }
 #ifdef BLOCKMOVE
                 while (0 < (small_count = min_t(unsigned int,
@@ -1719,8 +1662,6 @@ cyz_handle_tx(struct cyclades_port *info,
                         info->xmit_cnt -= small_count;
                         info->xmit_tail = (info->xmit_tail + small_count) &
                                         (SERIAL_XMIT_SIZE - 1);
-                        info->last_active = jiffies;
-                        info->jiffies[2] = jiffies;
                 }
 #else
                 while (info->xmit_cnt && char_count) {
@@ -1733,8 +1674,6 @@ cyz_handle_tx(struct cyclades_port *info,
                         tx_put = (tx_put + 1) & (tx_bufsize - 1);
                         char_count--;
                         info->icount.tx++;
-                        info->last_active = jiffies;
-                        info->jiffies[2] = jiffies;
                 }
 #endif
 ztxdone:
@@ -1750,33 +1689,32 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
 {
         struct tty_struct *tty;
         struct cyclades_port *info;
-        static volatile struct FIRM_ID __iomem *firm_id;
-        static volatile struct ZFW_CTRL __iomem *zfw_ctrl;
-        static volatile struct BOARD_CTRL __iomem *board_ctrl;
-        static volatile struct CH_CTRL __iomem *ch_ctrl;
-        static volatile struct BUF_CTRL __iomem *buf_ctrl;
-        uclong channel;
-        ucchar cmd;
-        uclong param;
-        uclong hw_ver, fw_ver;
+        static struct FIRM_ID __iomem *firm_id;
+        static struct ZFW_CTRL __iomem *zfw_ctrl;
+        static struct BOARD_CTRL __iomem *board_ctrl;
+        static struct CH_CTRL __iomem *ch_ctrl;
+        static struct BUF_CTRL __iomem *buf_ctrl;
+        __u32 channel;
+        __u8 cmd;
+        __u32 param;
+        __u32 hw_ver, fw_ver;
         int special_count;
         int delta_count;
 
         firm_id = cinfo->base_addr + ID_ADDRESS;
-        zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
-                        0xfffff);
+        zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
         board_ctrl = &zfw_ctrl->board_ctrl;
-        fw_ver = cy_readl(&board_ctrl->fw_version);
-        hw_ver = cy_readl(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
+        fw_ver = readl(&board_ctrl->fw_version);
+        hw_ver = readl(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
                         mail_box_0);
 
         while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
                 special_count = 0;
                 delta_count = 0;
-                info = &cy_port[channel + cinfo->first_line];
-                if ((tty = info->tty) == 0) {
+                info = &cinfo->ports[channel];
+                if ((tty = info->tty) == NULL)
                         continue;
-                }
+
                 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
                 buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
 
@@ -1801,7 +1739,7 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                         delta_count++;
                         if (info->flags & ASYNC_CHECK_CD) {
                                 if ((fw_ver > 241 ? ((u_long) param) :
-                                                cy_readl(&ch_ctrl->rs_status)) &
+                                                readl(&ch_ctrl->rs_status)) &
                                                 C_RS_DCD) {
                                         cy_sched_event(info,
                                                         Cy_EVENT_OPEN_WAKEUP);
@@ -1833,8 +1771,8 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                 case C_CM_INTBACK2:
                         /* Reception Interrupt */
 #ifdef CY_DEBUG_INTERRUPTS
-                        printk("cyz_interrupt: rcvd intr, card %d, "
-                                        "port %ld\n\r", info->card, channel);
+                        printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
+                                        "port %ld\n", info->card, channel);
 #endif
                         cyz_handle_rx(info, ch_ctrl, buf_ctrl);
                         break;
@@ -1843,8 +1781,8 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                 case C_CM_INTBACK:
                         /* Transmission Interrupt */
 #ifdef CY_DEBUG_INTERRUPTS
-                        printk("cyz_interrupt: xmit intr, card %d, "
-                                        "port %ld\n\r", info->card, channel);
+                        printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
+                                        "port %ld\n", info->card, channel);
 #endif
                         cyz_handle_tx(info, ch_ctrl, buf_ctrl);
                         break;
@@ -1865,18 +1803,19 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
 #ifdef CONFIG_CYZ_INTR
 static irqreturn_t cyz_interrupt(int irq, void *dev_id)
 {
-        struct cyclades_card *cinfo;
+        struct cyclades_card *cinfo = dev_id;
 
-        if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
+        if (unlikely(cinfo == NULL)) {
 #ifdef CY_DEBUG_INTERRUPTS
-                printk("cyz_interrupt: spurious interrupt %d\n\r", irq);
+                printk(KERN_DEBUG "cyz_interrupt: spurious interrupt %d\n",irq);
 #endif
                 return IRQ_NONE;        /* spurious interrupt */
         }
 
-        if (!ISZLOADED(*cinfo)) {
+        if (unlikely(!ISZLOADED(*cinfo))) {
 #ifdef CY_DEBUG_INTERRUPTS
-                printk("cyz_interrupt: board not yet loaded (IRQ%d).\n\r", irq);
+                printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
+                                "(IRQ%d).\n", irq);
 #endif
                 return IRQ_NONE;
         }
@@ -1890,19 +1829,18 @@ static irqreturn_t cyz_interrupt(int irq, void *dev_id)
 static void cyz_rx_restart(unsigned long arg)
 {
         struct cyclades_port *info = (struct cyclades_port *)arg;
+        struct cyclades_card *card = info->card;
         int retval;
-        int card = info->card;
-        uclong channel = (info->line) - (cy_card[card].first_line);
+        __u32 channel = info->line - card->first_line;
         unsigned long flags;
 
-        CY_LOCK(info, flags);
-        retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK2, 0L);
+        spin_lock_irqsave(&card->card_lock, flags);
+        retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
         if (retval != 0) {
-                printk("cyc:cyz_rx_restart retval on ttyC%d was %x\n",
+                printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
                         info->line, retval);
         }
-        cyz_rx_full_timer[info->line].function = NULL;
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&card->card_lock, flags);
 }
 
 #else                           /* CONFIG_CYZ_INTR */
@@ -1912,14 +1850,14 @@ static void cyz_poll(unsigned long arg)
         struct cyclades_card *cinfo;
         struct cyclades_port *info;
         struct tty_struct *tty;
-        static volatile struct FIRM_ID *firm_id;
-        static volatile struct ZFW_CTRL *zfw_ctrl;
-        static volatile struct BOARD_CTRL *board_ctrl;
-        static volatile struct CH_CTRL *ch_ctrl;
-        static volatile struct BUF_CTRL *buf_ctrl;
+        static struct FIRM_ID *firm_id;
+        static struct ZFW_CTRL *zfw_ctrl;
+        static struct BOARD_CTRL *board_ctrl;
+        static struct CH_CTRL *ch_ctrl;
+        static struct BUF_CTRL *buf_ctrl;
+        unsigned long expires = jiffies + HZ;
         int card, port;
 
-        cyz_timerlist.expires = jiffies + (HZ);
         for (card = 0; card < NR_CARDS; card++) {
                 cinfo = &cy_card[card];
 
@@ -1930,12 +1868,12 @@ static void cyz_poll(unsigned long arg)
 
                 firm_id = cinfo->base_addr + ID_ADDRESS;
                 zfw_ctrl = cinfo->base_addr +
-                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                 board_ctrl = &(zfw_ctrl->board_ctrl);
 
         /* Skip first polling cycle to avoid racing conditions with the FW */
                 if (!cinfo->intr_enabled) {
-                        cinfo->nports = (int)cy_readl(&board_ctrl->n_channel);
+                        cinfo->nports = (int)readl(&board_ctrl->n_channel);
                         cinfo->intr_enabled = 1;
                         continue;
                 }
@@ -1943,7 +1881,7 @@ static void cyz_poll(unsigned long arg)
                 cyz_handle_cmd(cinfo);
 
                 for (port = 0; port < cinfo->nports; port++) {
-                        info = &cy_port[port + cinfo->first_line];
+                        info = &cinfo->ports[port];
                         tty = info->tty;
                         ch_ctrl = &(zfw_ctrl->ch_ctrl[port]);
                         buf_ctrl = &(zfw_ctrl->buf_ctrl[port]);
@@ -1953,9 +1891,9 @@ static void cyz_poll(unsigned long arg)
                         cyz_handle_tx(info, ch_ctrl, buf_ctrl);
                 }
                 /* poll every 'cyz_polling_cycle' period */
-                cyz_timerlist.expires = jiffies + cyz_polling_cycle;
+                expires = jiffies + cyz_polling_cycle;
         }
-        add_timer(&cyz_timerlist);
+        mod_timer(&cyz_timerlist, expires);
 }                               /* cyz_poll */
 
 #endif                          /* CONFIG_CYZ_INTR */
@@ -1968,20 +1906,21 @@ static void cyz_poll(unsigned long arg)
  */
 static int startup(struct cyclades_port *info)
 {
+        struct cyclades_card *card;
         unsigned long flags;
         int retval = 0;
         void __iomem *base_addr;
-        int card, chip, channel, index;
+        int chip, channel, index;
         unsigned long page;
 
         card = info->card;
-        channel = (info->line) - (cy_card[card].first_line);
+        channel = info->line - card->first_line;
 
         page = get_zeroed_page(GFP_KERNEL);
         if (!page)
                 return -ENOMEM;
 
-        CY_LOCK(info, flags);
+        spin_lock_irqsave(&card->card_lock, flags);
 
         if (info->flags & ASYNC_INITIALIZED) {
                 free_page(page);
@@ -2001,24 +1940,22 @@ static int startup(struct cyclades_port *info)
         else
                 info->xmit_buf = (unsigned char *)page;
 
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&card->card_lock, flags);
 
         set_line_char(info);
 
-        if (!IS_CYC_Z(cy_card[card])) {
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr = cy_card[card].base_addr +
-                                (cy_chip_offset[chip] << index);
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
 #ifdef CY_DEBUG_OPEN
-                printk("cyc startup card %d, chip %d, channel %d, "
-                                "base_addr %lx\n",
-                                card, chip, channel, (long)base_addr);
-                /**/
+                printk(KERN_DEBUG "cyc startup card %d, chip %d, channel %d, "
+                                "base_addr %p\n",
+                                card, chip, channel, base_addr);
 #endif
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
 
                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
 
@@ -2034,14 +1971,14 @@ static int startup(struct cyclades_port *info)
                 cy_writeb(base_addr + (CyMSVR2 << index), CyDTR);
 
 #ifdef CY_DEBUG_DTR
-                printk("cyc:startup raising DTR\n");
-                printk("     status: 0x%x, 0x%x\n",
-                        cy_readb(base_addr + (CyMSVR1 << index)),
-                        cy_readb(base_addr + (CyMSVR2 << index)));
+                printk(KERN_DEBUG "cyc:startup raising DTR\n");
+                printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
+                        readb(base_addr + (CyMSVR1 << index)),
+                        readb(base_addr + (CyMSVR2 << index)));
 #endif
 
                 cy_writeb(base_addr + (CySRER << index),
-                        cy_readb(base_addr + (CySRER << index)) | CyRxData);
+                        readb(base_addr + (CySRER << index)) | CyRxData);
                 info->flags |= ASYNC_INITIALIZED;
 
                 if (info->tty) {
@@ -2054,7 +1991,7 @@ static int startup(struct cyclades_port *info)
                 info->idle_stats.recv_idle =
                 info->idle_stats.xmit_idle = jiffies;
 
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
 
         } else {
                 struct FIRM_ID __iomem *firm_id;
@@ -2063,24 +2000,23 @@ static int startup(struct cyclades_port *info)
                 struct CH_CTRL __iomem *ch_ctrl;
                 int retval;
 
-                base_addr = cy_card[card].base_addr;
+                base_addr = card->base_addr;
 
                 firm_id = base_addr + ID_ADDRESS;
-                if (!ISZLOADED(cy_card[card])) {
+                if (!ISZLOADED(*card)) {
                         return -ENODEV;
                 }
 
-                zfw_ctrl = cy_card[card].base_addr +
-                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                zfw_ctrl = card->base_addr +
+                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                 board_ctrl = &zfw_ctrl->board_ctrl;
                 ch_ctrl = zfw_ctrl->ch_ctrl;
 
 #ifdef CY_DEBUG_OPEN
-                printk("cyc startup Z card %d, channel %d, base_addr %lx\n",
-                        card, channel, (long)base_addr);
-                /**/
+                printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
+                        "base_addr %p\n", card, channel, base_addr);
 #endif
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
 
                 cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE);
 #ifdef Z_WAKE
@@ -2102,33 +2038,31 @@ static int startup(struct cyclades_port *info)
 #endif                          /* CONFIG_CYZ_INTR */
 #endif                          /* Z_WAKE */
 
-                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
+                retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
                 if (retval != 0) {
-                        printk("cyc:startup(1) retval on ttyC%d was %x\n",
-                                info->line, retval);
+                        printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
+                                "%x\n", info->line, retval);
                 }
 
                 /* Flush RX buffers before raising DTR and RTS */
-                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_RX,
-                                0L);
+                retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
                 if (retval != 0) {
-                        printk("cyc:startup(2) retval on ttyC%d was %x\n",
-                                info->line, retval);
+                        printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
+                                "%x\n", info->line, retval);
                 }
 
                 /* set timeout !!! */
                 /* set RTS and DTR !!! */
                 cy_writel(&ch_ctrl[channel].rs_control,
-                        cy_readl(&ch_ctrl[channel].rs_control) | C_RS_RTS |
+                        readl(&ch_ctrl[channel].rs_control) | C_RS_RTS |
                         C_RS_DTR);
-                retval = cyz_issue_cmd(&cy_card[info->card], channel,
-                                C_CM_IOCTLM, 0L);
+                retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
                 if (retval != 0) {
-                        printk("cyc:startup(3) retval on ttyC%d was %x\n",
-                                info->line, retval);
+                        printk(KERN_ERR "cyc:startup(3) retval on ttyC%d was "
+                                "%x\n", info->line, retval);
                 }
 #ifdef CY_DEBUG_DTR
-                printk("cyc:startup raising Z DTR\n");
+                printk(KERN_DEBUG "cyc:startup raising Z DTR\n");
 #endif
 
                 /* enable send, recv, modem !!! */
@@ -2144,51 +2078,50 @@ static int startup(struct cyclades_port *info)
                 info->idle_stats.recv_idle =
                 info->idle_stats.xmit_idle = jiffies;
 
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
         }
 
 #ifdef CY_DEBUG_OPEN
-        printk(" cyc startup done\n");
+        printk(KERN_DEBUG "cyc startup done\n");
 #endif
         return 0;
 
 errout:
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&card->card_lock, flags);
         return retval;
 }                               /* startup */
 
 static void start_xmit(struct cyclades_port *info)
 {
+        struct cyclades_card *card;
         unsigned long flags;
         void __iomem *base_addr;
-        int card, chip, channel, index;
+        int chip, channel, index;
 
         card = info->card;
-        channel = (info->line) - (cy_card[card].first_line);
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = info->line - card->first_line;
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr = cy_card[card].base_addr +
-                                (cy_chip_offset[chip] << index);
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
                 cy_writeb(base_addr + (CyCAR << index), channel);
                 cy_writeb(base_addr + (CySRER << index),
-                        cy_readb(base_addr + (CySRER << index)) | CyTxRdy);
-                CY_UNLOCK(info, flags);
+                        readb(base_addr + (CySRER << index)) | CyTxRdy);
+                spin_unlock_irqrestore(&card->card_lock, flags);
         } else {
 #ifdef CONFIG_CYZ_INTR
                 int retval;
 
-                CY_LOCK(info, flags);
-                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK,
-                                0L);
+                spin_lock_irqsave(&card->card_lock, flags);
+                retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
                 if (retval != 0) {
-                        printk("cyc:start_xmit retval on ttyC%d was %x\n",
-                                info->line, retval);
+                        printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
+                                "%x\n", info->line, retval);
                 }
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
 #else                           /* CONFIG_CYZ_INTR */
                 /* Don't have to do anything at this time */
 #endif                          /* CONFIG_CYZ_INTR */
@@ -2201,30 +2134,30 @@ static void start_xmit(struct cyclades_port *info)
  */
 static void shutdown(struct cyclades_port *info)
 {
+        struct cyclades_card *card;
         unsigned long flags;
         void __iomem *base_addr;
-        int card, chip, channel, index;
+        int chip, channel, index;
 
         if (!(info->flags & ASYNC_INITIALIZED)) {
                 return;
         }
 
         card = info->card;
-        channel = info->line - cy_card[card].first_line;
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = info->line - card->first_line;
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr = cy_card[card].base_addr +
-                                (cy_chip_offset[chip] << index);
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
 #ifdef CY_DEBUG_OPEN
-                printk("cyc shutdown Y card %d, chip %d, channel %d, "
-                                "base_addr %lx\n",
-                                card, chip, channel, (long)base_addr);
+                printk(KERN_DEBUG "cyc shutdown Y card %d, chip %d, "
+                                "channel %d, base_addr %p\n",
+                                card, chip, channel, base_addr);
 #endif
 
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
 
                 /* Clear delta_msr_wait queue to avoid mem leaks. */
                 wake_up_interruptible(&info->delta_msr_wait);
@@ -2240,10 +2173,10 @@ static void shutdown(struct cyclades_port *info)
                         cy_writeb(base_addr + (CyMSVR1 << index), ~CyRTS);
                         cy_writeb(base_addr + (CyMSVR2 << index), ~CyDTR);
 #ifdef CY_DEBUG_DTR
-                        printk("cyc shutdown dropping DTR\n");
-                        printk("     status: 0x%x, 0x%x\n",
-                                cy_readb(base_addr + (CyMSVR1 << index)),
-                                cy_readb(base_addr + (CyMSVR2 << index)));
+                        printk(KERN_DEBUG "cyc shutdown dropping DTR\n");
+                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
+                                readb(base_addr + (CyMSVR1 << index)),
+                                readb(base_addr + (CyMSVR2 << index)));
 #endif
                 }
                 cyy_issue_cmd(base_addr, CyCHAN_CTL | CyDIS_RCVR, index);
@@ -2254,7 +2187,7 @@ static void shutdown(struct cyclades_port *info)
                         set_bit(TTY_IO_ERROR, &info->tty->flags);
                 }
                 info->flags &= ~ASYNC_INITIALIZED;
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
         } else {
                 struct FIRM_ID __iomem *firm_id;
                 struct ZFW_CTRL __iomem *zfw_ctrl;
@@ -2262,23 +2195,23 @@ static void shutdown(struct cyclades_port *info)
                 struct CH_CTRL __iomem *ch_ctrl;
                 int retval;
 
-                base_addr = cy_card[card].base_addr;
+                base_addr = card->base_addr;
 #ifdef CY_DEBUG_OPEN
-                printk("cyc shutdown Z card %d, channel %d, base_addr %lx\n",
-                        card, channel, (long)base_addr);
+                printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
+                        "base_addr %p\n", card, channel, base_addr);
 #endif
 
                 firm_id = base_addr + ID_ADDRESS;
-                if (!ISZLOADED(cy_card[card])) {
+                if (!ISZLOADED(*card)) {
                         return;
                 }
 
-                zfw_ctrl = cy_card[card].base_addr +
-                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                zfw_ctrl = card->base_addr +
+                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                 board_ctrl = &zfw_ctrl->board_ctrl;
                 ch_ctrl = zfw_ctrl->ch_ctrl;
 
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
 
                 if (info->xmit_buf) {
                         unsigned char *temp;
@@ -2289,16 +2222,16 @@ static void shutdown(struct cyclades_port *info)
 
                 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
                         cy_writel(&ch_ctrl[channel].rs_control,
-                                (uclong)(cy_readl(&ch_ctrl[channel].rs_control)&
+                                (__u32)(readl(&ch_ctrl[channel].rs_control) &
                                         ~(C_RS_RTS | C_RS_DTR)));
-                        retval = cyz_issue_cmd(&cy_card[info->card], channel,
+                        retval = cyz_issue_cmd(info->card, channel,
                                         C_CM_IOCTLM, 0L);
                         if (retval != 0) {
-                                printk("cyc:shutdown retval on ttyC%d was %x\n",
-                                        info->line, retval);
+                                printk(KERN_ERR"cyc:shutdown retval on ttyC%d "
+                                        "was %x\n", info->line, retval);
                         }
 #ifdef CY_DEBUG_DTR
-                        printk("cyc:shutdown dropping Z DTR\n");
+                        printk(KERN_DEBUG "cyc:shutdown dropping Z DTR\n");
 #endif
                 }
 
@@ -2307,11 +2240,11 @@ static void shutdown(struct cyclades_port *info)
                 }
                 info->flags &= ~ASYNC_INITIALIZED;
 
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
         }
 
 #ifdef CY_DEBUG_OPEN
-        printk(" cyc shutdown done\n");
+        printk(KERN_DEBUG "cyc shutdown done\n");
 #endif
 }                               /* shutdown */
 
@@ -2332,7 +2265,7 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
         int retval;
         void __iomem *base_addr;
 
-        cinfo = &cy_card[info->card];
+        cinfo = info->card;
         channel = info->line - cinfo->first_line;
 
         /*
@@ -2340,9 +2273,8 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
          * until it's done, and then try again.
          */
         if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
-                if (info->flags & ASYNC_CLOSING) {
-                        interruptible_sleep_on(&info->close_wait);
-                }
+                wait_event_interruptible(info->close_wait,
+                                !(info->flags & ASYNC_CLOSING));
                 return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
         }
 
@@ -2365,17 +2297,16 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
         retval = 0;
         add_wait_queue(&info->open_wait, &wait);
 #ifdef CY_DEBUG_OPEN
-        printk("cyc block_til_ready before block: ttyC%d, count = %d\n",
-                info->line, info->count);
-        /**/
+        printk(KERN_DEBUG "cyc block_til_ready before block: ttyC%d, "
+                "count = %d\n", info->line, info->count);
 #endif
-        CY_LOCK(info, flags);
+        spin_lock_irqsave(&cinfo->card_lock, flags);
         if (!tty_hung_up_p(filp))
                 info->count--;
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&cinfo->card_lock, flags);
 #ifdef CY_DEBUG_COUNT
-        printk("cyc block_til_ready: (%d): decrementing count to %d\n",
-                current->pid, info->count);
+        printk(KERN_DEBUG "cyc block_til_ready: (%d): decrementing count to "
+                "%d\n", current->pid, info->count);
 #endif
         info->blocked_open++;
 
@@ -2386,7 +2317,7 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
                 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
 
                 while (1) {
-                        CY_LOCK(info, flags);
+                        spin_lock_irqsave(&cinfo->card_lock, flags);
                         if ((tty->termios->c_cflag & CBAUD)) {
                                 cy_writeb(base_addr + (CyCAR << index),
                                           (u_char) channel);
@@ -2395,15 +2326,14 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
                                 cy_writeb(base_addr + (CyMSVR2 << index),
                                           CyDTR);
 #ifdef CY_DEBUG_DTR
-                                printk("cyc:block_til_ready raising DTR\n");
-                                printk("     status: 0x%x, 0x%x\n",
-                                        cy_readb(base_addr +
-                                                (CyMSVR1 << index)),
-                                        cy_readb(base_addr +
-                                                (CyMSVR2 << index)));
+                                printk(KERN_DEBUG "cyc:block_til_ready raising "
+                                        "DTR\n");
+                                printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
+                                        readb(base_addr + (CyMSVR1 << index)),
+                                        readb(base_addr + (CyMSVR2 << index)));
 #endif
                         }
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&cinfo->card_lock, flags);
 
                         set_current_state(TASK_INTERRUPTIBLE);
                         if (tty_hung_up_p(filp) ||
@@ -2413,26 +2343,25 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
                                 break;
                         }
 
-                        CY_LOCK(info, flags);
+                        spin_lock_irqsave(&cinfo->card_lock, flags);
                         cy_writeb(base_addr + (CyCAR << index),
                                   (u_char) channel);
                         if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
-                                        (cy_readb(base_addr +
+                                        (readb(base_addr +
                                                 (CyMSVR1 << index)) & CyDCD))) {
-                                CY_UNLOCK(info, flags);
+                                spin_unlock_irqrestore(&cinfo->card_lock, flags);
                                 break;
                         }
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&cinfo->card_lock, flags);
 
                         if (signal_pending(current)) {
                                 retval = -ERESTARTSYS;
                                 break;
                         }
 #ifdef CY_DEBUG_OPEN
-                        printk("cyc block_til_ready blocking: ttyC%d, "
-                                        "count = %d\n",
-                                        info->line, info->count);
-                        /**/
+                        printk(KERN_DEBUG "cyc block_til_ready blocking: "
+                                "ttyC%d, count = %d\n",
+                                info->line, info->count);
 #endif
                         schedule();
                 }
@@ -2446,31 +2375,30 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
                 base_addr = cinfo->base_addr;
                 firm_id = base_addr + ID_ADDRESS;
                 if (!ISZLOADED(*cinfo)) {
-                        current->state = TASK_RUNNING;
+                        __set_current_state(TASK_RUNNING);
                         remove_wait_queue(&info->open_wait, &wait);
                         return -EINVAL;
                 }
 
-                zfw_ctrl = base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
-                                0xfffff);
+                zfw_ctrl = base_addr + (readl(&firm_id->zfwctrl_addr)& 0xfffff);
                 board_ctrl = &zfw_ctrl->board_ctrl;
                 ch_ctrl = zfw_ctrl->ch_ctrl;
 
                 while (1) {
                         if ((tty->termios->c_cflag & CBAUD)) {
                                 cy_writel(&ch_ctrl[channel].rs_control,
-                                          cy_readl(&ch_ctrl[channel].
-                                                   rs_control) | (C_RS_RTS |
-                                                                  C_RS_DTR));
-                                retval = cyz_issue_cmd(&cy_card[info->card],
-                                                channel, C_CM_IOCTLM, 0L);
+                                        readl(&ch_ctrl[channel].rs_control) |
+                                        C_RS_RTS | C_RS_DTR);
+                                retval = cyz_issue_cmd(cinfo,
+                                        channel, C_CM_IOCTLM, 0L);
                                 if (retval != 0) {
-                                        printk("cyc:block_til_ready retval on "
-                                                "ttyC%d was %x\n",
+                                        printk(KERN_ERR "cyc:block_til_ready "
+                                                "retval on ttyC%d was %x\n",
                                                 info->line, retval);
                                 }
 #ifdef CY_DEBUG_DTR
-                                printk("cyc:block_til_ready raising Z DTR\n");
+                                printk(KERN_DEBUG "cyc:block_til_ready raising "
+                                        "Z DTR\n");
 #endif
                         }
 
@@ -2482,7 +2410,7 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
                                 break;
                         }
                         if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
-                                        (cy_readl(&ch_ctrl[channel].rs_status) &
+                                        (readl(&ch_ctrl[channel].rs_status) &
                                                 C_RS_DCD))) {
                                 break;
                         }
@@ -2491,28 +2419,26 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
                                 break;
                         }
 #ifdef CY_DEBUG_OPEN
-                        printk("cyc block_til_ready blocking: ttyC%d, "
-                                        "count = %d\n",
-                                        info->line, info->count);
-                        /**/
+                        printk(KERN_DEBUG "cyc block_til_ready blocking: "
+                                "ttyC%d, count = %d\n",
+                                info->line, info->count);
 #endif
                         schedule();
                 }
         }
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&info->open_wait, &wait);
         if (!tty_hung_up_p(filp)) {
                 info->count++;
 #ifdef CY_DEBUG_COUNT
-                printk("cyc:block_til_ready (%d): incrementing count to %d\n",
-                        current->pid, info->count);
+                printk(KERN_DEBUG "cyc:block_til_ready (%d): incrementing "
+                        "count to %d\n", current->pid, info->count);
 #endif
         }
         info->blocked_open--;
 #ifdef CY_DEBUG_OPEN
-        printk("cyc:block_til_ready after blocking: ttyC%d, count = %d\n",
-                info->line, info->count);
-        /**/
+        printk(KERN_DEBUG "cyc:block_til_ready after blocking: ttyC%d, "
+                "count = %d\n", info->line, info->count);
 #endif
         if (retval)
                 return retval;
@@ -2527,13 +2453,20 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
 static int cy_open(struct tty_struct *tty, struct file *filp)
 {
         struct cyclades_port *info;
+        unsigned int i;
         int retval, line;
 
         line = tty->index;
         if ((line < 0) || (NR_PORTS <= line)) {
                 return -ENODEV;
         }
-        info = &cy_port[line];
+        for (i = 0; i < NR_CARDS; i++)
+                if (line < cy_card[i].first_line + cy_card[i].nports &&
+                                line >= cy_card[i].first_line)
+                        break;
+        if (i >= NR_CARDS)
+                return -ENODEV;
+        info = &cy_card[i].ports[line - cy_card[i].first_line];
         if (info->line < 0) {
                 return -ENODEV;
         }
@@ -2542,23 +2475,23 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
            treat it as absent from the system.  This
            will make the user pay attention.
          */
-        if (IS_CYC_Z(cy_card[info->card])) {
-                struct cyclades_card *cinfo = &cy_card[info->card];
+        if (IS_CYC_Z(*info->card)) {
+                struct cyclades_card *cinfo = info->card;
                 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
 
                 if (!ISZLOADED(*cinfo)) {
-                        if (((ZE_V1 == cy_readl(
-                                        &((struct RUNTIME_9060 __iomem *)
+                        if (((ZE_V1 == readl(&((struct RUNTIME_9060 __iomem *)
                                          (cinfo->ctl_addr))->mail_box_0)) &&
                                         Z_FPGA_CHECK(*cinfo)) &&
-                                        (ZFIRM_HLT == cy_readl(
+                                        (ZFIRM_HLT == readl(
                                                 &firm_id->signature))) {
-                                printk("cyc:Cyclades-Z Error: you need an "
-                                        "external power supply for this number "
-                                        "of ports.\n\rFirmware halted.\r\n");
+                                printk(KERN_ERR "cyc:Cyclades-Z Error: you "
+                                        "need an external power supply for "
+                                        "this number of ports.\nFirmware "
+                                        "halted.\n");
                         } else {
-                                printk("cyc:Cyclades-Z firmware not yet "
-                                        "loaded\n");
+                                printk(KERN_ERR "cyc:Cyclades-Z firmware not "
+                                        "yet loaded\n");
                         }
                         return -ENODEV;
                 }
@@ -2572,24 +2505,23 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
                                 struct BOARD_CTRL __iomem *board_ctrl;
 
                                 zfw_ctrl = cinfo->base_addr +
-                                        (cy_readl(&firm_id->zfwctrl_addr) &
-                                                0xfffff);
+                                        (readl(&firm_id->zfwctrl_addr) &
+                                         0xfffff);
 
                                 board_ctrl = &zfw_ctrl->board_ctrl;
 
                                 /* Enable interrupts on the PLX chip */
                                 cy_writew(cinfo->ctl_addr + 0x68,
-                                          cy_readw(cinfo->ctl_addr +
-                                                   0x68) | 0x0900);
+                                        readw(cinfo->ctl_addr + 0x68) | 0x0900);
                                 /* Enable interrupts on the FW */
                                 retval = cyz_issue_cmd(cinfo, 0,
                                                 C_CM_IRQ_ENBL, 0L);
                                 if (retval != 0) {
-                                        printk("cyc:IRQ enable retval was %x\n",
-                                                retval);
+                                        printk(KERN_ERR "cyc:IRQ enable retval "
+                                                "was %x\n", retval);
                                 }
                                 cinfo->nports =
-                                        (int)cy_readl(&board_ctrl->n_channel);
+                                        (int)readl(&board_ctrl->n_channel);
                                 cinfo->intr_enabled = 1;
                         }
                 }
@@ -2599,7 +2531,7 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
                         return -ENODEV;
         }
 #ifdef CY_DEBUG_OTHER
-        printk("cyc:cy_open ttyC%d\n", info->line);     /* */
+        printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
 #endif
         tty->driver_data = info;
         info->tty = tty;
@@ -2607,12 +2539,12 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
                 return -ENODEV;
         }
 #ifdef CY_DEBUG_OPEN
-        printk("cyc:cy_open ttyC%d, count = %d\n", info->line, info->count);
-        /**/
+        printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
+                        info->count);
 #endif
         info->count++;
 #ifdef CY_DEBUG_COUNT
-        printk("cyc:cy_open (%d): incrementing count to %d\n",
+        printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
                 current->pid, info->count);
 #endif
 
@@ -2620,8 +2552,8 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
          * If the port is the middle of closing, bail out now
          */
         if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
-                if (info->flags & ASYNC_CLOSING)
-                        interruptible_sleep_on(&info->close_wait);
+                wait_event_interruptible(info->close_wait,
+                                !(info->flags & ASYNC_CLOSING));
                 return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
         }
 
@@ -2636,8 +2568,8 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
         retval = block_til_ready(tty, filp, info);
         if (retval) {
 #ifdef CY_DEBUG_OPEN
-                printk("cyc:cy_open returning after block_til_ready with %d\n",
-                        retval);
+                printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
+                        "with %d\n", retval);
 #endif
                 return retval;
         }
@@ -2645,8 +2577,7 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
         info->throttle = 0;
 
 #ifdef CY_DEBUG_OPEN
-        printk(" cyc:cy_open done\n");
-        /**/
+        printk(KERN_DEBUG "cyc:cy_open done\n");
 #endif
         return 0;
 }                               /* cy_open */
@@ -2656,9 +2587,10 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
  */
 static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_card *card;
+        struct cyclades_port *info = tty->driver_data;
         void __iomem *base_addr;
-        int card, chip, channel, index;
+        int chip, channel, index;
         unsigned long orig_jiffies;
         int char_time;
 
@@ -2697,20 +2629,19 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
         if (!timeout || timeout > 2 * info->timeout)
                 timeout = 2 * info->timeout;
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
-        printk("In cy_wait_until_sent(%d) check=%lu...", timeout, char_time);
-        printk("jiff=%lu...", jiffies);
+        printk(KERN_DEBUG "In cy_wait_until_sent(%d) check=%d, jiff=%lu...",
+                timeout, char_time, jiffies);
 #endif
         card = info->card;
-        channel = (info->line) - (cy_card[card].first_line);
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = (info->line) - (card->first_line);
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr =
-                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
-                while (cy_readb(base_addr + (CySRER << index)) & CyTxRdy) {
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
+                while (readb(base_addr + (CySRER << index)) & CyTxRdy) {
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
-                        printk("Not clean (jiff=%lu)...", jiffies);
+                        printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies);
 #endif
                         if (msleep_interruptible(jiffies_to_msecs(char_time)))
                                 break;
@@ -2718,13 +2649,11 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
                                         timeout))
                                 break;
                 }
-        } else {
-                /* Nothing to do! */
         }
         /* Run one more char cycle */
         msleep_interruptible(jiffies_to_msecs(char_time * 5));
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
-        printk("Clean (jiff=%lu)...done\n", jiffies);
+        printk(KERN_DEBUG "Clean (jiff=%lu)...done\n", jiffies);
 #endif
 }
 
@@ -2733,25 +2662,29 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
  */
 static void cy_close(struct tty_struct *tty, struct file *filp)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
+        struct cyclades_card *card;
         unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
-        printk("cyc:cy_close ttyC%d\n", info->line);
+        printk(KERN_DEBUG "cyc:cy_close ttyC%d\n", info->line);
 #endif
 
         if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
                 return;
         }
 
-        CY_LOCK(info, flags);
+        card = info->card;
+
+        spin_lock_irqsave(&card->card_lock, flags);
         /* If the TTY is being hung up, nothing to do */
         if (tty_hung_up_p(filp)) {
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
                 return;
         }
 #ifdef CY_DEBUG_OPEN
-        printk("cyc:cy_close ttyC%d, count = %d\n", info->line, info->count);
+        printk(KERN_DEBUG "cyc:cy_close ttyC%d, count = %d\n", info->line,
+                info->count);
 #endif
         if ((tty->count == 1) && (info->count != 1)) {
                 /*
@@ -2761,22 +2694,22 @@ static void cy_close(struct tty_struct *tty, struct file *filp)
                  * one, we've got real problems, since it means the
                  * serial port won't be shutdown.
                  */
-                printk("cyc:cy_close: bad serial port count; tty->count is 1, "
-                        "info->count is %d\n", info->count);
+                printk(KERN_ERR "cyc:cy_close: bad serial port count; "
+                        "tty->count is 1, info->count is %d\n", info->count);
                 info->count = 1;
         }
 #ifdef CY_DEBUG_COUNT
-        printk("cyc:cy_close at (%d): decrementing count to %d\n",
+        printk(KERN_DEBUG  "cyc:cy_close at (%d): decrementing count to %d\n",
                 current->pid, info->count - 1);
 #endif
         if (--info->count < 0) {
 #ifdef CY_DEBUG_COUNT
-                printk("cyc:cyc_close setting count to 0\n");
+                printk(KERN_DEBUG "cyc:cyc_close setting count to 0\n");
 #endif
                 info->count = 0;
         }
         if (info->count) {
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
                 return;
         }
         info->flags |= ASYNC_CLOSING;
@@ -2786,81 +2719,80 @@ static void cy_close(struct tty_struct *tty, struct file *filp)
          * the line discipline to only process XON/XOFF characters.
          */
         tty->closing = 1;
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&card->card_lock, flags);
         if (info->closing_wait != CY_CLOSING_WAIT_NONE) {
                 tty_wait_until_sent(tty, info->closing_wait);
         }
-        CY_LOCK(info, flags);
+        spin_lock_irqsave(&card->card_lock, flags);
 
-        if (!IS_CYC_Z(cy_card[info->card])) {
-                int channel = info->line - cy_card[info->card].first_line;
-                int index = cy_card[info->card].bus_index;
-                void __iomem *base_addr = cy_card[info->card].base_addr +
+        if (!IS_CYC_Z(*card)) {
+                int channel = info->line - card->first_line;
+                int index = card->bus_index;
+                void __iomem *base_addr = card->base_addr +
                         (cy_chip_offset[channel >> 2] << index);
                 /* Stop accepting input */
                 channel &= 0x03;
                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
                 cy_writeb(base_addr + (CySRER << index),
-                          cy_readb(base_addr + (CySRER << index)) & ~CyRxData);
+                          readb(base_addr + (CySRER << index)) & ~CyRxData);
                 if (info->flags & ASYNC_INITIALIZED) {
                         /* Waiting for on-board buffers to be empty before closing
                            the port */
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&card->card_lock, flags);
                         cy_wait_until_sent(tty, info->timeout);
-                        CY_LOCK(info, flags);
+                        spin_lock_irqsave(&card->card_lock, flags);
                 }
         } else {
 #ifdef Z_WAKE
                 /* Waiting for on-board buffers to be empty before closing the port */
-                void __iomem *base_addr = cy_card[info->card].base_addr;
+                void __iomem *base_addr = card->base_addr;
                 struct FIRM_ID __iomem *firm_id = base_addr + ID_ADDRESS;
                 struct ZFW_CTRL __iomem *zfw_ctrl =
-                    base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                    base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                 struct CH_CTRL __iomem *ch_ctrl = zfw_ctrl->ch_ctrl;
-                int channel = info->line - cy_card[info->card].first_line;
+                int channel = info->line - card->first_line;
                 int retval;
 
-                if (cy_readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
-                        retval = cyz_issue_cmd(&cy_card[info->card], channel,
-                                                C_CM_IOCTLW, 0L);
+                if (readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
+                        retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
                         if (retval != 0) {
-                                printk("cyc:cy_close retval on ttyC%d was %x\n",
-                                        info->line, retval);
+                                printk(KERN_DEBUG "cyc:cy_close retval on "
+                                        "ttyC%d was %x\n", info->line, retval);
                         }
-                        CY_UNLOCK(info, flags);
-                        interruptible_sleep_on(&info->shutdown_wait);
-                        CY_LOCK(info, flags);
+                        spin_unlock_irqrestore(&card->card_lock, flags);
+                        wait_for_completion_interruptible(&info->shutdown_wait);
+                        spin_lock_irqsave(&card->card_lock, flags);
                 }
 #endif
         }
 
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&card->card_lock, flags);
         shutdown(info);
         if (tty->driver->flush_buffer)
                 tty->driver->flush_buffer(tty);
         tty_ldisc_flush(tty);
-        CY_LOCK(info, flags);
+        spin_lock_irqsave(&card->card_lock, flags);
 
         tty->closing = 0;
         info->event = 0;
         info->tty = NULL;
         if (info->blocked_open) {
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
                 if (info->close_delay) {
                         msleep_interruptible(jiffies_to_msecs
                                                 (info->close_delay));
                 }
                 wake_up_interruptible(&info->open_wait);
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
         }
         info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
         wake_up_interruptible(&info->close_wait);
 
 #ifdef CY_DEBUG_OTHER
-        printk(" cyc:cy_close done\n");
+        printk(KERN_DEBUG "cyc:cy_close done\n");
 #endif
 
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&card->card_lock, flags);
 }                               /* cy_close */
 
 /* This routine gets called when tty_write has put something into
@@ -2878,12 +2810,12 @@ static void cy_close(struct tty_struct *tty, struct file *filp)
  */
 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
         unsigned long flags;
         int c, ret = 0;
 
 #ifdef CY_DEBUG_IO
-        printk("cyc:cy_write ttyC%d\n", info->line);    /* */
+        printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
 #endif
 
         if (serial_paranoia_check(info, tty->name, "cy_write")) {
@@ -2893,7 +2825,7 @@ static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
         if (!info->xmit_buf)
                 return 0;
 
-        CY_LOCK(info, flags);
+        spin_lock_irqsave(&info->card->card_lock, flags);
         while (1) {
                 c = min(count, min((int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1),
                                    (int)(SERIAL_XMIT_SIZE - info->xmit_head)));
@@ -2909,7 +2841,7 @@ static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
                 count -= c;
                 ret += c;
         }
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&info->card->card_lock, flags);
 
         info->idle_stats.xmit_bytes += ret;
         info->idle_stats.xmit_idle = jiffies;
@@ -2929,11 +2861,11 @@ static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
  */
 static void cy_put_char(struct tty_struct *tty, unsigned char ch)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
         unsigned long flags;
 
 #ifdef CY_DEBUG_IO
-        printk("cyc:cy_put_char ttyC%d\n", info->line);
+        printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
 #endif
 
         if (serial_paranoia_check(info, tty->name, "cy_put_char"))
@@ -2942,9 +2874,9 @@ static void cy_put_char(struct tty_struct *tty, unsigned char ch)
         if (!info->xmit_buf)
                 return;
 
-        CY_LOCK(info, flags);
+        spin_lock_irqsave(&info->card->card_lock, flags);
         if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&info->card->card_lock, flags);
                 return;
         }
 
@@ -2953,7 +2885,7 @@ static void cy_put_char(struct tty_struct *tty, unsigned char ch)
         info->xmit_cnt++;
         info->idle_stats.xmit_bytes++;
         info->idle_stats.xmit_idle = jiffies;
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&info->card->card_lock, flags);
 }                               /* cy_put_char */
 
 /*
@@ -2962,10 +2894,10 @@ static void cy_put_char(struct tty_struct *tty, unsigned char ch)
  */
 static void cy_flush_chars(struct tty_struct *tty)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
 
 #ifdef CY_DEBUG_IO
-        printk("cyc:cy_flush_chars ttyC%d\n", info->line);      /* */
+        printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
 #endif
 
         if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
@@ -2986,11 +2918,11 @@ static void cy_flush_chars(struct tty_struct *tty)
  */
 static int cy_write_room(struct tty_struct *tty)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
         int ret;
 
 #ifdef CY_DEBUG_IO
-        printk("cyc:cy_write_room ttyC%d\n", info->line);       /* */
+        printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
 #endif
 
         if (serial_paranoia_check(info, tty->name, "cy_write_room"))
@@ -3003,46 +2935,49 @@ static int cy_write_room(struct tty_struct *tty)
 
 static int cy_chars_in_buffer(struct tty_struct *tty)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-        int card, channel;
+        struct cyclades_card *card;
+        struct cyclades_port *info = tty->driver_data;
+        int channel;
 
         if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
                 return 0;
 
         card = info->card;
-        channel = (info->line) - (cy_card[card].first_line);
+        channel = (info->line) - (card->first_line);
 
 #ifdef Z_EXT_CHARS_IN_BUFFER
         if (!IS_CYC_Z(cy_card[card])) {
 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
 #ifdef CY_DEBUG_IO
-                printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt);       /* */
+                printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
+                        info->line, info->xmit_cnt);
 #endif
                 return info->xmit_cnt;
 #ifdef Z_EXT_CHARS_IN_BUFFER
         } else {
-                static volatile struct FIRM_ID *firm_id;
-                static volatile struct ZFW_CTRL *zfw_ctrl;
-                static volatile struct CH_CTRL *ch_ctrl;
-                static volatile struct BUF_CTRL *buf_ctrl;
+                static struct FIRM_ID *firm_id;
+                static struct ZFW_CTRL *zfw_ctrl;
+                static struct CH_CTRL *ch_ctrl;
+                static struct BUF_CTRL *buf_ctrl;
                 int char_count;
-                volatile uclong tx_put, tx_get, tx_bufsize;
+                __u32 tx_put, tx_get, tx_bufsize;
 
-                firm_id = cy_card[card].base_addr + ID_ADDRESS;
-                zfw_ctrl = cy_card[card].base_addr +
-                        (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                firm_id = card->base_addr + ID_ADDRESS;
+                zfw_ctrl = card->base_addr +
+                        (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
                 buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
 
-                tx_get = cy_readl(&buf_ctrl->tx_get);
-                tx_put = cy_readl(&buf_ctrl->tx_put);
-                tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
+                tx_get = readl(&buf_ctrl->tx_get);
+                tx_put = readl(&buf_ctrl->tx_put);
+                tx_bufsize = readl(&buf_ctrl->tx_bufsize);
                 if (tx_put >= tx_get)
                         char_count = tx_put - tx_get;
                 else
                         char_count = tx_put - tx_get + tx_bufsize;
 #ifdef CY_DEBUG_IO
-                printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt + char_count);  /* */
+                printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
+                        info->line, info->xmit_cnt + char_count);
 #endif
                 return info->xmit_cnt + char_count;
         }
@@ -3055,10 +2990,10 @@ static int cy_chars_in_buffer(struct tty_struct *tty)
  * ------------------------------------------------------------
  */
 
-static void cyy_baud_calc(struct cyclades_port *info, uclong baud)
+static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
 {
         int co, co_val, bpr;
-        uclong cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
+        __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
                         25000000);
 
         if (baud == 0) {
@@ -3086,9 +3021,10 @@ static void cyy_baud_calc(struct cyclades_port *info, uclong baud)
  */
 static void set_line_char(struct cyclades_port *info)
 {
+        struct cyclades_card *card;
         unsigned long flags;
         void __iomem *base_addr;
-        int card, chip, channel, index;
+        int chip, channel, index;
         unsigned cflag, iflag;
         unsigned short chip_number;
         int baud, baud_rate = 0;
@@ -3118,12 +3054,12 @@ static void set_line_char(struct cyclades_port *info)
         }
 
         card = info->card;
-        channel = (info->line) - (cy_card[card].first_line);
+        channel = info->line - card->first_line;
         chip_number = channel / 4;
 
-        if (!IS_CYC_Z(cy_card[card])) {
+        if (!IS_CYC_Z(*card)) {
 
-                index = cy_card[card].bus_index;
+                index = card->bus_index;
 
                 /* baud rate */
                 baud = tty_get_baud_rate(info->tty);
@@ -3241,10 +3177,9 @@ static void set_line_char(struct cyclades_port *info)
 
                 chip = channel >> 2;
                 channel &= 0x03;
-                base_addr = cy_card[card].base_addr +
-                        (cy_chip_offset[chip] << index);
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
 
                 /* tx and rx baud rate */
@@ -3276,8 +3211,7 @@ static void set_line_char(struct cyclades_port *info)
                 if (C_CLOCAL(info->tty)) {
                         /* without modem intr */
                         cy_writeb(base_addr + (CySRER << index),
-                                  cy_readb(base_addr +
-                                           (CySRER << index)) | CyMdmCh);
+                                readb(base_addr + (CySRER << index)) | CyMdmCh);
                         /* act on 1->0 modem transitions */
                         if ((cflag & CRTSCTS) && info->rflow) {
                                 cy_writeb(base_addr + (CyMCOR1 << index),
@@ -3291,7 +3225,7 @@ static void set_line_char(struct cyclades_port *info)
                 } else {
                         /* without modem intr */
                         cy_writeb(base_addr + (CySRER << index),
-                                  cy_readb(base_addr +
+                                  readb(base_addr +
                                            (CySRER << index)) | CyMdmCh);
                         /* act on 1->0 modem transitions */
                         if ((cflag & CRTSCTS) && info->rflow) {
@@ -3316,10 +3250,10 @@ static void set_line_char(struct cyclades_port *info)
                                           ~CyDTR);
                         }
 #ifdef CY_DEBUG_DTR
-                        printk("cyc:set_line_char dropping DTR\n");
-                        printk("     status: 0x%x, 0x%x\n",
-                                cy_readb(base_addr + (CyMSVR1 << index)),
-                                cy_readb(base_addr + (CyMSVR2 << index)));
+                        printk(KERN_DEBUG "cyc:set_line_char dropping DTR\n");
+                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
+                                readb(base_addr + (CyMSVR1 << index)),
+                                readb(base_addr + (CyMSVR2 << index)));
 #endif
                 } else {
                         if (info->rtsdtr_inv) {
@@ -3330,17 +3264,17 @@ static void set_line_char(struct cyclades_port *info)
                                           CyDTR);
                         }
 #ifdef CY_DEBUG_DTR
-                        printk("cyc:set_line_char raising DTR\n");
-                        printk("     status: 0x%x, 0x%x\n",
-                                cy_readb(base_addr + (CyMSVR1 << index)),
-                                cy_readb(base_addr + (CyMSVR2 << index)));
+                        printk(KERN_DEBUG "cyc:set_line_char raising DTR\n");
+                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
+                                readb(base_addr + (CyMSVR1 << index)),
+                                readb(base_addr + (CyMSVR2 << index)));
 #endif
                 }
 
                 if (info->tty) {
                         clear_bit(TTY_IO_ERROR, &info->tty->flags);
                 }
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
 
         } else {
                 struct FIRM_ID __iomem *firm_id;
@@ -3348,16 +3282,16 @@ static void set_line_char(struct cyclades_port *info)
                 struct BOARD_CTRL __iomem *board_ctrl;
                 struct CH_CTRL __iomem *ch_ctrl;
                 struct BUF_CTRL __iomem *buf_ctrl;
-                uclong sw_flow;
+                __u32 sw_flow;
                 int retval;
 
-                firm_id = cy_card[card].base_addr + ID_ADDRESS;
-                if (!ISZLOADED(cy_card[card])) {
+                firm_id = card->base_addr + ID_ADDRESS;
+                if (!ISZLOADED(*card)) {
                         return;
                 }
 
-                zfw_ctrl = cy_card[card].base_addr +
-                        (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                zfw_ctrl = card->base_addr +
+                        (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                 board_ctrl = &zfw_ctrl->board_ctrl;
                 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
                 buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
@@ -3408,10 +3342,10 @@ static void set_line_char(struct cyclades_port *info)
                 }
                 if (cflag & CSTOPB) {
                         cy_writel(&ch_ctrl->comm_data_l,
-                                  cy_readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
+                                  readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
                 } else {
                         cy_writel(&ch_ctrl->comm_data_l,
-                                  cy_readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
+                                  readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
                 }
                 if (cflag & PARENB) {
                         if (cflag & PARODD) {
@@ -3426,12 +3360,10 @@ static void set_line_char(struct cyclades_port *info)
                 /* CTS flow control flag */
                 if (cflag & CRTSCTS) {
                         cy_writel(&ch_ctrl->hw_flow,
-                                  cy_readl(&ch_ctrl->
-                                           hw_flow) | C_RS_CTS | C_RS_RTS);
+                                readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
                 } else {
-                        cy_writel(&ch_ctrl->hw_flow,
-                                  cy_readl(&ch_ctrl->
-                                           hw_flow) & ~(C_RS_CTS | C_RS_RTS));
+                        cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
+                                        ~(C_RS_CTS | C_RS_RTS));
                 }
                 /* As the HW flow control is done in firmware, the driver
                    doesn't need to care about it */
@@ -3446,10 +3378,10 @@ static void set_line_char(struct cyclades_port *info)
                 }
                 cy_writel(&ch_ctrl->sw_flow, sw_flow);
 
-                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
+                retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
                 if (retval != 0) {
-                        printk("cyc:set_line_char retval on ttyC%d was %x\n",
-                                info->line, retval);
+                        printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
+                                "was %x\n", info->line, retval);
                 }
 
                 /* CD sensitivity */
@@ -3461,22 +3393,22 @@ static void set_line_char(struct cyclades_port *info)
 
                 if (baud == 0) {        /* baud rate is zero, turn off line */
                         cy_writel(&ch_ctrl->rs_control,
-                                  cy_readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
+                                  readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-                        printk("cyc:set_line_char dropping Z DTR\n");
+                        printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
 #endif
                 } else {
                         cy_writel(&ch_ctrl->rs_control,
-                                  cy_readl(&ch_ctrl->rs_control) | C_RS_DTR);
+                                  readl(&ch_ctrl->rs_control) | C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-                        printk("cyc:set_line_char raising Z DTR\n");
+                        printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
 #endif
                 }
 
-                retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTLM,0L);
+                retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM,0L);
                 if (retval != 0) {
-                        printk("cyc:set_line_char(2) retval on ttyC%d was %x\n",
-                                info->line, retval);
+                        printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
+                                "was %x\n", info->line, retval);
                 }
 
                 if (info->tty) {
@@ -3490,14 +3422,15 @@ get_serial_info(struct cyclades_port *info,
                 struct serial_struct __user * retinfo)
 {
         struct serial_struct tmp;
-        struct cyclades_card *cinfo = &cy_card[info->card];
+        struct cyclades_card *cinfo = info->card;
 
         if (!retinfo)
                 return -EFAULT;
         memset(&tmp, 0, sizeof(tmp));
         tmp.type = info->type;
         tmp.line = info->line;
-        tmp.port = info->card * 0x100 + info->line - cinfo->first_line;
+        tmp.port = (info->card - cy_card) * 0x100 + info->line -
+                cinfo->first_line;
         tmp.irq = cinfo->irq;
         tmp.flags = info->flags;
         tmp.close_delay = info->close_delay;
@@ -3566,25 +3499,25 @@ check_and_exit:
  */
 static int get_lsr_info(struct cyclades_port *info, unsigned int __user * value)
 {
-        int card, chip, channel, index;
+        struct cyclades_card *card;
+        int chip, channel, index;
         unsigned char status;
         unsigned int result;
         unsigned long flags;
         void __iomem *base_addr;
 
         card = info->card;
-        channel = (info->line) - (cy_card[card].first_line);
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = (info->line) - (card->first_line);
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr =
-                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
-                CY_LOCK(info, flags);
-                status = cy_readb(base_addr + (CySRER << index)) &
+                spin_lock_irqsave(&card->card_lock, flags);
+                status = readb(base_addr + (CySRER << index)) &
                                 (CyTxRdy | CyTxMpty);
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
                 result = (status ? 0 : TIOCSER_TEMT);
         } else {
                 /* Not supported yet */
@@ -3595,8 +3528,9 @@ static int get_lsr_info(struct cyclades_port *info, unsigned int __user * value)
 
 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-        int card, chip, channel, index;
+        struct cyclades_port *info = tty->driver_data;
+        struct cyclades_card *card;
+        int chip, channel, index;
         void __iomem *base_addr;
         unsigned long flags;
         unsigned char status;
@@ -3611,19 +3545,18 @@ static int cy_tiocmget(struct tty_struct *tty, struct file *file)
                 return -ENODEV;
 
         card = info->card;
-        channel = (info->line) - (cy_card[card].first_line);
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = info->line - card->first_line;
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr =
-                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
-                status = cy_readb(base_addr + (CyMSVR1 << index));
-                status |= cy_readb(base_addr + (CyMSVR2 << index));
-                CY_UNLOCK(info, flags);
+                status = readb(base_addr + (CyMSVR1 << index));
+                status |= readb(base_addr + (CyMSVR2 << index));
+                spin_unlock_irqrestore(&card->card_lock, flags);
 
                 if (info->rtsdtr_inv) {
                         result = ((status & CyRTS) ? TIOCM_DTR : 0) |
@@ -3637,19 +3570,14 @@ static int cy_tiocmget(struct tty_struct *tty, struct file *file)
                         ((status & CyDSR) ? TIOCM_DSR : 0) |
                         ((status & CyCTS) ? TIOCM_CTS : 0);
         } else {
-                base_addr = cy_card[card].base_addr;
-
-                if (cy_card[card].num_chips != -1) {
-                        return -EINVAL;
-                }
-
-                firm_id = cy_card[card].base_addr + ID_ADDRESS;
-                if (ISZLOADED(cy_card[card])) {
-                        zfw_ctrl = cy_card[card].base_addr +
-                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                base_addr = card->base_addr;
+                firm_id = card->base_addr + ID_ADDRESS;
+                if (ISZLOADED(*card)) {
+                        zfw_ctrl = card->base_addr +
+                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                         board_ctrl = &zfw_ctrl->board_ctrl;
                         ch_ctrl = zfw_ctrl->ch_ctrl;
-                        lstatus = cy_readl(&ch_ctrl[channel].rs_status);
+                        lstatus = readl(&ch_ctrl[channel].rs_status);
                         result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
                                 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
                                 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
@@ -3669,8 +3597,9 @@ static int
 cy_tiocmset(struct tty_struct *tty, struct file *file,
                 unsigned int set, unsigned int clear)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-        int card, chip, channel, index;
+        struct cyclades_port *info = tty->driver_data;
+        struct cyclades_card *card;
+        int chip, channel, index;
         void __iomem *base_addr;
         unsigned long flags;
         struct FIRM_ID __iomem *firm_id;
@@ -3683,16 +3612,15 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
                 return -ENODEV;
 
         card = info->card;
-        channel = (info->line) - (cy_card[card].first_line);
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = (info->line) - (card->first_line);
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr =
-                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
                 if (set & TIOCM_RTS) {
-                        CY_LOCK(info, flags);
+                        spin_lock_irqsave(&card->card_lock, flags);
                         cy_writeb(base_addr + (CyCAR << index),
                                   (u_char) channel);
                         if (info->rtsdtr_inv) {
@@ -3702,10 +3630,10 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
                                 cy_writeb(base_addr + (CyMSVR1 << index),
                                           CyRTS);
                         }
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&card->card_lock, flags);
                 }
                 if (clear & TIOCM_RTS) {
-                        CY_LOCK(info, flags);
+                        spin_lock_irqsave(&card->card_lock, flags);
                         cy_writeb(base_addr + (CyCAR << index),
                                   (u_char) channel);
                         if (info->rtsdtr_inv) {
@@ -3715,10 +3643,10 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
                                 cy_writeb(base_addr + (CyMSVR1 << index),
                                           ~CyRTS);
                         }
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&card->card_lock, flags);
                 }
                 if (set & TIOCM_DTR) {
-                        CY_LOCK(info, flags);
+                        spin_lock_irqsave(&card->card_lock, flags);
                         cy_writeb(base_addr + (CyCAR << index),
                                   (u_char) channel);
                         if (info->rtsdtr_inv) {
@@ -3729,15 +3657,15 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
                                           CyDTR);
                         }
 #ifdef CY_DEBUG_DTR
-                        printk("cyc:set_modem_info raising DTR\n");
-                        printk("     status: 0x%x, 0x%x\n",
-                                cy_readb(base_addr + (CyMSVR1 << index)),
-                                cy_readb(base_addr + (CyMSVR2 << index)));
+                        printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
+                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
+                                readb(base_addr + (CyMSVR1 << index)),
+                                readb(base_addr + (CyMSVR2 << index)));
 #endif
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&card->card_lock, flags);
                 }
                 if (clear & TIOCM_DTR) {
-                        CY_LOCK(info, flags);
+                        spin_lock_irqsave(&card->card_lock, flags);
                         cy_writeb(base_addr + (CyCAR << index),
                                   (u_char) channel);
                         if (info->rtsdtr_inv) {
@@ -3749,68 +3677,69 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
                         }
 
 #ifdef CY_DEBUG_DTR
-                        printk("cyc:set_modem_info dropping DTR\n");
-                        printk("     status: 0x%x, 0x%x\n",
-                                cy_readb(base_addr + (CyMSVR1 << index)),
-                                cy_readb(base_addr + (CyMSVR2 << index)));
+                        printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
+                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
+                                readb(base_addr + (CyMSVR1 << index)),
+                                readb(base_addr + (CyMSVR2 << index)));
 #endif
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&card->card_lock, flags);
                 }
         } else {
-                base_addr = cy_card[card].base_addr;
+                base_addr = card->base_addr;
 
-                firm_id = cy_card[card].base_addr + ID_ADDRESS;
-                if (ISZLOADED(cy_card[card])) {
-                        zfw_ctrl = cy_card[card].base_addr +
-                                (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                firm_id = card->base_addr + ID_ADDRESS;
+                if (ISZLOADED(*card)) {
+                        zfw_ctrl = card->base_addr +
+                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                         board_ctrl = &zfw_ctrl->board_ctrl;
                         ch_ctrl = zfw_ctrl->ch_ctrl;
 
                         if (set & TIOCM_RTS) {
-                                CY_LOCK(info, flags);
+                                spin_lock_irqsave(&card->card_lock, flags);
                                 cy_writel(&ch_ctrl[channel].rs_control,
-                                          cy_readl(&ch_ctrl[channel].
-                                                   rs_control) | C_RS_RTS);
-                                CY_UNLOCK(info, flags);
+                                        readl(&ch_ctrl[channel].rs_control) |
+                                        C_RS_RTS);
+                                spin_unlock_irqrestore(&card->card_lock, flags);
                         }
                         if (clear & TIOCM_RTS) {
-                                CY_LOCK(info, flags);
+                                spin_lock_irqsave(&card->card_lock, flags);
                                 cy_writel(&ch_ctrl[channel].rs_control,
-                                          cy_readl(&ch_ctrl[channel].
-                                                   rs_control) & ~C_RS_RTS);
-                                CY_UNLOCK(info, flags);
+                                        readl(&ch_ctrl[channel].rs_control) &
+                                        ~C_RS_RTS);
+                                spin_unlock_irqrestore(&card->card_lock, flags);
                         }
                         if (set & TIOCM_DTR) {
-                                CY_LOCK(info, flags);
+                                spin_lock_irqsave(&card->card_lock, flags);
                                 cy_writel(&ch_ctrl[channel].rs_control,
-                                          cy_readl(&ch_ctrl[channel].
-                                                   rs_control) | C_RS_DTR);
+                                        readl(&ch_ctrl[channel].rs_control) |
+                                        C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-                                printk("cyc:set_modem_info raising Z DTR\n");
+                                printk(KERN_DEBUG "cyc:set_modem_info raising "
+                                        "Z DTR\n");
 #endif
-                                CY_UNLOCK(info, flags);
+                                spin_unlock_irqrestore(&card->card_lock, flags);
                         }
                         if (clear & TIOCM_DTR) {
-                                CY_LOCK(info, flags);
+                                spin_lock_irqsave(&card->card_lock, flags);
                                 cy_writel(&ch_ctrl[channel].rs_control,
-                                          cy_readl(&ch_ctrl[channel].
-                                                   rs_control) & ~C_RS_DTR);
+                                        readl(&ch_ctrl[channel].rs_control) &
+                                        ~C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-                                printk("cyc:set_modem_info clearing Z DTR\n");
+                                printk(KERN_DEBUG "cyc:set_modem_info clearing "
+                                        "Z DTR\n");
 #endif
-                                CY_UNLOCK(info, flags);
+                                spin_unlock_irqrestore(&card->card_lock, flags);
                         }
                 } else {
                         return -ENODEV;
                 }
-                CY_LOCK(info, flags);
-                retval = cyz_issue_cmd(&cy_card[info->card],
-                                        channel, C_CM_IOCTLM, 0L);
+                spin_lock_irqsave(&card->card_lock, flags);
+                retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
                 if (retval != 0) {
-                        printk("cyc:set_modem_info retval on ttyC%d was %x\n",
-                                info->line, retval);
+                        printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
+                                "was %x\n", info->line, retval);
                 }
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
         }
         return 0;
 }                               /* cy_tiocmset */
@@ -3820,14 +3749,17 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
  */
 static void cy_break(struct tty_struct *tty, int break_state)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
+        struct cyclades_card *card;
         unsigned long flags;
 
         if (serial_paranoia_check(info, tty->name, "cy_break"))
                 return;
 
-        CY_LOCK(info, flags);
-        if (!IS_CYC_Z(cy_card[info->card])) {
+        card = info->card;
+
+        spin_lock_irqsave(&card->card_lock, flags);
+        if (!IS_CYC_Z(*card)) {
                 /* Let the transmit ISR take care of this (since it
                    requires stuffing characters into the output stream).
                  */
@@ -3835,18 +3767,18 @@ static void cy_break(struct tty_struct *tty, int break_state)
                         if (!info->breakon) {
                                 info->breakon = 1;
                                 if (!info->xmit_cnt) {
-                                        CY_UNLOCK(info, flags);
+                                        spin_unlock_irqrestore(&card->card_lock, flags);
                                         start_xmit(info);
-                                        CY_LOCK(info, flags);
+                                        spin_lock_irqsave(&card->card_lock, flags);
                                 }
                         }
                 } else {
                         if (!info->breakoff) {
                                 info->breakoff = 1;
                                 if (!info->xmit_cnt) {
-                                        CY_UNLOCK(info, flags);
+                                        spin_unlock_irqrestore(&card->card_lock, flags);
                                         start_xmit(info);
-                                        CY_LOCK(info, flags);
+                                        spin_lock_irqsave(&card->card_lock, flags);
                                 }
                         }
                 }
@@ -3854,24 +3786,25 @@ static void cy_break(struct tty_struct *tty, int break_state)
                 int retval;
 
                 if (break_state == -1) {
-                        retval = cyz_issue_cmd(&cy_card[info->card],
-                                info->line - cy_card[info->card].first_line,
+                        retval = cyz_issue_cmd(card,
+                                info->line - card->first_line,
                                 C_CM_SET_BREAK, 0L);
                         if (retval != 0) {
-                                printk("cyc:cy_break (set) retval on ttyC%d "
-                                        "was %x\n", info->line, retval);
+                                printk(KERN_ERR "cyc:cy_break (set) retval on "
+                                        "ttyC%d was %x\n", info->line, retval);
                         }
                 } else {
-                        retval = cyz_issue_cmd(&cy_card[info->card],
-                                info->line - cy_card[info->card].first_line,
+                        retval = cyz_issue_cmd(card,
+                                info->line - card->first_line,
                                 C_CM_CLR_BREAK, 0L);
                         if (retval != 0) {
-                                printk("cyc:cy_break (clr) retval on ttyC%d "
-                                        "was %x\n", info->line, retval);
+                                printk(KERN_DEBUG "cyc:cy_break (clr) retval "
+                                        "on ttyC%d was %x\n", info->line,
+                                        retval);
                         }
                 }
         }
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&card->card_lock, flags);
 }                               /* cy_break */
 
 static int
@@ -3889,28 +3822,27 @@ get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
 
 static int set_threshold(struct cyclades_port *info, unsigned long value)
 {
+        struct cyclades_card *card;
         void __iomem *base_addr;
-        int card, channel, chip, index;
+        int channel, chip, index;
         unsigned long flags;
 
         card = info->card;
-        channel = info->line - cy_card[card].first_line;
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = info->line - card->first_line;
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
+                index = card->bus_index;
                 base_addr =
-                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+                    card->base_addr + (cy_chip_offset[chip] << index);
 
                 info->cor3 &= ~CyREC_FIFO;
                 info->cor3 |= value & CyREC_FIFO;
 
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
                 cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
                 cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR3ch, index);
-                CY_UNLOCK(info, flags);
-        } else {
-                /* Nothing to do! */
+                spin_unlock_irqrestore(&card->card_lock, flags);
         }
         return 0;
 }                               /* set_threshold */
@@ -3918,25 +3850,23 @@ static int set_threshold(struct cyclades_port *info, unsigned long value)
 static int
 get_threshold(struct cyclades_port *info, unsigned long __user * value)
 {
+        struct cyclades_card *card;
         void __iomem *base_addr;
-        int card, channel, chip, index;
+        int channel, chip, index;
         unsigned long tmp;
 
         card = info->card;
-        channel = info->line - cy_card[card].first_line;
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = info->line - card->first_line;
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr =
-                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
-                tmp = cy_readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
+                tmp = readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
                 return put_user(tmp, value);
-        } else {
-                /* Nothing to do! */
-                return 0;
         }
+        return 0;
 }                               /* get_threshold */
 
 static int
@@ -3954,49 +3884,45 @@ get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
 
 static int set_timeout(struct cyclades_port *info, unsigned long value)
 {
+        struct cyclades_card *card;
         void __iomem *base_addr;
-        int card, channel, chip, index;
+        int channel, chip, index;
         unsigned long flags;
 
         card = info->card;
-        channel = info->line - cy_card[card].first_line;
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = info->line - card->first_line;
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr =
-                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&card->card_lock, flags);
                 cy_writeb(base_addr + (CyRTPR << index), value & 0xff);
-                CY_UNLOCK(info, flags);
-        } else {
-                /* Nothing to do! */
+                spin_unlock_irqrestore(&card->card_lock, flags);
         }
         return 0;
 }                               /* set_timeout */
 
 static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
 {
+        struct cyclades_card *card;
         void __iomem *base_addr;
-        int card, channel, chip, index;
+        int channel, chip, index;
         unsigned long tmp;
 
         card = info->card;
-        channel = info->line - cy_card[card].first_line;
-        if (!IS_CYC_Z(cy_card[card])) {
+        channel = info->line - card->first_line;
+        if (!IS_CYC_Z(*card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                index = cy_card[card].bus_index;
-                base_addr =
-                    cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+                index = card->bus_index;
+                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
-                tmp = cy_readb(base_addr + (CyRTPR << index));
+                tmp = readb(base_addr + (CyRTPR << index));
                 return put_user(tmp, value);
-        } else {
-                /* Nothing to do! */
-                return 0;
         }
+        return 0;
 }                               /* get_timeout */
 
 static int set_default_timeout(struct cyclades_port *info, unsigned long value)
@@ -4020,7 +3946,7 @@ static int
 cy_ioctl(struct tty_struct *tty, struct file *file,
          unsigned int cmd, unsigned long arg)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
         struct cyclades_icount cprev, cnow;     /* kernel counter temps */
         struct serial_icounter_struct __user *p_cuser;  /* user space */
         int ret_val = 0;
@@ -4031,7 +3957,8 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
                 return -ENODEV;
 
 #ifdef CY_DEBUG_OTHER
-        printk("cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n", info->line, cmd, arg);      /* */
+        printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
+                info->line, cmd, arg);
 #endif
 
         switch (cmd) {
@@ -4076,14 +4003,6 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
         case CYGETRTSDTR_INV:
                 ret_val = info->rtsdtr_inv;
                 break;
-        case CYGETCARDINFO:
-                if (copy_to_user(argp, &cy_card[info->card],
-                                 sizeof(struct cyclades_card))) {
-                        ret_val = -EFAULT;
-                        break;
-                }
-                ret_val = 0;
-                break;
         case CYGETCD1400VER:
                 ret_val = info->chip_rev;
                 break;
@@ -4119,34 +4038,22 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
                  * Caller should use TIOCGICOUNT to see which one it was
                  */
         case TIOCMIWAIT:
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&info->card->card_lock, flags);
                 /* note the counters on entry */
-                cprev = info->icount;
-                CY_UNLOCK(info, flags);
-                while (1) {
-                        interruptible_sleep_on(&info->delta_msr_wait);
-                        /* see if a signal did it */
-                        if (signal_pending(current)) {
-                                return -ERESTARTSYS;
-                        }
-
-                        CY_LOCK(info, flags);
+                cnow = info->icount;
+                spin_unlock_irqrestore(&info->card->card_lock, flags);
+                ret_val = wait_event_interruptible(info->delta_msr_wait, ({
+                        cprev = cnow;
+                        spin_lock_irqsave(&info->card->card_lock, flags);
                         cnow = info->icount;    /* atomic copy */
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&info->card->card_lock, flags);
 
-                        if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
-                            cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
-                                return -EIO;    /* no change => error */
-                        }
-                        if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
-                            ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
-                            ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
-                            ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
-                                return 0;
-                        }
-                        cprev = cnow;
-                }
-                /* NOTREACHED */
+                        ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
+                        ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
+                        ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
+                        ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts));
+                }));
+                break;
 
                 /*
                  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
@@ -4155,9 +4062,9 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
                  *     RI where only 0->1 is counted.
                  */
         case TIOCGICOUNT:
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&info->card->card_lock, flags);
                 cnow = info->icount;
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&info->card->card_lock, flags);
                 p_cuser = argp;
                 ret_val = put_user(cnow.cts, &p_cuser->cts);
                 if (ret_val)
@@ -4199,7 +4106,7 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
         }
 
 #ifdef CY_DEBUG_OTHER
-        printk(" cyc:cy_ioctl done\n");
+        printk(KERN_DEBUG "cyc:cy_ioctl done\n");
 #endif
 
         return ret_val;
@@ -4213,10 +4120,10 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
  */
 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
 
 #ifdef CY_DEBUG_OTHER
-        printk("cyc:cy_set_termios ttyC%d\n", info->line);
+        printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
 #endif
 
         if (tty->termios->c_cflag == old_termios->c_cflag &&
@@ -4248,8 +4155,9 @@ static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 */
 static void cy_send_xchar(struct tty_struct *tty, char ch)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-        int card, channel;
+        struct cyclades_port *info = tty->driver_data;
+        struct cyclades_card *card;
+        int channel;
 
         if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
                 return;
@@ -4260,15 +4168,13 @@ static void cy_send_xchar(struct tty_struct *tty, char ch)
                 cy_start(tty);
 
         card = info->card;
-        channel = info->line - cy_card[card].first_line;
+        channel = info->line - card->first_line;
 
-        if (IS_CYC_Z(cy_card[card])) {
+        if (IS_CYC_Z(*card)) {
                 if (ch == STOP_CHAR(tty))
-                        cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXOFF,
-                                        0L);
+                        cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
                 else if (ch == START_CHAR(tty))
-                        cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXON,
-                                        0L);
+                        cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
         }
 }
 
@@ -4278,15 +4184,16 @@ static void cy_send_xchar(struct tty_struct *tty, char ch)
  */
 static void cy_throttle(struct tty_struct *tty)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
+        struct cyclades_card *card;
         unsigned long flags;
         void __iomem *base_addr;
-        int card, chip, channel, index;
+        int chip, channel, index;
 
 #ifdef CY_DEBUG_THROTTLE
         char buf[64];
 
-        printk("cyc:throttle %s: %d....ttyC%d\n", tty_name(tty, buf),
+        printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
                         tty->ldisc.chars_in_buffer(tty), info->line);
 #endif
 
@@ -4297,22 +4204,22 @@ static void cy_throttle(struct tty_struct *tty)
         card = info->card;
 
         if (I_IXOFF(tty)) {
-                if (!IS_CYC_Z(cy_card[card]))
+                if (!IS_CYC_Z(*card))
                         cy_send_xchar(tty, STOP_CHAR(tty));
                 else
                         info->throttle = 1;
         }
 
         if (tty->termios->c_cflag & CRTSCTS) {
-                channel = info->line - cy_card[card].first_line;
-                if (!IS_CYC_Z(cy_card[card])) {
+                channel = info->line - card->first_line;
+                if (!IS_CYC_Z(*card)) {
                         chip = channel >> 2;
                         channel &= 0x03;
-                        index = cy_card[card].bus_index;
-                        base_addr = cy_card[card].base_addr +
+                        index = card->bus_index;
+                        base_addr = card->base_addr +
                                 (cy_chip_offset[chip] << index);
 
-                        CY_LOCK(info, flags);
+                        spin_lock_irqsave(&card->card_lock, flags);
                         cy_writeb(base_addr + (CyCAR << index),
                                   (u_char) channel);
                         if (info->rtsdtr_inv) {
@@ -4322,7 +4229,7 @@ static void cy_throttle(struct tty_struct *tty)
                                 cy_writeb(base_addr + (CyMSVR1 << index),
                                           ~CyRTS);
                         }
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&card->card_lock, flags);
                 } else {
                         info->throttle = 1;
                 }
@@ -4336,16 +4243,17 @@ static void cy_throttle(struct tty_struct *tty)
  */
 static void cy_unthrottle(struct tty_struct *tty)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
+        struct cyclades_card *card;
         unsigned long flags;
         void __iomem *base_addr;
-        int card, chip, channel, index;
+        int chip, channel, index;
 
 #ifdef CY_DEBUG_THROTTLE
         char buf[64];
 
-        printk("cyc:unthrottle %s: %d....ttyC%d\n", tty_name(tty, buf),
-                tty->ldisc.chars_in_buffer(tty), info->line);
+        printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
+                tty_name(tty, buf), tty->ldisc.chars_in_buffer(tty),info->line);
 #endif
 
         if (serial_paranoia_check(info, tty->name, "cy_unthrottle")) {
@@ -4361,15 +4269,15 @@ static void cy_unthrottle(struct tty_struct *tty)
 
         if (tty->termios->c_cflag & CRTSCTS) {
                 card = info->card;
-                channel = info->line - cy_card[card].first_line;
-                if (!IS_CYC_Z(cy_card[card])) {
+                channel = info->line - card->first_line;
+                if (!IS_CYC_Z(*card)) {
                         chip = channel >> 2;
                         channel &= 0x03;
-                        index = cy_card[card].bus_index;
-                        base_addr = cy_card[card].base_addr +
+                        index = card->bus_index;
+                        base_addr = card->base_addr +
                                 (cy_chip_offset[chip] << index);
 
-                        CY_LOCK(info, flags);
+                        spin_lock_irqsave(&card->card_lock, flags);
                         cy_writeb(base_addr + (CyCAR << index),
                                   (u_char) channel);
                         if (info->rtsdtr_inv) {
@@ -4379,7 +4287,7 @@ static void cy_unthrottle(struct tty_struct *tty)
                                 cy_writeb(base_addr + (CyMSVR1 << index),
                                           CyRTS);
                         }
-                        CY_UNLOCK(info, flags);
+                        spin_unlock_irqrestore(&card->card_lock, flags);
                 } else {
                         info->throttle = 0;
                 }
@@ -4392,102 +4300,96 @@ static void cy_unthrottle(struct tty_struct *tty)
 static void cy_stop(struct tty_struct *tty)
 {
         struct cyclades_card *cinfo;
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
         void __iomem *base_addr;
         int chip, channel, index;
         unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
-        printk("cyc:cy_stop ttyC%d\n", info->line);     /* */
+        printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
 #endif
 
         if (serial_paranoia_check(info, tty->name, "cy_stop"))
                 return;
 
-        cinfo = &cy_card[info->card];
+        cinfo = info->card;
         channel = info->line - cinfo->first_line;
         if (!IS_CYC_Z(*cinfo)) {
                 index = cinfo->bus_index;
                 chip = channel >> 2;
                 channel &= 0x03;
-                base_addr = cy_card[info->card].base_addr +
-                        (cy_chip_offset[chip] << index);
+                base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
 
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&cinfo->card_lock, flags);
                 cy_writeb(base_addr + (CyCAR << index),
                         (u_char)(channel & 0x0003)); /* index channel */
                 cy_writeb(base_addr + (CySRER << index),
-                          cy_readb(base_addr + (CySRER << index)) & ~CyTxRdy);
-                CY_UNLOCK(info, flags);
-        } else {
-                /* Nothing to do! */
+                          readb(base_addr + (CySRER << index)) & ~CyTxRdy);
+                spin_unlock_irqrestore(&cinfo->card_lock, flags);
         }
 }                               /* cy_stop */
 
 static void cy_start(struct tty_struct *tty)
 {
         struct cyclades_card *cinfo;
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
         void __iomem *base_addr;
         int chip, channel, index;
         unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
-        printk("cyc:cy_start ttyC%d\n", info->line);    /* */
+        printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
 #endif
 
         if (serial_paranoia_check(info, tty->name, "cy_start"))
                 return;
 
-        cinfo = &cy_card[info->card];
+        cinfo = info->card;
         channel = info->line - cinfo->first_line;
         index = cinfo->bus_index;
         if (!IS_CYC_Z(*cinfo)) {
                 chip = channel >> 2;
                 channel &= 0x03;
-                base_addr = cy_card[info->card].base_addr +
-                        (cy_chip_offset[chip] << index);
+                base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
 
-                CY_LOCK(info, flags);
+                spin_lock_irqsave(&cinfo->card_lock, flags);
                 cy_writeb(base_addr + (CyCAR << index), (u_char) (channel & 0x0003));   /* index channel */
                 cy_writeb(base_addr + (CySRER << index),
-                          cy_readb(base_addr + (CySRER << index)) | CyTxRdy);
-                CY_UNLOCK(info, flags);
-        } else {
-                /* Nothing to do! */
+                          readb(base_addr + (CySRER << index)) | CyTxRdy);
+                spin_unlock_irqrestore(&cinfo->card_lock, flags);
         }
 }                               /* cy_start */
 
 static void cy_flush_buffer(struct tty_struct *tty)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-        int card, channel, retval;
+        struct cyclades_port *info = tty->driver_data;
+        struct cyclades_card *card;
+        int channel, retval;
         unsigned long flags;
 
 #ifdef CY_DEBUG_IO
-        printk("cyc:cy_flush_buffer ttyC%d\n", info->line);     /* */
+        printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
 #endif
 
         if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
                 return;
 
         card = info->card;
-        channel = (info->line) - (cy_card[card].first_line);
+        channel = info->line - card->first_line;
 
-        CY_LOCK(info, flags);
+        spin_lock_irqsave(&card->card_lock, flags);
         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-        CY_UNLOCK(info, flags);
+        spin_unlock_irqrestore(&card->card_lock, flags);
 
-        if (IS_CYC_Z(cy_card[card])) {  /* If it is a Z card, flush the on-board
+        if (IS_CYC_Z(*card)) {  /* If it is a Z card, flush the on-board
                                            buffers as well */
-                CY_LOCK(info, flags);
-                retval =
-                    cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_TX, 0L);
+                spin_lock_irqsave(&card->card_lock, flags);
+                retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
                 if (retval != 0) {
-                        printk("cyc: flush_buffer retval on ttyC%d was %x\n",
-                                info->line, retval);
+                        printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
+                                "was %x\n", info->line, retval);
                 }
-                CY_UNLOCK(info, flags);
+                spin_unlock_irqrestore(&card->card_lock, flags);
         }
         tty_wakeup(tty);
 }                               /* cy_flush_buffer */
@@ -4497,10 +4399,10 @@ static void cy_flush_buffer(struct tty_struct *tty)
  */
 static void cy_hangup(struct tty_struct *tty)
 {
-        struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+        struct cyclades_port *info = tty->driver_data;
 
 #ifdef CY_DEBUG_OTHER
-        printk("cyc:cy_hangup ttyC%d\n", info->line);   /* */
+        printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
 #endif
 
         if (serial_paranoia_check(info, tty->name, "cy_hangup"))
@@ -4511,7 +4413,8 @@ static void cy_hangup(struct tty_struct *tty)
         info->event = 0;
         info->count = 0;
 #ifdef CY_DEBUG_COUNT
-        printk("cyc:cy_hangup (%d): setting count to 0\n", current->pid);
+        printk(KERN_DEBUG "cyc:cy_hangup (%d): setting count to 0\n",
+                current->pid);
 #endif
         info->tty = NULL;
         info->flags &= ~ASYNC_NORMAL_ACTIVE;
@@ -4526,10 +4429,107 @@ static void cy_hangup(struct tty_struct *tty)
  * ---------------------------------------------------------------------
  */
 
+static int __devinit cy_init_card(struct cyclades_card *cinfo)
+{
+        struct cyclades_port *info;
+        u32 mailbox;
+        unsigned int nports;
+        unsigned short chip_number;
+        int index, port;
+
+        spin_lock_init(&cinfo->card_lock);
+
+        if (IS_CYC_Z(*cinfo)) { /* Cyclades-Z */
+                mailbox = readl(&((struct RUNTIME_9060 __iomem *)
+                                     cinfo->ctl_addr)->mail_box_0);
+                nports = (mailbox == ZE_V1) ? ZE_V1_NPORTS : 8;
+                cinfo->intr_enabled = 0;
+                cinfo->nports = 0;      /* Will be correctly set later, after
+                                           Z FW is loaded */
+        } else {
+                index = cinfo->bus_index;
+                nports = cinfo->nports = CyPORTS_PER_CHIP * cinfo->num_chips;
+        }
+
+        cinfo->ports = kzalloc(sizeof(*cinfo->ports) * nports, GFP_KERNEL);
+        if (cinfo->ports == NULL) {
+                printk(KERN_ERR "Cyclades: cannot allocate ports\n");
+                cinfo->nports = 0;
+                return -ENOMEM;
+        }
+
+        for (port = cinfo->first_line; port < cinfo->first_line + nports;
+                        port++) {
+                info = &cinfo->ports[port - cinfo->first_line];
+                info->magic = CYCLADES_MAGIC;
+                info->card = cinfo;
+                info->line = port;
+                info->flags = STD_COM_FLAGS;
+                info->closing_wait = CLOSING_WAIT_DELAY;
+                info->close_delay = 5 * HZ / 10;
+
+                INIT_WORK(&info->tqueue, do_softint);
+                init_waitqueue_head(&info->open_wait);
+                init_waitqueue_head(&info->close_wait);
+                init_completion(&info->shutdown_wait);
+                init_waitqueue_head(&info->delta_msr_wait);
+
+                if (IS_CYC_Z(*cinfo)) {
+                        info->type = PORT_STARTECH;
+                        if (mailbox == ZO_V1)
+                                info->xmit_fifo_size = CYZ_FIFO_SIZE;
+                        else
+                                info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
+#ifdef CONFIG_CYZ_INTR
+                        setup_timer(&cyz_rx_full_timer[port],
+                                cyz_rx_restart, (unsigned long)info);
+#endif
+                } else {
+                        info->type = PORT_CIRRUS;
+                        info->xmit_fifo_size = CyMAX_CHAR_FIFO;
+                        info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
+                        info->cor2 = CyETC;
+                        info->cor3 = 0x08;      /* _very_ small rcv threshold */
+
+                        chip_number = (port - cinfo->first_line) / 4;
+                        if ((info->chip_rev = readb(cinfo->base_addr +
+                                      (cy_chip_offset[chip_number] <<
+                                       index) + (CyGFRCR << index))) >=
+                            CD1400_REV_J) {
+                                /* It is a CD1400 rev. J or later */
+                                info->tbpr = baud_bpr_60[13];   /* Tx BPR */
+                                info->tco = baud_co_60[13];     /* Tx CO */
+                                info->rbpr = baud_bpr_60[13];   /* Rx BPR */
+                                info->rco = baud_co_60[13];     /* Rx CO */
+                                info->rtsdtr_inv = 1;
+                        } else {
+                                info->tbpr = baud_bpr_25[13];   /* Tx BPR */
+                                info->tco = baud_co_25[13];     /* Tx CO */
+                                info->rbpr = baud_bpr_25[13];   /* Rx BPR */
+                                info->rco = baud_co_25[13];     /* Rx CO */
+                                info->rtsdtr_inv = 0;
+                        }
+                        info->read_status_mask = CyTIMEOUT | CySPECHAR |
+                                CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
+                }
+
+        }
+
+#ifndef CONFIG_CYZ_INTR
+        if (IS_CYC_Z(*cinfo) && !timer_pending(&cyz_timerlist)) {
+                mod_timer(&cyz_timerlist, jiffies + 1);
+#ifdef CY_PCI_DEBUG
+                printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
+#endif
+        }
+#endif
+        return 0;
+}
+
 /* initialize chips on Cyclom-Y card -- return number of valid
    chips (which is number of ports/4) */
-static unsigned short __init
-cyy_init_card(void __iomem * true_base_addr, int index)
+static unsigned short __devinit cyy_init_card(void __iomem *true_base_addr,
+                int index)
 {
         unsigned int chip_number;
         void __iomem *base_addr;
@@ -4544,7 +4544,7 @@ cyy_init_card(void __iomem * true_base_addr, int index)
                 base_addr =
                     true_base_addr + (cy_chip_offset[chip_number] << index);
                 mdelay(1);
-                if (cy_readb(base_addr + (CyCCR << index)) != 0x00) {
+                if (readb(base_addr + (CyCCR << index)) != 0x00) {
                         /*************
                         printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
                         chip_number, (unsigned long)base_addr);
@@ -4561,7 +4561,7 @@ cyy_init_card(void __iomem * true_base_addr, int index)
                    chip 4 GFRCR register appears at chip 0, there is no chip 4
                    and this must be a Cyclom-16Y, not a Cyclom-32Ye.
                  */
-                if (chip_number == 4 && cy_readb(true_base_addr +
+                if (chip_number == 4 && readb(true_base_addr +
                                 (cy_chip_offset[0] << index) +
                                 (CyGFRCR << index)) == 0) {
                         return chip_number;
@@ -4570,7 +4570,7 @@ cyy_init_card(void __iomem * true_base_addr, int index)
                 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
                 mdelay(1);
 
-                if (cy_readb(base_addr + (CyGFRCR << index)) == 0x00) {
+                if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
                         /*
                            printk(" chip #%d at %#6lx is not responding ",
                            chip_number, (unsigned long)base_addr);
@@ -4578,7 +4578,7 @@ cyy_init_card(void __iomem * true_base_addr, int index)
                          */
                         return chip_number;
                 }
-                if ((0xf0 & (cy_readb(base_addr + (CyGFRCR << index)))) !=
+                if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
                                 0x40) {
                         /*
                         printk(" chip #%d at %#6lx is not valid (GFRCR == "
@@ -4589,7 +4589,7 @@ cyy_init_card(void __iomem * true_base_addr, int index)
                         return chip_number;
                 }
                 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
-                if (cy_readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
+                if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
                         /* It is a CD1400 rev. J or later */
                         /* Impossible to reach 5ms with this chip.
                            Changed to 2ms instead (f = 500 Hz). */
@@ -4602,7 +4602,7 @@ cyy_init_card(void __iomem * true_base_addr, int index)
                 /*
                    printk(" chip #%d at %#6lx is rev 0x%2x\n",
                    chip_number, (unsigned long)base_addr,
-                   cy_readb(base_addr+(CyGFRCR<<index)));
+                   readb(base_addr+(CyGFRCR<<index)));
                  */
         }
         return chip_number;
@@ -4647,9 +4647,15 @@ static int __init cy_detect_isa(void)
 
                 /* probe for CD1400... */
                 cy_isa_address = ioremap(isa_address, CyISA_Ywin);
+                if (cy_isa_address == NULL) {
+                        printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
+                                        "address\n");
+                        continue;
+                }
                 cy_isa_nchan = CyPORTS_PER_CHIP *
                         cyy_init_card(cy_isa_address, 0);
                 if (cy_isa_nchan == 0) {
+                        iounmap(cy_isa_address);
                         continue;
                 }
 #ifdef MODULE
@@ -4660,40 +4666,42 @@ static int __init cy_detect_isa(void)
                         /* find out the board's irq by probing */
                         cy_isa_irq = detect_isa_irq(cy_isa_address);
                 if (cy_isa_irq == 0) {
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
+                        printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
+                                "IRQ could not be detected.\n",
                                 (unsigned long)cy_isa_address);
-                        printk("but the IRQ could not be detected.\n");
+                        iounmap(cy_isa_address);
                         continue;
                 }
 
                 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
+                        printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
+                                "more channels are available. Change NR_PORTS "
+                                "in cyclades.c and recompile kernel.\n",
                                 (unsigned long)cy_isa_address);
-                        printk("but no more channels are available.\n");
-                        printk("Change NR_PORTS in cyclades.c and recompile "
-                                        "kernel.\n");
+                        iounmap(cy_isa_address);
                         return nboard;
                 }
                 /* fill the next cy_card structure available */
                 for (j = 0; j < NR_CARDS; j++) {
-                        if (cy_card[j].base_addr == 0)
+                        if (cy_card[j].base_addr == NULL)
                                 break;
                 }
                 if (j == NR_CARDS) {    /* no more cy_cards available */
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
+                        printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
+                                "more cards can be used. Change NR_CARDS in "
+                                "cyclades.c and recompile kernel.\n",
                                 (unsigned long)cy_isa_address);
-                        printk("but no more cards can be used .\n");
-                        printk("Change NR_CARDS in cyclades.c and recompile "
-                                        "kernel.\n");
+                        iounmap(cy_isa_address);
                         return nboard;
                 }
 
                 /* allocate IRQ */
                 if (request_irq(cy_isa_irq, cyy_interrupt,
                                 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
-                                (unsigned long)cy_isa_address);
-                        printk("but could not allocate IRQ#%d.\n", cy_isa_irq);
+                        printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
+                                "could not allocate IRQ#%d.\n",
+                                (unsigned long)cy_isa_address, cy_isa_irq);
+                        iounmap(cy_isa_address);
                         return nboard;
                 }
 
@@ -4704,15 +4712,23 @@ static int __init cy_detect_isa(void)
                 cy_card[j].bus_index = 0;
                 cy_card[j].first_line = cy_next_channel;
                 cy_card[j].num_chips = cy_isa_nchan / 4;
+                if (cy_init_card(&cy_card[j])) {
+                        cy_card[j].base_addr = NULL;
+                        free_irq(cy_isa_irq, &cy_card[j]);
+                        iounmap(cy_isa_address);
+                        continue;
+                }
                 nboard++;
 
-                /* print message */
-                printk("Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d, ",
+                printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
+                        "%d channels starting from port %d\n",
                         j + 1, (unsigned long)cy_isa_address,
                         (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
-                        cy_isa_irq);
-                printk("%d channels starting from port %d.\n",
-                        cy_isa_nchan, cy_next_channel);
+                        cy_isa_irq, cy_isa_nchan, cy_next_channel);
+
+                for (j = cy_next_channel;
+                                j < cy_next_channel + cy_isa_nchan; j++)
+                        tty_register_device(cy_serial_driver, j, NULL);
                 cy_next_channel += cy_isa_nchan;
         }
         return nboard;
@@ -4721,510 +4737,310 @@ static int __init cy_detect_isa(void)
 #endif                          /* CONFIG_ISA */
 }                               /* cy_detect_isa */
 
-static void plx_init(void __iomem * addr, uclong initctl)
+#ifdef CONFIG_PCI
+static void __devinit plx_init(void __iomem * addr, __u32 initctl)
 {
         /* Reset PLX */
-        cy_writel(addr + initctl, cy_readl(addr + initctl) | 0x40000000);
+        cy_writel(addr + initctl, readl(addr + initctl) | 0x40000000);
         udelay(100L);
-        cy_writel(addr + initctl, cy_readl(addr + initctl) & ~0x40000000);
+        cy_writel(addr + initctl, readl(addr + initctl) & ~0x40000000);
 
         /* Reload Config. Registers from EEPROM */
-        cy_writel(addr + initctl, cy_readl(addr + initctl) | 0x20000000);
+        cy_writel(addr + initctl, readl(addr + initctl) | 0x20000000);
         udelay(100L);
-        cy_writel(addr + initctl, cy_readl(addr + initctl) & ~0x20000000);
+        cy_writel(addr + initctl, readl(addr + initctl) & ~0x20000000);
 }
 
-/*
- * ---------------------------------------------------------------------
- * cy_detect_pci() - Test PCI bus presence and Cyclom-Ye/PCI.
- * sets global variables and return the number of PCI boards found.
- * ---------------------------------------------------------------------
- */
-static int __init cy_detect_pci(void)
+static int __devinit cy_pci_probe(struct pci_dev *pdev,
+                const struct pci_device_id *ent)
 {
-#ifdef CONFIG_PCI
-
-        struct pci_dev *pdev = NULL;
-        unsigned char cyy_rev_id;
-        unsigned char cy_pci_irq = 0;
-        uclong cy_pci_phys0, cy_pci_phys2;
-        void __iomem *cy_pci_addr0, *cy_pci_addr2;
-        unsigned short i, j, cy_pci_nchan, plx_ver;
-        unsigned short device_id, dev_index = 0;
-        uclong mailbox;
-        uclong ZeIndex = 0;
-        void __iomem *Ze_addr0[NR_CARDS], *Ze_addr2[NR_CARDS];
-        uclong Ze_phys0[NR_CARDS], Ze_phys2[NR_CARDS];
-        unsigned char Ze_irq[NR_CARDS];
-        struct pci_dev *Ze_pdev[NR_CARDS];
-
-        for (i = 0; i < NR_CARDS; i++) {
-                /* look for a Cyclades card by vendor and device id */
-                while ((device_id = cy_pci_dev_id[dev_index].device) != 0) {
-                        if ((pdev = pci_get_device(PCI_VENDOR_ID_CYCLADES,
-                                                   device_id, pdev)) == NULL) {
-                                dev_index++;    /* try next device id */
-                        } else {
-                                break;  /* found a board */
-                        }
-                }
-
-                if (device_id == 0)
-                        break;
-
-                if (pci_enable_device(pdev))
-                        continue;
-
-                /* read PCI configuration area */
-                cy_pci_irq = pdev->irq;
-                cy_pci_phys0 = pci_resource_start(pdev, 0);
-                cy_pci_phys2 = pci_resource_start(pdev, 2);
-                pci_read_config_byte(pdev, PCI_REVISION_ID, &cyy_rev_id);
+        void __iomem *addr0 = NULL, *addr2 = NULL;
+        char *card_name = NULL;
+        u32 mailbox;
+        unsigned int device_id, nchan = 0, card_no, i;
+        unsigned char plx_ver;
+        int retval, irq;
+
+        retval = pci_enable_device(pdev);
+        if (retval) {
+                dev_err(&pdev->dev, "cannot enable device\n");
+                goto err;
+        }
 
-                device_id &= ~PCI_DEVICE_ID_MASK;
+        /* read PCI configuration area */
+        irq = pdev->irq;
+        device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
 
-                if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
-                                device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
-#ifdef CY_PCI_DEBUG
-                        printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
-                                pdev->bus->number, pdev->devfn);
-                        printk("rev_id=%d) IRQ%d\n",
-                                cyy_rev_id, (int)cy_pci_irq);
-                        printk("Cyclom-Y/PCI:found  winaddr=0x%lx "
-                                "ctladdr=0x%lx\n",
-                                (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
+#if defined(__alpha__)
+        if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
+                dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
+                        "addresses on Alpha systems.\n");
+                retval = -EIO;
+                goto err_dis;
+        }
 #endif
+        if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
+                dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
+                        "addresses\n");
+                retval = -EIO;
+                goto err_dis;
+        }
 
-                        if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
-                                printk("  Warning: PCI I/O bit incorrectly "
-                                        "set. Ignoring it...\n");
-                                pdev->resource[2].flags &= ~IORESOURCE_IO;
-                        }
+        if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
+                dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
+                                "it...\n");
+                pdev->resource[2].flags &= ~IORESOURCE_IO;
+        }
 
-                        /* Although we don't use this I/O region, we should
-                           request it from the kernel anyway, to avoid problems
-                           with other drivers accessing it. */
-                        if (pci_request_regions(pdev, "Cyclom-Y") != 0) {
-                                printk(KERN_ERR "cyclades: failed to reserve "
-                                                "PCI resources\n");
-                                continue;
-                        }
-#if defined(__alpha__)
-                        if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
-                                printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
-                                        pdev->bus->number, pdev->devfn);
-                                printk("rev_id=%d) IRQ%d\n",
-                                        cyy_rev_id, (int)cy_pci_irq);
-                                printk("Cyclom-Y/PCI:found  winaddr=0x%lx "
-                                        "ctladdr=0x%lx\n",
-                                        (ulong)cy_pci_phys2,
-                                        (ulong)cy_pci_phys0);
-                                printk("Cyclom-Y/PCI not supported for low "
-                                        "addresses in Alpha systems.\n");
-                                i--;
-                                continue;
-                        }
-#endif
-                        cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Yctl);
-                        cy_pci_addr2 = ioremap(cy_pci_phys2, CyPCI_Ywin);
+        retval = pci_request_regions(pdev, "cyclades");
+        if (retval) {
+                dev_err(&pdev->dev, "failed to reserve resources\n");
+                goto err_dis;
+        }
 
-#ifdef CY_PCI_DEBUG
-                        printk("Cyclom-Y/PCI: relocate winaddr=0x%lx "
-                                "ctladdr=0x%lx\n",
-                                (u_long)cy_pci_addr2, (u_long)cy_pci_addr0);
-#endif
-                        cy_pci_nchan = (unsigned short)(CyPORTS_PER_CHIP *
-                                        cyy_init_card(cy_pci_addr2, 1));
-                        if (cy_pci_nchan == 0) {
-                                printk("Cyclom-Y PCI host card with ");
-                                printk("no Serial-Modules at 0x%lx.\n",
-                                        (ulong) cy_pci_phys2);
-                                i--;
-                                continue;
-                        }
-                        if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
-                                printk("Cyclom-Y/PCI found at 0x%lx ",
-                                        (ulong) cy_pci_phys2);
-                                printk("but no channels are available.\n");
-                                printk("Change NR_PORTS in cyclades.c and "
-                                                "recompile kernel.\n");
-                                return i;
-                        }
-                        /* fill the next cy_card structure available */
-                        for (j = 0; j < NR_CARDS; j++) {
-                                if (cy_card[j].base_addr == 0)
-                                        break;
-                        }
-                        if (j == NR_CARDS) {    /* no more cy_cards available */
-                                printk("Cyclom-Y/PCI found at 0x%lx ",
-                                        (ulong) cy_pci_phys2);
-                                printk("but no more cards can be used.\n");
-                                printk("Change NR_CARDS in cyclades.c and "
-                                                "recompile kernel.\n");
-                                return i;
-                        }
+        retval = -EIO;
+        if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
+                        device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
+                card_name = "Cyclom-Y";
 
-                        /* allocate IRQ */
-                        if (request_irq(cy_pci_irq, cyy_interrupt,
-                                        IRQF_SHARED, "Cyclom-Y", &cy_card[j])) {
-                                printk("Cyclom-Y/PCI found at 0x%lx ",
-                                        (ulong) cy_pci_phys2);
-                                printk("but could not allocate IRQ%d.\n",
-                                        cy_pci_irq);
-                                return i;
-                        }
+                addr0 = pci_iomap(pdev, 0, CyPCI_Yctl);
+                if (addr0 == NULL) {
+                        dev_err(&pdev->dev, "can't remap ctl region\n");
+                        goto err_reg;
+                }
+                addr2 = pci_iomap(pdev, 2, CyPCI_Ywin);
+                if (addr2 == NULL) {
+                        dev_err(&pdev->dev, "can't remap base region\n");
+                        goto err_unmap;
+                }
 
-                        /* set cy_card */
-                        cy_card[j].base_phys = (ulong) cy_pci_phys2;
-                        cy_card[j].ctl_phys = (ulong) cy_pci_phys0;
-                        cy_card[j].base_addr = cy_pci_addr2;
-                        cy_card[j].ctl_addr = cy_pci_addr0;
-                        cy_card[j].irq = (int)cy_pci_irq;
-                        cy_card[j].bus_index = 1;
-                        cy_card[j].first_line = cy_next_channel;
-                        cy_card[j].num_chips = cy_pci_nchan / 4;
-                        cy_card[j].pdev = pdev;
-
-                        /* enable interrupts in the PCI interface */
-                        plx_ver = cy_readb(cy_pci_addr2 + CyPLX_VER) & 0x0f;
-                        switch (plx_ver) {
-                        case PLX_9050:
-
-                                cy_writeb(cy_pci_addr0 + 0x4c, 0x43);
-                                break;
+                nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
+                if (nchan == 0) {
+                        dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
+                                        "Serial-Modules\n");
+                        return -EIO;
+                }
+        } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
+                struct RUNTIME_9060 __iomem *ctl_addr;
 
-                        case PLX_9060:
-                        case PLX_9080:
-                        default:        /* Old boards, use PLX_9060 */
-
-                                plx_init(cy_pci_addr0, 0x6c);
-                        /* For some yet unknown reason, once the PLX9060 reloads
-                           the EEPROM, the IRQ is lost and, thus, we have to
-                           re-write it to the PCI config. registers.
-                           This will remain here until we find a permanent
-                           fix. */
-                                pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
-                                                cy_pci_irq);
-
-                                cy_writew(cy_pci_addr0 + 0x68,
-                                          cy_readw(cy_pci_addr0 +
-                                                   0x68) | 0x0900);
-                                break;
-                        }
+                ctl_addr = addr0 = pci_iomap(pdev, 0, CyPCI_Zctl);
+                if (addr0 == NULL) {
+                        dev_err(&pdev->dev, "can't remap ctl region\n");
+                        goto err_reg;
+                }
 
-                        /* print message */
-                        printk("Cyclom-Y/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
-                                j + 1, (ulong)cy_pci_phys2,
-                                (ulong) (cy_pci_phys2 + CyPCI_Ywin - 1),
-                                (int)cy_pci_irq);
-                        printk("%d channels starting from port %d.\n",
-                                cy_pci_nchan, cy_next_channel);
-
-                        cy_next_channel += cy_pci_nchan;
-                } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
-                        /* print message */
-                        printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
-                                pdev->bus->number, pdev->devfn);
-                        printk("rev_id=%d) IRQ%d\n",
-                                cyy_rev_id, (int)cy_pci_irq);
-                        printk("Cyclades-Z/PCI: found winaddr=0x%lx "
-                                "ctladdr=0x%lx\n",
-                                (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
-                        printk("Cyclades-Z/PCI not supported for low "
-                                "addresses\n");
-                        break;
-                } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
-#ifdef CY_PCI_DEBUG
-                        printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
-                                pdev->bus->number, pdev->devfn);
-                        printk("rev_id=%d) IRQ%d\n",
-                                cyy_rev_id, (int)cy_pci_irq);
-                        printk("Cyclades-Z/PCI: found winaddr=0x%lx "
-                                "ctladdr=0x%lx\n",
-                                (ulong) cy_pci_phys2, (ulong) cy_pci_phys0);
-#endif
-                        cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Zctl);
-
-                        /* Disable interrupts on the PLX before resetting it */
-                        cy_writew(cy_pci_addr0 + 0x68,
-                                cy_readw(cy_pci_addr0 + 0x68) & ~0x0900);
-
-                        plx_init(cy_pci_addr0, 0x6c);
-                        /* For some yet unknown reason, once the PLX9060 reloads
-                           the EEPROM, the IRQ is lost and, thus, we have to
-                           re-write it to the PCI config. registers.
-                           This will remain here until we find a permanent
-                           fix. */
-                        pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
-                                                cy_pci_irq);
-
-                        mailbox =
-                            (uclong)cy_readl(&((struct RUNTIME_9060 __iomem *)
-                                                cy_pci_addr0)->mail_box_0);
-
-                        if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
-                                printk("  Warning: PCI I/O bit incorrectly "
-                                        "set. Ignoring it...\n");
-                                pdev->resource[2].flags &= ~IORESOURCE_IO;
-                        }
+                /* Disable interrupts on the PLX before resetting it */
+                cy_writew(addr0 + 0x68,
+                        readw(addr0 + 0x68) & ~0x0900);
+
+                plx_init(addr0, 0x6c);
+                /* For some yet unknown reason, once the PLX9060 reloads
+                   the EEPROM, the IRQ is lost and, thus, we have to
+                   re-write it to the PCI config. registers.
+                   This will remain here until we find a permanent
+                   fix. */
+                pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
+
+                mailbox = (u32)readl(&ctl_addr->mail_box_0);
+
+                addr2 = pci_iomap(pdev, 2, mailbox == ZE_V1 ?
+                                CyPCI_Ze_win : CyPCI_Zwin);
+                if (addr2 == NULL) {
+                        dev_err(&pdev->dev, "can't remap base region\n");
+                        goto err_unmap;
+                }
 
-                        /* Although we don't use this I/O region, we should
-                           request it from the kernel anyway, to avoid problems
-                           with other drivers accessing it. */
-                        if (pci_request_regions(pdev, "Cyclades-Z") != 0) {
-                                printk(KERN_ERR "cyclades: failed to reserve "
-                                        "PCI resources\n");
-                                continue;
-                        }
+                if (mailbox == ZE_V1) {
+                        card_name = "Cyclades-Ze";
 
-                        if (mailbox == ZE_V1) {
-                                cy_pci_addr2 = ioremap(cy_pci_phys2,
-                                                CyPCI_Ze_win);
-                                if (ZeIndex == NR_CARDS) {
-                                        printk("Cyclades-Ze/PCI found at "
-                                                "0x%lx but no more cards can "
-                                                "be used.\nChange NR_CARDS in "
-                                                "cyclades.c and recompile "
-                                                "kernel.\n",
-                                                (ulong)cy_pci_phys2);
-                                } else {
-                                        Ze_phys0[ZeIndex] = cy_pci_phys0;
-                                        Ze_phys2[ZeIndex] = cy_pci_phys2;
-                                        Ze_addr0[ZeIndex] = cy_pci_addr0;
-                                        Ze_addr2[ZeIndex] = cy_pci_addr2;
-                                        Ze_irq[ZeIndex] = cy_pci_irq;
-                                        Ze_pdev[ZeIndex] = pdev;
-                                        ZeIndex++;
-                                }
-                                i--;
-                                continue;
-                        } else {
-                                cy_pci_addr2 = ioremap(cy_pci_phys2,CyPCI_Zwin);
-                        }
+                        readl(&ctl_addr->mail_box_0);
+                        nchan = ZE_V1_NPORTS;
+                } else {
+                        card_name = "Cyclades-8Zo";
 
 #ifdef CY_PCI_DEBUG
-                        printk("Cyclades-Z/PCI: relocate winaddr=0x%lx "
-                                "ctladdr=0x%lx\n",
-                                (ulong) cy_pci_addr2, (ulong) cy_pci_addr0);
                         if (mailbox == ZO_V1) {
-                                cy_writel(&((struct RUNTIME_9060 *)
-                                        (cy_pci_addr0))->loc_addr_base,
-                                        WIN_CREG);
-                                PAUSE;
-                                printk("Cyclades-8Zo/PCI: FPGA id %lx, ver "
-                                        "%lx\n", (ulong) (0xff &
-                                        cy_readl(&((struct CUSTOM_REG *)
-                                                (cy_pci_addr2))->fpga_id)),
-                                        (ulong)(0xff &
-                                        cy_readl(&((struct CUSTOM_REG *)
-                                                (cy_pci_addr2))->
-                                                        fpga_version)));
-                                cy_writel(&((struct RUNTIME_9060 *)
-                                        (cy_pci_addr0))->loc_addr_base,
-                                        WIN_RAM);
+                                cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
+                                dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
+                                        "id %lx, ver %lx\n", (ulong)(0xff &
+                                        readl(&((struct CUSTOM_REG *)addr2)->
+                                                fpga_id)), (ulong)(0xff &
+                                        readl(&((struct CUSTOM_REG *)addr2)->
+                                                fpga_version)));
+                                cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
                         } else {
-                                printk("Cyclades-Z/PCI: New Cyclades-Z board.  "
-                                                "FPGA not loaded\n");
+                                dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
+                                        "Cyclades-Z board.  FPGA not loaded\n");
                         }
 #endif
                         /* The following clears the firmware id word.  This
                            ensures that the driver will not attempt to talk to
                            the board until it has been properly initialized.
                          */
-                        PAUSE;
                         if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
-                                cy_writel(cy_pci_addr2 + ID_ADDRESS, 0L);
+                                cy_writel(addr2 + ID_ADDRESS, 0L);
 
                         /* This must be a Cyclades-8Zo/PCI.  The extendable
                            version will have a different device_id and will
                            be allocated its maximum number of ports. */
-                        cy_pci_nchan = 8;
-
-                        if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
-                                printk("Cyclades-8Zo/PCI found at 0x%lx but"
-                                        "no channels are available.\nChange "
-                                        "NR_PORTS in cyclades.c and recompile "
-                                        "kernel.\n", (ulong)cy_pci_phys2);
-                                return i;
-                        }
-
-                        /* fill the next cy_card structure available */
-                        for (j = 0; j < NR_CARDS; j++) {
-                                if (cy_card[j].base_addr == 0)
-                                        break;
-                        }
-                        if (j == NR_CARDS) {    /* no more cy_cards available */
-                                printk("Cyclades-8Zo/PCI found at 0x%lx but"
-                                        "no more cards can be used.\nChange "
-                                        "NR_CARDS in cyclades.c and recompile "
-                                        "kernel.\n", (ulong)cy_pci_phys2);
-                                return i;
-                        }
-#ifdef CONFIG_CYZ_INTR
-                        /* allocate IRQ only if board has an IRQ */
-                        if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
-                                if (request_irq(cy_pci_irq, cyz_interrupt,
-                                                IRQF_SHARED, "Cyclades-Z",
-                                                &cy_card[j])) {
-                                        printk("Cyclom-8Zo/PCI found at 0x%lx "
-                                                "but could not allocate "
-                                                "IRQ%d.\n", (ulong)cy_pci_phys2,
-                                                cy_pci_irq);
-                                        return i;
-                                }
-                        }
-#endif                          /* CONFIG_CYZ_INTR */
-
-                        /* set cy_card */
-                        cy_card[j].base_phys = cy_pci_phys2;
-                        cy_card[j].ctl_phys = cy_pci_phys0;
-                        cy_card[j].base_addr = cy_pci_addr2;
-                        cy_card[j].ctl_addr = cy_pci_addr0;
-                        cy_card[j].irq = (int)cy_pci_irq;
-                        cy_card[j].bus_index = 1;
-                        cy_card[j].first_line = cy_next_channel;
-                        cy_card[j].num_chips = -1;
-                        cy_card[j].pdev = pdev;
-
-                        /* print message */
-#ifdef CONFIG_CYZ_INTR
-                        /* don't report IRQ if board is no IRQ */
-                        if ((cy_pci_irq != 0) && (cy_pci_irq != 255))
-                                printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, "
-                                        "IRQ%d, ", j + 1, (ulong)cy_pci_phys2,
-                                        (ulong) (cy_pci_phys2 + CyPCI_Zwin - 1),
-                                        (int)cy_pci_irq);
-                        else
-#endif                          /* CONFIG_CYZ_INTR */
-                                printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, ",
-                                        j + 1, (ulong)cy_pci_phys2,
-                                        (ulong)(cy_pci_phys2 + CyPCI_Zwin - 1));
-
-                        printk("%d channels starting from port %d.\n",
-                                        cy_pci_nchan, cy_next_channel);
-                        cy_next_channel += cy_pci_nchan;
+                        nchan = 8;
                 }
         }
 
-        for (; ZeIndex != 0 && i < NR_CARDS; i++) {
-                cy_pci_phys0 = Ze_phys0[0];
-                cy_pci_phys2 = Ze_phys2[0];
-                cy_pci_addr0 = Ze_addr0[0];
-                cy_pci_addr2 = Ze_addr2[0];
-                cy_pci_irq = Ze_irq[0];
-                pdev = Ze_pdev[0];
-                for (j = 0; j < ZeIndex - 1; j++) {
-                        Ze_phys0[j] = Ze_phys0[j + 1];
-                        Ze_phys2[j] = Ze_phys2[j + 1];
-                        Ze_addr0[j] = Ze_addr0[j + 1];
-                        Ze_addr2[j] = Ze_addr2[j + 1];
-                        Ze_irq[j] = Ze_irq[j + 1];
-                        Ze_pdev[j] = Ze_pdev[j + 1];
-                }
-                ZeIndex--;
-                mailbox = (uclong)cy_readl(&((struct RUNTIME_9060 __iomem *)
-                                                cy_pci_addr0)->mail_box_0);
-#ifdef CY_PCI_DEBUG
-                printk("Cyclades-Z/PCI: relocate winaddr=0x%lx ctladdr=0x%lx\n",
-                        (ulong)cy_pci_addr2, (ulong)cy_pci_addr0);
-                printk("Cyclades-Z/PCI: New Cyclades-Z board.  FPGA not "
-                                "loaded\n");
-#endif
-                PAUSE;
-                /* This must be the new Cyclades-Ze/PCI. */
-                cy_pci_nchan = ZE_V1_NPORTS;
-
-                if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
-                        printk("Cyclades-Ze/PCI found at 0x%lx but no channels "
-                                "are available.\nChange NR_PORTS in cyclades.c "
-                                "and recompile kernel.\n",
-                                (ulong) cy_pci_phys2);
-                        return i;
-                }
+        if ((cy_next_channel + nchan) > NR_PORTS) {
+                dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
+                        "channels are available. Change NR_PORTS in "
+                        "cyclades.c and recompile kernel.\n");
+                goto err_unmap;
+        }
+        /* fill the next cy_card structure available */
+        for (card_no = 0; card_no < NR_CARDS; card_no++) {
+                if (cy_card[card_no].base_addr == NULL)
+                        break;
+        }
+        if (card_no == NR_CARDS) {      /* no more cy_cards available */
+                dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
+                        "more cards can be used. Change NR_CARDS in "
+                        "cyclades.c and recompile kernel.\n");
+                goto err_unmap;
+        }
 
-                /* fill the next cy_card structure available */
-                for (j = 0; j < NR_CARDS; j++) {
-                        if (cy_card[j].base_addr == 0)
-                                break;
-                }
-                if (j == NR_CARDS) {    /* no more cy_cards available */
-                        printk("Cyclades-Ze/PCI found at 0x%lx but no more "
-                                "cards can be used.\nChange NR_CARDS in "
-                                "cyclades.c and recompile kernel.\n",
-                                (ulong) cy_pci_phys2);
-                        return i;
+        if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
+                        device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
+                /* allocate IRQ */
+                retval = request_irq(irq, cyy_interrupt,
+                                IRQF_SHARED, "Cyclom-Y", &cy_card[card_no]);
+                if (retval) {
+                        dev_err(&pdev->dev, "could not allocate IRQ\n");
+                        goto err_unmap;
                 }
+                cy_card[card_no].num_chips = nchan / 4;
+        } else {
 #ifdef CONFIG_CYZ_INTR
                 /* allocate IRQ only if board has an IRQ */
-                if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
-                        if (request_irq(cy_pci_irq, cyz_interrupt,
+                if (irq != 0 && irq != 255) {
+                        retval = request_irq(irq, cyz_interrupt,
                                         IRQF_SHARED, "Cyclades-Z",
-                                        &cy_card[j])) {
-                                printk("Cyclom-Ze/PCI found at 0x%lx ",
-                                        (ulong) cy_pci_phys2);
-                                printk("but could not allocate IRQ%d.\n",
-                                        cy_pci_irq);
-                                return i;
+                                        &cy_card[card_no]);
+                        if (retval) {
+                                dev_err(&pdev->dev, "could not allocate IRQ\n");
+                                goto err_unmap;
                         }
                 }
 #endif                          /* CONFIG_CYZ_INTR */
+                cy_card[card_no].num_chips = -1;
+        }
 
-                /* set cy_card */
-                cy_card[j].base_phys = cy_pci_phys2;
-                cy_card[j].ctl_phys = cy_pci_phys0;
-                cy_card[j].base_addr = cy_pci_addr2;
-                cy_card[j].ctl_addr = cy_pci_addr0;
-                cy_card[j].irq = (int)cy_pci_irq;
-                cy_card[j].bus_index = 1;
-                cy_card[j].first_line = cy_next_channel;
-                cy_card[j].num_chips = -1;
-                cy_card[j].pdev = pdev;
+        /* set cy_card */
+        cy_card[card_no].base_addr = addr2;
+        cy_card[card_no].ctl_addr = addr0;
+        cy_card[card_no].irq = irq;
+        cy_card[card_no].bus_index = 1;
+        cy_card[card_no].first_line = cy_next_channel;
+        retval = cy_init_card(&cy_card[card_no]);
+        if (retval)
+                goto err_null;
 
-                /* print message */
-#ifdef CONFIG_CYZ_INTR
-                /* don't report IRQ if board is no IRQ */
-                if ((cy_pci_irq != 0) && (cy_pci_irq != 255))
-                        printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
-                                j + 1, (ulong) cy_pci_phys2,
-                                (ulong) (cy_pci_phys2 + CyPCI_Ze_win - 1),
-                                (int)cy_pci_irq);
-                else
-#endif                          /* CONFIG_CYZ_INTR */
-                        printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, ",
-                                j + 1, (ulong) cy_pci_phys2,
-                                (ulong) (cy_pci_phys2 + CyPCI_Ze_win - 1));
+        pci_set_drvdata(pdev, &cy_card[card_no]);
 
-                printk("%d channels starting from port %d.\n",
-                        cy_pci_nchan, cy_next_channel);
-                cy_next_channel += cy_pci_nchan;
-        }
-        if (ZeIndex != 0) {
-                printk("Cyclades-Ze/PCI found at 0x%x but no more cards can be "
-                        "used.\nChange NR_CARDS in cyclades.c and recompile "
-                        "kernel.\n", (unsigned int)Ze_phys2[0]);
+        if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
+                        device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
+                /* enable interrupts in the PCI interface */
+                plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
+                switch (plx_ver) {
+                case PLX_9050:
+
+                        cy_writeb(addr0 + 0x4c, 0x43);
+                        break;
+
+                case PLX_9060:
+                case PLX_9080:
+                default:        /* Old boards, use PLX_9060 */
+
+                        plx_init(addr0, 0x6c);
+                /* For some yet unknown reason, once the PLX9060 reloads
+                   the EEPROM, the IRQ is lost and, thus, we have to
+                   re-write it to the PCI config. registers.
+                   This will remain here until we find a permanent
+                   fix. */
+                        pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
+
+                        cy_writew(addr0 + 0x68, readw(addr0 + 0x68) | 0x0900);
+                        break;
+                }
         }
-        return i;
-#else
+
+        dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
+                "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
+        for (i = cy_next_channel; i < cy_next_channel + nchan; i++)
+                tty_register_device(cy_serial_driver, i, &pdev->dev);
+        cy_next_channel += nchan;
+
         return 0;
-#endif                          /* ifdef CONFIG_PCI */
-}                               /* cy_detect_pci */
+err_null:
+        cy_card[card_no].base_addr = NULL;
+        free_irq(irq, &cy_card[card_no]);
+err_unmap:
+        pci_iounmap(pdev, addr0);
+        if (addr2)
+                pci_iounmap(pdev, addr2);
+err_reg:
+        pci_release_regions(pdev);
+err_dis:
+        pci_disable_device(pdev);
+err:
+        return retval;
+}
 
-/*
- * This routine prints out the appropriate serial driver version number
- * and identifies which options were configured into this driver.
- */
-static inline void show_version(void)
+static void __devexit cy_pci_remove(struct pci_dev *pdev)
 {
-        printk("Cyclades driver " CY_VERSION "\n");
-        printk("        built %s %s\n", __DATE__, __TIME__);
-}                               /* show_version */
+        struct cyclades_card *cinfo = pci_get_drvdata(pdev);
+        unsigned int i;
+
+        /* non-Z with old PLX */
+        if (!IS_CYC_Z(*cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
+                        PLX_9050)
+                cy_writeb(cinfo->ctl_addr + 0x4c, 0);
+        else
+#ifndef CONFIG_CYZ_INTR
+                if (!IS_CYC_Z(*cinfo))
+#endif
+                cy_writew(cinfo->ctl_addr + 0x68,
+                                readw(cinfo->ctl_addr + 0x68) & ~0x0900);
+
+        pci_iounmap(pdev, cinfo->base_addr);
+        if (cinfo->ctl_addr)
+                pci_iounmap(pdev, cinfo->ctl_addr);
+        if (cinfo->irq
+#ifndef CONFIG_CYZ_INTR
+                && !IS_CYC_Z(*cinfo)
+#endif /* CONFIG_CYZ_INTR */
+                )
+                free_irq(cinfo->irq, cinfo);
+        pci_release_regions(pdev);
+
+        cinfo->base_addr = NULL;
+        for (i = cinfo->first_line; i < cinfo->first_line +
+                        cinfo->nports; i++)
+                tty_unregister_device(cy_serial_driver, i);
+        cinfo->nports = 0;
+        kfree(cinfo->ports);
+}
+
+static struct pci_driver cy_pci_driver = {
+        .name = "cyclades",
+        .id_table = cy_pci_dev_id,
+        .probe = cy_pci_probe,
+        .remove = __devexit_p(cy_pci_remove)
+};
+#endif
 
 static int
 cyclades_get_proc_info(char *buf, char **start, off_t offset, int length,
                 int *eof, void *data)
 {
         struct cyclades_port *info;
-        int i;
+        unsigned int i, j;
         int len = 0;
         off_t begin = 0;
         off_t pos = 0;
@@ -5238,33 +5054,34 @@ cyclades_get_proc_info(char *buf, char **start, off_t offset, int length,
         len += size;
 
         /* Output one line for each known port */
-        for (i = 0; i < NR_PORTS && cy_port[i].line >= 0; i++) {
-                info = &cy_port[i];
-
-                if (info->count)
-                        size = sprintf(buf + len, "%3d %8lu %10lu %8lu %10lu "
-                                "%8lu %9lu %6ld\n", info->line,
-                                (cur_jifs - info->idle_stats.in_use) / HZ,
-                                info->idle_stats.xmit_bytes,
-                                (cur_jifs - info->idle_stats.xmit_idle) / HZ,
-                                info->idle_stats.recv_bytes,
-                                (cur_jifs - info->idle_stats.recv_idle) / HZ,
-                                info->idle_stats.overruns,
-                                (long)info->tty->ldisc.num);
-                else
-                        size = sprintf(buf + len, "%3d %8lu %10lu %8lu %10lu "
-                                "%8lu %9lu %6ld\n",
-                                info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
-                len += size;
-                pos = begin + len;
-
-                if (pos < offset) {
-                        len = 0;
-                        begin = pos;
+        for (i = 0; i < NR_CARDS; i++)
+                for (j = 0; j < cy_card[i].nports; j++) {
+                        info = &cy_card[i].ports[j];
+
+                        if (info->count)
+                                size = sprintf(buf + len, "%3d %8lu %10lu %8lu "
+                                        "%10lu %8lu %9lu %6ld\n", info->line,
+                                        (cur_jifs - info->idle_stats.in_use) /
+                                        HZ, info->idle_stats.xmit_bytes,
+                                        (cur_jifs - info->idle_stats.xmit_idle)/
+                                        HZ, info->idle_stats.recv_bytes,
+                                        (cur_jifs - info->idle_stats.recv_idle)/
+                                        HZ, info->idle_stats.overruns,
+                                        (long)info->tty->ldisc.num);
+                        else
+                                size = sprintf(buf + len, "%3d %8lu %10lu %8lu "
+                                        "%10lu %8lu %9lu %6ld\n",
+                                        info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
+                        len += size;
+                        pos = begin + len;
+
+                        if (pos < offset) {
+                                len = 0;
+                                begin = pos;
+                        }
+                        if (pos > offset + length)
+                                goto done;
                 }
-                if (pos > offset + length)
-                        goto done;
-        }
         *eof = 1;
 done:
         *start = buf + (offset - begin);        /* Start of wanted data */
@@ -5319,18 +5136,15 @@ static const struct tty_operations cy_ops = {
 
 static int __init cy_init(void)
 {
-        struct cyclades_port *info;
-        struct cyclades_card *cinfo;
-        int number_z_boards = 0;
-        int board, port, i, index;
-        unsigned long mailbox;
-        unsigned short chip_number;
-        int nports;
+        unsigned int nboards;
+        int retval = -ENOMEM;
 
         cy_serial_driver = alloc_tty_driver(NR_PORTS);
         if (!cy_serial_driver)
-                return -ENOMEM;
-        show_version();
+                goto err;
+
+        printk(KERN_INFO "Cyclades driver " CY_VERSION " (built %s %s)\n",
+                        __DATE__, __TIME__);
 
         /* Initialize the tty_driver structure */
 
@@ -5344,15 +5158,13 @@ static int __init cy_init(void)
         cy_serial_driver->init_termios = tty_std_termios;
         cy_serial_driver->init_termios.c_cflag =
             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
-        cy_serial_driver->flags = TTY_DRIVER_REAL_RAW;
+        cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
         tty_set_operations(cy_serial_driver, &cy_ops);
 
-        if (tty_register_driver(cy_serial_driver))
-                panic("Couldn't register Cyclades serial driver\n");
-
-        for (i = 0; i < NR_CARDS; i++) {
-                /* base_addr=0 indicates board not found */
-                cy_card[i].base_addr = NULL;
+        retval = tty_register_driver(cy_serial_driver);
+        if (retval) {
+                printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
+                goto err_frtty;
         }
 
         /* the code below is responsible to find the boards. Each different
@@ -5363,223 +5175,68 @@ static int __init cy_init(void)
            the cy_next_channel. */
 
         /* look for isa boards */
-        cy_isa_nboard = cy_detect_isa();
+        nboards = cy_detect_isa();
 
+#ifdef CONFIG_PCI
         /* look for pci boards */
-        cy_pci_nboard = cy_detect_pci();
-
-        cy_nboard = cy_isa_nboard + cy_pci_nboard;
-
-        /* invalidate remaining cy_card structures */
-        for (i = 0; i < NR_CARDS; i++) {
-                if (cy_card[i].base_addr == 0) {
-                        cy_card[i].first_line = -1;
-                        cy_card[i].ctl_addr = NULL;
-                        cy_card[i].irq = 0;
-                        cy_card[i].bus_index = 0;
-                        cy_card[i].first_line = 0;
-                        cy_card[i].num_chips = 0;
-                }
-        }
-        /* invalidate remaining cy_port structures */
-        for (i = cy_next_channel; i < NR_PORTS; i++) {
-                cy_port[i].line = -1;
-                cy_port[i].magic = -1;
-        }
-
-        /* initialize per-port data structures for each valid board found */
-        for (board = 0; board < cy_nboard; board++) {
-                cinfo = &cy_card[board];
-                if (cinfo->num_chips == -1) {   /* Cyclades-Z */
-                        number_z_boards++;
-                        mailbox = cy_readl(&((struct RUNTIME_9060 __iomem *)
-                                             cy_card[board].ctl_addr)->
-                                           mail_box_0);
-                        nports = (mailbox == ZE_V1) ? ZE_V1_NPORTS : 8;
-                        cinfo->intr_enabled = 0;
-                        cinfo->nports = 0;      /* Will be correctly set later, after 
-                                                   Z FW is loaded */
-                        spin_lock_init(&cinfo->card_lock);
-                        for (port = cinfo->first_line;
-                             port < cinfo->first_line + nports; port++) {
-                                info = &cy_port[port];
-                                info->magic = CYCLADES_MAGIC;
-                                info->type = PORT_STARTECH;
-                                info->card = board;
-                                info->line = port;
-                                info->chip_rev = 0;
-                                info->flags = STD_COM_FLAGS;
-                                info->tty = NULL;
-                                if (mailbox == ZO_V1)
-                                        info->xmit_fifo_size = CYZ_FIFO_SIZE;
-                                else
-                                        info->xmit_fifo_size =
-                                            4 * CYZ_FIFO_SIZE;
-                                info->cor1 = 0;
-                                info->cor2 = 0;
-                                info->cor3 = 0;
-                                info->cor4 = 0;
-                                info->cor5 = 0;
-                                info->tbpr = 0;
-                                info->tco = 0;
-                                info->rbpr = 0;
-                                info->rco = 0;
-                                info->custom_divisor = 0;
-                                info->close_delay = 5 * HZ / 10;
-                                info->closing_wait = CLOSING_WAIT_DELAY;
-                                info->icount.cts = info->icount.dsr =
-                                    info->icount.rng = info->icount.dcd = 0;
-                                info->icount.rx = info->icount.tx = 0;
-                                info->icount.frame = info->icount.parity = 0;
-                                info->icount.overrun = info->icount.brk = 0;
-                                info->x_char = 0;
-                                info->event = 0;
-                                info->count = 0;
-                                info->blocked_open = 0;
-                                info->default_threshold = 0;
-                                info->default_timeout = 0;
-                                INIT_WORK(&info->tqueue, do_softint);
-                                init_waitqueue_head(&info->open_wait);
-                                init_waitqueue_head(&info->close_wait);
-                                init_waitqueue_head(&info->shutdown_wait);
-                                init_waitqueue_head(&info->delta_msr_wait);
-                                /* info->session */
-                                /* info->pgrp */
-                                info->read_status_mask = 0;
-                                /* info->timeout */
-                                /* Bentson's vars */
-                                info->jiffies[0] = 0;
-                                info->jiffies[1] = 0;
-                                info->jiffies[2] = 0;
-                                info->rflush_count = 0;
-#ifdef CONFIG_CYZ_INTR
-                                init_timer(&cyz_rx_full_timer[port]);
-                                cyz_rx_full_timer[port].function = NULL;
+        retval = pci_register_driver(&cy_pci_driver);
+        if (retval && !nboards)
+                goto err_unr;
 #endif
-                        }
-                        continue;
-                } else {        /* Cyclom-Y of some kind */
-                        index = cinfo->bus_index;
-                        spin_lock_init(&cinfo->card_lock);
-                        cinfo->nports = CyPORTS_PER_CHIP * cinfo->num_chips;
-                        for (port = cinfo->first_line;
-                             port < cinfo->first_line + cinfo->nports; port++) {
-                                info = &cy_port[port];
-                                info->magic = CYCLADES_MAGIC;
-                                info->type = PORT_CIRRUS;
-                                info->card = board;
-                                info->line = port;
-                                info->flags = STD_COM_FLAGS;
-                                info->tty = NULL;
-                                info->xmit_fifo_size = CyMAX_CHAR_FIFO;
-                                info->cor1 =
-                                    CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
-                                info->cor2 = CyETC;
-                                info->cor3 = 0x08;      /* _very_ small rcv threshold */
-                                info->cor4 = 0;
-                                info->cor5 = 0;
-                                info->custom_divisor = 0;
-                                info->close_delay = 5 * HZ / 10;
-                                info->closing_wait = CLOSING_WAIT_DELAY;
-                                info->icount.cts = info->icount.dsr =
-                                    info->icount.rng = info->icount.dcd = 0;
-                                info->icount.rx = info->icount.tx = 0;
-                                info->icount.frame = info->icount.parity = 0;
-                                info->icount.overrun = info->icount.brk = 0;
-                                chip_number = (port - cinfo->first_line) / 4;
-                                if ((info->chip_rev =
-                                     cy_readb(cinfo->base_addr +
-                                              (cy_chip_offset[chip_number] <<
-                                               index) + (CyGFRCR << index))) >=
-                                    CD1400_REV_J) {
-                                        /* It is a CD1400 rev. J or later */
-                                        info->tbpr = baud_bpr_60[13];   /* Tx BPR */
-                                        info->tco = baud_co_60[13];     /* Tx CO */
-                                        info->rbpr = baud_bpr_60[13];   /* Rx BPR */
-                                        info->rco = baud_co_60[13];     /* Rx CO */
-                                        info->rflow = 0;
-                                        info->rtsdtr_inv = 1;
-                                } else {
-                                        info->tbpr = baud_bpr_25[13];   /* Tx BPR */
-                                        info->tco = baud_co_25[13];     /* Tx CO */
-                                        info->rbpr = baud_bpr_25[13];   /* Rx BPR */
-                                        info->rco = baud_co_25[13];     /* Rx CO */
-                                        info->rflow = 0;
-                                        info->rtsdtr_inv = 0;
-                                }
-                                info->x_char = 0;
-                                info->event = 0;
-                                info->count = 0;
-                                info->blocked_open = 0;
-                                info->default_threshold = 0;
-                                info->default_timeout = 0;
-                                INIT_WORK(&info->tqueue, do_softint);
-                                init_waitqueue_head(&info->open_wait);
-                                init_waitqueue_head(&info->close_wait);
-                                init_waitqueue_head(&info->shutdown_wait);
-                                init_waitqueue_head(&info->delta_msr_wait);
-                                /* info->session */
-                                /* info->pgrp */
-                                info->read_status_mask =
-                                    CyTIMEOUT | CySPECHAR | CyBREAK
-                                    | CyPARITY | CyFRAME | CyOVERRUN;
-                                /* info->timeout */
-                        }
-                }
-        }
-
-#ifndef CONFIG_CYZ_INTR
-        if (number_z_boards && !cyz_timeron) {
-                cyz_timeron++;
-                cyz_timerlist.expires = jiffies + 1;
-                add_timer(&cyz_timerlist);
-#ifdef CY_PCI_DEBUG
-                printk("Cyclades-Z polling initialized\n");
-#endif
-        }
-#endif                          /* CONFIG_CYZ_INTR */
 
         return 0;
-
+err_unr:
+        tty_unregister_driver(cy_serial_driver);
+err_frtty:
+        put_tty_driver(cy_serial_driver);
+err:
+        return retval;
 }                               /* cy_init */
 
 static void __exit cy_cleanup_module(void)
 {
+        struct cyclades_card *card;
         int i, e1;
 
 #ifndef CONFIG_CYZ_INTR
-        if (cyz_timeron){
-                cyz_timeron = 0;
-                del_timer(&cyz_timerlist);
-        }
+        del_timer_sync(&cyz_timerlist);
 #endif /* CONFIG_CYZ_INTR */
 
         if ((e1 = tty_unregister_driver(cy_serial_driver)))
-                printk("cyc: failed to unregister Cyclades serial driver(%d)\n",
-                        e1);
+                printk(KERN_ERR "failed to unregister Cyclades serial "
+                                "driver(%d)\n", e1);
 
-        put_tty_driver(cy_serial_driver);
+#ifdef CONFIG_PCI
+        pci_unregister_driver(&cy_pci_driver);
+#endif
 
         for (i = 0; i < NR_CARDS; i++) {
-                if (cy_card[i].base_addr) {
-                        iounmap(cy_card[i].base_addr);
-                        if (cy_card[i].ctl_addr)
-                                iounmap(cy_card[i].ctl_addr);
-                        if (cy_card[i].irq
+                card = &cy_card[i];
+                if (card->base_addr) {
+                        /* clear interrupt */
+                        cy_writeb(card->base_addr + Cy_ClrIntr, 0);
+                        iounmap(card->base_addr);
+                        if (card->ctl_addr)
+                                iounmap(card->ctl_addr);
+                        if (card->irq
 #ifndef CONFIG_CYZ_INTR
-                                && cy_card[i].num_chips != -1 /* not a Z card */
+                                && !IS_CYC_Z(*card)
 #endif /* CONFIG_CYZ_INTR */
                                 )
-                                free_irq(cy_card[i].irq, &cy_card[i]);
-#ifdef CONFIG_PCI
-                        if (cy_card[i].pdev)
-                                pci_release_regions(cy_card[i].pdev);
-#endif
+                                free_irq(card->irq, card);
+                        for (e1 = card->first_line;
+                                        e1 < card->first_line +
+                                        card->nports; e1++)
+                                tty_unregister_device(cy_serial_driver, e1);
+                        kfree(card->ports);
                 }
         }
+
+        put_tty_driver(cy_serial_driver);
 } /* cy_cleanup_module */
 
 module_init(cy_init);
 module_exit(cy_cleanup_module);
 
 MODULE_LICENSE("GPL");
+MODULE_VERSION(CY_VERSION);
diff --git a/drivers/char/digi.h b/drivers/char/digi.h
deleted file mode 100644
index 19df0e879b1b..000000000000
--- a/drivers/char/digi.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/*          Definitions for DigiBoard ditty(1) command.                 */
-
-#if !defined(TIOCMODG)
-#define TIOCMODG        (('d'<<8) | 250)                /* get modem ctrl state */
-#define TIOCMODS        (('d'<<8) | 251)                /* set modem ctrl state */
-#endif
-
-#if !defined(TIOCMSET)
-#define TIOCMSET        (('d'<<8) | 252)                /* set modem ctrl state */
-#define TIOCMGET        (('d'<<8) | 253)                /* set modem ctrl state */
-#endif
-
-#if !defined(TIOCMBIC)
-#define TIOCMBIC        (('d'<<8) | 254)                /* set modem ctrl state */
-#define TIOCMBIS        (('d'<<8) | 255)                /* set modem ctrl state */
-#endif
-
-#if !defined(TIOCSDTR)
-#define TIOCSDTR        (('e'<<8) | 0)          /* set DTR              */
-#define TIOCCDTR        (('e'<<8) | 1)          /* clear DTR            */
-#endif
-
-/************************************************************************
- * Ioctl command arguments for DIGI parameters.
- ************************************************************************/
-#define DIGI_GETA       (('e'<<8) | 94)         /* Read params          */
-
-#define DIGI_SETA       (('e'<<8) | 95)         /* Set params           */
-#define DIGI_SETAW      (('e'<<8) | 96)         /* Drain & set params   */
-#define DIGI_SETAF      (('e'<<8) | 97)         /* Drain, flush & set params */
-
-#define DIGI_GETFLOW    (('e'<<8) | 99)         /* Get startc/stopc flow */
-                                                /* control characters    */
-#define DIGI_SETFLOW    (('e'<<8) | 100)                /* Set startc/stopc flow */
-                                                /* control characters    */
-#define DIGI_GETAFLOW   (('e'<<8) | 101)                /* Get Aux. startc/stopc */
-                                                /* flow control chars    */
-#define DIGI_SETAFLOW   (('e'<<8) | 102)                /* Set Aux. startc/stopc */
-                                                /* flow control chars    */
-
-struct  digiflow_struct {
-        unsigned char   startc;                         /* flow cntl start char */
-        unsigned char   stopc;                          /* flow cntl stop char  */
-};
-
-typedef struct digiflow_struct digiflow_t;
-
-
-/************************************************************************
- * Values for digi_flags 
- ************************************************************************/
-#define DIGI_IXON       0x0001          /* Handle IXON in the FEP       */
-#define DIGI_FAST       0x0002          /* Fast baud rates              */
-#define RTSPACE         0x0004          /* RTS input flow control       */
-#define CTSPACE         0x0008          /* CTS output flow control      */
-#define DSRPACE         0x0010          /* DSR output flow control      */
-#define DCDPACE         0x0020          /* DCD output flow control      */
-#define DTRPACE         0x0040          /* DTR input flow control       */
-#define DIGI_FORCEDCD   0x0100          /* Force carrier                */
-#define DIGI_ALTPIN     0x0200          /* Alternate RJ-45 pin config   */
-#define DIGI_AIXON      0x0400          /* Aux flow control in fep      */
-
-
-/************************************************************************
- * Structure used with ioctl commands for DIGI parameters.
- ************************************************************************/
-struct digi_struct {
-        unsigned short  digi_flags;             /* Flags (see above)    */
-};
-
-typedef struct digi_struct digi_t;
diff --git a/drivers/char/ds1620.c b/drivers/char/ds1620.c
index 3d7efc26aad6..334ad5bbe6b6 100644
--- a/drivers/char/ds1620.c
+++ b/drivers/char/ds1620.c
@@ -4,7 +4,6 @@
  */
 #include <linux/module.h>
 #include <linux/miscdevice.h>
-#include <linux/smp_lock.h>
 #include <linux/delay.h>
 #include <linux/proc_fs.h>
 #include <linux/capability.h>
diff --git a/drivers/char/dsp56k.c b/drivers/char/dsp56k.c
index db984e481d4c..9b8278e1f4f8 100644
--- a/drivers/char/dsp56k.c
+++ b/drivers/char/dsp56k.c
@@ -32,7 +32,6 @@
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/device.h>
 
 #include <asm/atarihw.h>
diff --git a/drivers/char/dtlk.c b/drivers/char/dtlk.c
index d8dbdb916232..abde6ddefe69 100644
--- a/drivers/char/dtlk.c
+++ b/drivers/char/dtlk.c
@@ -62,7 +62,6 @@
 #include <linux/init.h>         /* for __init, module_{init,exit} */
 #include <linux/poll.h>         /* for POLLIN, etc. */
 #include <linux/dtlk.h>         /* local header file for DoubleTalk values */
-#include <linux/smp_lock.h>
 
 #ifdef TRACING
 #define TRACE_TEXT(str) printk(str);
@@ -325,16 +324,22 @@ static int dtlk_release(struct inode *inode, struct file *file)
 
 static int __init dtlk_init(void)
 {
+        int err;
+
         dtlk_port_lpc = 0;
         dtlk_port_tts = 0;
         dtlk_busy = 0;
         dtlk_major = register_chrdev(0, "dtlk", &dtlk_fops);
-        if (dtlk_major == 0) {
+        if (dtlk_major < 0) {
                 printk(KERN_ERR "DoubleTalk PC - cannot register device\n");
-                return 0;
+                return dtlk_major;
+        }
+        err = dtlk_dev_probe();
+        if (err) {
+                unregister_chrdev(dtlk_major, "dtlk");
+                return err;
         }
-        if (dtlk_dev_probe() == 0)
-                printk(", MAJOR %d\n", dtlk_major);
+        printk(", MAJOR %d\n", dtlk_major);
 
         init_waitqueue_head(&dtlk_process_list);
 
diff --git a/drivers/char/ec3104_keyb.c b/drivers/char/ec3104_keyb.c
index 77f58ed6d59a..020011495d91 100644
--- a/drivers/char/ec3104_keyb.c
+++ b/drivers/char/ec3104_keyb.c
@@ -41,7 +41,6 @@
 #include <linux/miscdevice.h>
 #include <linux/slab.h>
 #include <linux/kbd_kern.h>
-#include <linux/smp_lock.h>
 #include <linux/bitops.h>
 
 #include <asm/keyboard.h>
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index de5be30484ad..c6c56fb8ba50 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -949,7 +949,7 @@ static int block_til_ready(struct tty_struct *tty,
 
         } /* End forever while  */
 
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&ch->open_wait, &wait);
         if (!tty_hung_up_p(filp))
                 ch->count++;
diff --git a/drivers/char/genrtc.c b/drivers/char/genrtc.c
index 23b25ada65ea..49f914e79216 100644
--- a/drivers/char/genrtc.c
+++ b/drivers/char/genrtc.c
@@ -207,7 +207,7 @@ static ssize_t gen_rtc_read(struct file *file, char __user *buf,
                         sizeof(unsigned long);
         }
  out:
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&gen_rtc_wait, &wait);
 
         return retval;
diff --git a/drivers/char/hangcheck-timer.c b/drivers/char/hangcheck-timer.c
index ae76a9ffe89f..f0e7263dfcde 100644
--- a/drivers/char/hangcheck-timer.c
+++ b/drivers/char/hangcheck-timer.c
@@ -44,7 +44,6 @@
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/reboot.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <asm/uaccess.h>
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index 0f9ed7b46a6d..322bc5f7d86b 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -111,7 +111,7 @@ static int last_hvc = -1;
  * lock held.  If successful, this function increments the kobject reference
  * count against the target hvc_struct so it should be released when finished.
  */
-struct hvc_struct *hvc_get_by_index(int index)
+static struct hvc_struct *hvc_get_by_index(int index)
 {
         struct hvc_struct *hp;
         unsigned long flags;
@@ -150,7 +150,8 @@ static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
  * hvc_console_setup() finds adapters.
  */
 
-void hvc_console_print(struct console *co, const char *b, unsigned count)
+static void hvc_console_print(struct console *co, const char *b,
+                              unsigned count)
 {
         char c[N_OUTBUF] __ALIGNED__;
         unsigned i = 0, n = 0;
@@ -208,7 +209,7 @@ static int __init hvc_console_setup(struct console *co, char *options)
         return 0;
 }
 
-struct console hvc_con_driver = {
+static struct console hvc_con_driver = {
         .name           = "hvc",
         .write          = hvc_console_print,
         .device         = hvc_console_device,
@@ -278,7 +279,6 @@ int hvc_instantiate(uint32_t vtermno, int index, struct hv_ops *ops)
 
         return 0;
 }
-EXPORT_SYMBOL(hvc_instantiate);
 
 /* Wake the sleeping khvcd */
 static void hvc_kick(void)
@@ -792,7 +792,6 @@ struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int irq,
 
         return hp;
 }
-EXPORT_SYMBOL(hvc_alloc);
 
 int __devexit hvc_remove(struct hvc_struct *hp)
 {
@@ -828,11 +827,10 @@ int __devexit hvc_remove(struct hvc_struct *hp)
                 tty_hangup(tty);
         return 0;
 }
-EXPORT_SYMBOL(hvc_remove);
 
 /* Driver initialization.  Follow console initialization.  This is where the TTY
  * interfaces start to become available. */
-int __init hvc_init(void)
+static int __init hvc_init(void)
 {
         struct tty_driver *drv;
 
diff --git a/drivers/char/hw_random/intel-rng.c b/drivers/char/hw_random/intel-rng.c
index cc1046e6ee02..4ae9811d1a6c 100644
--- a/drivers/char/hw_random/intel-rng.c
+++ b/drivers/char/hw_random/intel-rng.c
@@ -24,10 +24,11 @@
  * warranty of any kind, whether express or implied.
  */
 
-#include <linux/module.h>
+#include <linux/hw_random.h>
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/pci.h>
-#include <linux/hw_random.h>
+#include <linux/stop_machine.h>
 #include <asm/io.h>
 
 
@@ -217,30 +218,117 @@ static struct hwrng intel_rng = {
         .data_read      = intel_rng_data_read,
 };
 
+struct intel_rng_hw {
+        struct pci_dev *dev;
+        void __iomem *mem;
+        u8 bios_cntl_off;
+        u8 bios_cntl_val;
+        u8 fwh_dec_en1_off;
+        u8 fwh_dec_en1_val;
+};
 
-#ifdef CONFIG_SMP
-static char __initdata waitflag;
+static int __init intel_rng_hw_init(void *_intel_rng_hw)
+{
+        struct intel_rng_hw *intel_rng_hw = _intel_rng_hw;
+        u8 mfc, dvc;
+
+        /* interrupts disabled in stop_machine_run call */
+
+        if (!(intel_rng_hw->fwh_dec_en1_val & FWH_F8_EN_MASK))
+                pci_write_config_byte(intel_rng_hw->dev,
+                                      intel_rng_hw->fwh_dec_en1_off,
+                                      intel_rng_hw->fwh_dec_en1_val |
+                                      FWH_F8_EN_MASK);
+        if (!(intel_rng_hw->bios_cntl_val & BIOS_CNTL_WRITE_ENABLE_MASK))
+                pci_write_config_byte(intel_rng_hw->dev,
+                                      intel_rng_hw->bios_cntl_off,
+                                      intel_rng_hw->bios_cntl_val |
+                                      BIOS_CNTL_WRITE_ENABLE_MASK);
+
+        writeb(INTEL_FWH_RESET_CMD, intel_rng_hw->mem);
+        writeb(INTEL_FWH_READ_ID_CMD, intel_rng_hw->mem);
+        mfc = readb(intel_rng_hw->mem + INTEL_FWH_MANUFACTURER_CODE_ADDRESS);
+        dvc = readb(intel_rng_hw->mem + INTEL_FWH_DEVICE_CODE_ADDRESS);
+        writeb(INTEL_FWH_RESET_CMD, intel_rng_hw->mem);
+
+        if (!(intel_rng_hw->bios_cntl_val &
+              (BIOS_CNTL_LOCK_ENABLE_MASK|BIOS_CNTL_WRITE_ENABLE_MASK)))
+                pci_write_config_byte(intel_rng_hw->dev,
+                                      intel_rng_hw->bios_cntl_off,
+                                      intel_rng_hw->bios_cntl_val);
+        if (!(intel_rng_hw->fwh_dec_en1_val & FWH_F8_EN_MASK))
+                pci_write_config_byte(intel_rng_hw->dev,
+                                      intel_rng_hw->fwh_dec_en1_off,
+                                      intel_rng_hw->fwh_dec_en1_val);
 
-static void __init intel_init_wait(void *unused)
+        if (mfc != INTEL_FWH_MANUFACTURER_CODE ||
+            (dvc != INTEL_FWH_DEVICE_CODE_8M &&
+             dvc != INTEL_FWH_DEVICE_CODE_4M)) {
+                printk(KERN_ERR PFX "FWH not detected\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int __init intel_init_hw_struct(struct intel_rng_hw *intel_rng_hw,
+                                        struct pci_dev *dev)
 {
-        while (waitflag)
-                cpu_relax();
+        intel_rng_hw->bios_cntl_val = 0xff;
+        intel_rng_hw->fwh_dec_en1_val = 0xff;
+        intel_rng_hw->dev = dev;
+
+        /* Check for Intel 82802 */
+        if (dev->device < 0x2640) {
+                intel_rng_hw->fwh_dec_en1_off = FWH_DEC_EN1_REG_OLD;
+                intel_rng_hw->bios_cntl_off = BIOS_CNTL_REG_OLD;
+        } else {
+                intel_rng_hw->fwh_dec_en1_off = FWH_DEC_EN1_REG_NEW;
+                intel_rng_hw->bios_cntl_off = BIOS_CNTL_REG_NEW;
+        }
+
+        pci_read_config_byte(dev, intel_rng_hw->fwh_dec_en1_off,
+                             &intel_rng_hw->fwh_dec_en1_val);
+        pci_read_config_byte(dev, intel_rng_hw->bios_cntl_off,
+                             &intel_rng_hw->bios_cntl_val);
+
+        if ((intel_rng_hw->bios_cntl_val &
+             (BIOS_CNTL_LOCK_ENABLE_MASK|BIOS_CNTL_WRITE_ENABLE_MASK))
+            == BIOS_CNTL_LOCK_ENABLE_MASK) {
+                static __initdata /*const*/ char warning[] =
+                        KERN_WARNING PFX "Firmware space is locked read-only. "
+                        KERN_WARNING PFX "If you can't or\n don't want to "
+                        KERN_WARNING PFX "disable this in firmware setup, and "
+                        KERN_WARNING PFX "if\n you are certain that your "
+                        KERN_WARNING PFX "system has a functional\n RNG, try"
+                        KERN_WARNING PFX "using the 'no_fwh_detect' option.\n";
+
+                if (no_fwh_detect)
+                        return -ENODEV;
+                printk(warning);
+                return -EBUSY;
+        }
+
+        intel_rng_hw->mem = ioremap_nocache(INTEL_FWH_ADDR, INTEL_FWH_ADDR_LEN);
+        if (intel_rng_hw->mem == NULL)
+                return -EBUSY;
+
+        return 0;
 }
-#endif
+
 
 static int __init mod_init(void)
 {
         int err = -ENODEV;
-        unsigned i;
+        int i;
         struct pci_dev *dev = NULL;
-        void __iomem *mem;
-        unsigned long flags;
-        u8 bios_cntl_off, fwh_dec_en1_off;
-        u8 bios_cntl_val = 0xff, fwh_dec_en1_val = 0xff;
-        u8 hw_status, mfc, dvc;
+        void __iomem *mem = mem;
+        u8 hw_status;
+        struct intel_rng_hw *intel_rng_hw;
 
         for (i = 0; !dev && pci_tbl[i].vendor; ++i)
-                dev = pci_get_device(pci_tbl[i].vendor, pci_tbl[i].device, NULL);
+                dev = pci_get_device(pci_tbl[i].vendor, pci_tbl[i].device,
+                                     NULL);
 
         if (!dev)
                 goto out; /* Device not found. */
@@ -250,39 +338,18 @@ static int __init mod_init(void)
                 goto fwh_done;
         }
 
-        /* Check for Intel 82802 */
-        if (dev->device < 0x2640) {
-                fwh_dec_en1_off = FWH_DEC_EN1_REG_OLD;
-                bios_cntl_off = BIOS_CNTL_REG_OLD;
-        } else {
-                fwh_dec_en1_off = FWH_DEC_EN1_REG_NEW;
-                bios_cntl_off = BIOS_CNTL_REG_NEW;
-        }
-
-        pci_read_config_byte(dev, fwh_dec_en1_off, &fwh_dec_en1_val);
-        pci_read_config_byte(dev, bios_cntl_off, &bios_cntl_val);
-
-        if ((bios_cntl_val &
-             (BIOS_CNTL_LOCK_ENABLE_MASK|BIOS_CNTL_WRITE_ENABLE_MASK))
-            == BIOS_CNTL_LOCK_ENABLE_MASK) {
-                static __initdata /*const*/ char warning[] =
-                        KERN_WARNING PFX "Firmware space is locked read-only. If you can't or\n"
-                        KERN_WARNING PFX "don't want to disable this in firmware setup, and if\n"
-                        KERN_WARNING PFX "you are certain that your system has a functional\n"
-                        KERN_WARNING PFX "RNG, try using the 'no_fwh_detect' option.\n";
-
+        intel_rng_hw = kmalloc(sizeof(*intel_rng_hw), GFP_KERNEL);
+        if (!intel_rng_hw) {
                 pci_dev_put(dev);
-                if (no_fwh_detect)
-                        goto fwh_done;
-                printk(warning);
-                err = -EBUSY;
                 goto out;
         }
 
-        mem = ioremap_nocache(INTEL_FWH_ADDR, INTEL_FWH_ADDR_LEN);
-        if (mem == NULL) {
+        err = intel_init_hw_struct(intel_rng_hw, dev);
+        if (err) {
                 pci_dev_put(dev);
-                err = -EBUSY;
+                kfree(intel_rng_hw);
+                if (err == -ENODEV)
+                        goto fwh_done;
                 goto out;
         }
 
@@ -290,59 +357,18 @@ static int __init mod_init(void)
          * Since the BIOS code/data is going to disappear from its normal
          * location with the Read ID command, all activity on the system
          * must be stopped until the state is back to normal.
+         *
+         * Use stop_machine_run because IPIs can be blocked by disabling
+         * interrupts.
          */
-#ifdef CONFIG_SMP
-        set_mb(waitflag, 1);
-        if (smp_call_function(intel_init_wait, NULL, 1, 0) != 0) {
-                set_mb(waitflag, 0);
-                pci_dev_put(dev);
-                printk(KERN_ERR PFX "cannot run on all processors\n");
-                err = -EAGAIN;
-                goto err_unmap;
-        }
-#endif
-        local_irq_save(flags);
-
-        if (!(fwh_dec_en1_val & FWH_F8_EN_MASK))
-                pci_write_config_byte(dev,
-                                      fwh_dec_en1_off,
-                                      fwh_dec_en1_val | FWH_F8_EN_MASK);
-        if (!(bios_cntl_val & BIOS_CNTL_WRITE_ENABLE_MASK))
-                pci_write_config_byte(dev,
-                                      bios_cntl_off,
-                                      bios_cntl_val | BIOS_CNTL_WRITE_ENABLE_MASK);
-
-        writeb(INTEL_FWH_RESET_CMD, mem);
-        writeb(INTEL_FWH_READ_ID_CMD, mem);
-        mfc = readb(mem + INTEL_FWH_MANUFACTURER_CODE_ADDRESS);
-        dvc = readb(mem + INTEL_FWH_DEVICE_CODE_ADDRESS);
-        writeb(INTEL_FWH_RESET_CMD, mem);
-
-        if (!(bios_cntl_val &
-              (BIOS_CNTL_LOCK_ENABLE_MASK|BIOS_CNTL_WRITE_ENABLE_MASK)))
-                pci_write_config_byte(dev, bios_cntl_off, bios_cntl_val);
-        if (!(fwh_dec_en1_val & FWH_F8_EN_MASK))
-                pci_write_config_byte(dev, fwh_dec_en1_off, fwh_dec_en1_val);
-
-        local_irq_restore(flags);
-#ifdef CONFIG_SMP
-        /* Tell other CPUs to resume. */
-        set_mb(waitflag, 0);
-#endif
-
-        iounmap(mem);
+        err = stop_machine_run(intel_rng_hw_init, intel_rng_hw, NR_CPUS);
         pci_dev_put(dev);
-
-        if (mfc != INTEL_FWH_MANUFACTURER_CODE ||
-            (dvc != INTEL_FWH_DEVICE_CODE_8M &&
-             dvc != INTEL_FWH_DEVICE_CODE_4M)) {
-                printk(KERN_ERR PFX "FWH not detected\n");
-                err = -ENODEV;
+        iounmap(intel_rng_hw->mem);
+        kfree(intel_rng_hw);
+        if (err)
                 goto out;
-        }
 
 fwh_done:
-
         err = -ENOMEM;
         mem = ioremap(INTEL_RNG_ADDR, INTEL_RNG_ADDR_LEN);
         if (!mem)
@@ -352,22 +378,21 @@ fwh_done:
         /* Check for Random Number Generator */
         err = -ENODEV;
         hw_status = hwstatus_get(mem);
-        if ((hw_status & INTEL_RNG_PRESENT) == 0)
-                goto err_unmap;
+        if ((hw_status & INTEL_RNG_PRESENT) == 0) {
+                iounmap(mem);
+                goto out;
+        }
 
         printk(KERN_INFO "Intel 82802 RNG detected\n");
         err = hwrng_register(&intel_rng);
         if (err) {
                 printk(KERN_ERR PFX "RNG registering failed (%d)\n",
                        err);
-                goto err_unmap;
+                iounmap(mem);
         }
 out:
         return err;
 
-err_unmap:
-        iounmap(mem);
-        goto out;
 }
 
 static void __exit mod_exit(void)
diff --git a/drivers/char/i8k.c b/drivers/char/i8k.c
index 353d9f3cf8d7..0289705967de 100644
--- a/drivers/char/i8k.c
+++ b/drivers/char/i8k.c
@@ -22,6 +22,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/dmi.h>
+#include <linux/capability.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
diff --git a/drivers/char/ip27-rtc.c b/drivers/char/ip27-rtc.c
index a48da02aad2f..932264a657d0 100644
--- a/drivers/char/ip27-rtc.c
+++ b/drivers/char/ip27-rtc.c
@@ -35,7 +35,6 @@
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
-#include <linux/smp_lock.h>
 
 #include <asm/m48t35.h>
 #include <asm/sn/ioc3.h>
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index e22146546add..6c5d15de3317 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -9,6 +9,7 @@
  *         source@mvista.com
  *
  * Copyright 2002 MontaVista Software Inc.
+ * Copyright 2006 IBM Corp., Christian Krafft <krafft@de.ibm.com>
  *
  *  This program is free software; you can redistribute it and/or modify it
  *  under the terms of the GNU General Public License as published by the
@@ -64,6 +65,11 @@
 #include <linux/string.h>
 #include <linux/ctype.h>
 
+#ifdef CONFIG_PPC_OF
+#include <asm/of_device.h>
+#include <asm/of_platform.h>
+#endif
+
 #define PFX "ipmi_si: "
 
 /* Measure times between events in the driver. */
@@ -76,6 +82,12 @@
 #define SI_SHORT_TIMEOUT_USEC  250 /* .25ms when the SM request a
                                        short timeout */
 
+/* Bit for BMC global enables. */
+#define IPMI_BMC_RCV_MSG_INTR     0x01
+#define IPMI_BMC_EVT_MSG_INTR     0x02
+#define IPMI_BMC_EVT_MSG_BUFF     0x04
+#define IPMI_BMC_SYS_LOG          0x08
+
 enum si_intf_state {
         SI_NORMAL,
         SI_GETTING_FLAGS,
@@ -84,7 +96,9 @@ enum si_intf_state {
         SI_CLEARING_FLAGS_THEN_SET_IRQ,
         SI_GETTING_MESSAGES,
         SI_ENABLE_INTERRUPTS1,
-        SI_ENABLE_INTERRUPTS2
+        SI_ENABLE_INTERRUPTS2,
+        SI_DISABLE_INTERRUPTS1,
+        SI_DISABLE_INTERRUPTS2
         /* FIXME - add watchdog stuff. */
 };
 
@@ -333,6 +347,17 @@ static void start_enable_irq(struct smi_info *smi_info)
         smi_info->si_state = SI_ENABLE_INTERRUPTS1;
 }
 
+static void start_disable_irq(struct smi_info *smi_info)
+{
+        unsigned char msg[2];
+
+        msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
+        msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
+
+        smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
+        smi_info->si_state = SI_DISABLE_INTERRUPTS1;
+}
+
 static void start_clear_flags(struct smi_info *smi_info)
 {
         unsigned char msg[3];
@@ -353,7 +378,7 @@ static void start_clear_flags(struct smi_info *smi_info)
 static inline void disable_si_irq(struct smi_info *smi_info)
 {
         if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
-                disable_irq_nosync(smi_info->irq);
+                start_disable_irq(smi_info);
                 smi_info->interrupt_disabled = 1;
         }
 }
@@ -361,7 +386,7 @@ static inline void disable_si_irq(struct smi_info *smi_info)
 static inline void enable_si_irq(struct smi_info *smi_info)
 {
         if ((smi_info->irq) && (smi_info->interrupt_disabled)) {
-                enable_irq(smi_info->irq);
+                start_enable_irq(smi_info);
                 smi_info->interrupt_disabled = 0;
         }
 }
@@ -583,7 +608,9 @@ static void handle_transaction_done(struct smi_info *smi_info)
                 } else {
                         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
                         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
-                        msg[2] = msg[3] | 1; /* enable msg queue int */
+                        msg[2] = (msg[3] |
+                                  IPMI_BMC_RCV_MSG_INTR |
+                                  IPMI_BMC_EVT_MSG_INTR);
                         smi_info->handlers->start_transaction(
                                 smi_info->si_sm, msg, 3);
                         smi_info->si_state = SI_ENABLE_INTERRUPTS2;
@@ -605,6 +632,45 @@ static void handle_transaction_done(struct smi_info *smi_info)
                 smi_info->si_state = SI_NORMAL;
                 break;
         }
+
+        case SI_DISABLE_INTERRUPTS1:
+        {
+                unsigned char msg[4];
+
+                /* We got the flags from the SMI, now handle them. */
+                smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
+                if (msg[2] != 0) {
+                        printk(KERN_WARNING
+                               "ipmi_si: Could not disable interrupts"
+                               ", failed get.\n");
+                        smi_info->si_state = SI_NORMAL;
+                } else {
+                        msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
+                        msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
+                        msg[2] = (msg[3] &
+                                  ~(IPMI_BMC_RCV_MSG_INTR |
+                                    IPMI_BMC_EVT_MSG_INTR));
+                        smi_info->handlers->start_transaction(
+                                smi_info->si_sm, msg, 3);
+                        smi_info->si_state = SI_DISABLE_INTERRUPTS2;
+                }
+                break;
+        }
+
+        case SI_DISABLE_INTERRUPTS2:
+        {
+                unsigned char msg[4];
+
+                /* We got the flags from the SMI, now handle them. */
+                smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
+                if (msg[2] != 0) {
+                        printk(KERN_WARNING
+                               "ipmi_si: Could not disable interrupts"
+                               ", failed set.\n");
+                }
+                smi_info->si_state = SI_NORMAL;
+                break;
+        }
         }
 }
 
@@ -858,9 +924,6 @@ static void smi_timeout(unsigned long data)
         struct timeval    t;
 #endif
 
-        if (atomic_read(&smi_info->stop_operation))
-                return;
-
         spin_lock_irqsave(&(smi_info->si_lock), flags);
 #ifdef DEBUG_TIMING
         do_gettimeofday(&t);
@@ -916,15 +979,11 @@ static irqreturn_t si_irq_handler(int irq, void *data)
         smi_info->interrupts++;
         spin_unlock(&smi_info->count_lock);
 
-        if (atomic_read(&smi_info->stop_operation))
-                goto out;
-
 #ifdef DEBUG_TIMING
         do_gettimeofday(&t);
         printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
         smi_event_handler(smi_info, 0);
- out:
         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
         return IRQ_HANDLED;
 }
@@ -1006,6 +1065,7 @@ static DEFINE_MUTEX(smi_infos_lock);
 static int smi_num; /* Used to sequence the SMIs */
 
 #define DEFAULT_REGSPACING      1
+#define DEFAULT_REGSIZE         1
 
 static int           si_trydefaults = 1;
 static char          *si_type[SI_MAX_PARMS];
@@ -1111,7 +1171,7 @@ static int std_irq_setup(struct smi_info *info)
         if (info->si_type == SI_BT) {
                 rv = request_irq(info->irq,
                                  si_bt_irq_handler,
-                                 IRQF_DISABLED,
+                                 IRQF_SHARED | IRQF_DISABLED,
                                  DEVICE_NAME,
                                  info);
                 if (!rv)
@@ -1121,7 +1181,7 @@ static int std_irq_setup(struct smi_info *info)
         } else
                 rv = request_irq(info->irq,
                                  si_irq_handler,
-                                 IRQF_DISABLED,
+                                 IRQF_SHARED | IRQF_DISABLED,
                                  DEVICE_NAME,
                                  info);
         if (rv) {
@@ -1701,15 +1761,11 @@ static u32 ipmi_acpi_gpe(void *context)
         smi_info->interrupts++;
         spin_unlock(&smi_info->count_lock);
 
-        if (atomic_read(&smi_info->stop_operation))
-                goto out;
-
 #ifdef DEBUG_TIMING
         do_gettimeofday(&t);
         printk("**ACPI_GPE: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
         smi_event_handler(smi_info, 0);
- out:
         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 
         return ACPI_INTERRUPT_HANDLED;
@@ -2133,12 +2189,15 @@ static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
                 info->irq_setup = std_irq_setup;
 
         info->dev = &pdev->dev;
+        pci_set_drvdata(pdev, info);
 
         return try_smi_init(info);
 }
 
 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
 {
+        struct smi_info *info = pci_get_drvdata(pdev);
+        cleanup_one_si(info);
 }
 
 #ifdef CONFIG_PM
@@ -2172,6 +2231,99 @@ static struct pci_driver ipmi_pci_driver = {
 #endif /* CONFIG_PCI */
 
 
+#ifdef CONFIG_PPC_OF
+static int __devinit ipmi_of_probe(struct of_device *dev,
+                         const struct of_device_id *match)
+{
+        struct smi_info *info;
+        struct resource resource;
+        const int *regsize, *regspacing, *regshift;
+        struct device_node *np = dev->node;
+        int ret;
+        int proplen;
+
+        dev_info(&dev->dev, PFX "probing via device tree\n");
+
+        ret = of_address_to_resource(np, 0, &resource);
+        if (ret) {
+                dev_warn(&dev->dev, PFX "invalid address from OF\n");
+                return ret;
+        }
+
+        regsize = get_property(np, "reg-size", &proplen);
+        if (regsize && proplen != 4) {
+                dev_warn(&dev->dev, PFX "invalid regsize from OF\n");
+                return -EINVAL;
+        }
+
+        regspacing = get_property(np, "reg-spacing", &proplen);
+        if (regspacing && proplen != 4) {
+                dev_warn(&dev->dev, PFX "invalid regspacing from OF\n");
+                return -EINVAL;
+        }
+
+        regshift = get_property(np, "reg-shift", &proplen);
+        if (regshift && proplen != 4) {
+                dev_warn(&dev->dev, PFX "invalid regshift from OF\n");
+                return -EINVAL;
+        }
+
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+
+        if (!info) {
+                dev_err(&dev->dev,
+                        PFX "could not allocate memory for OF probe\n");
+                return -ENOMEM;
+        }
+
+        info->si_type           = (enum si_type) match->data;
+        info->addr_source       = "device-tree";
+        info->io_setup          = mem_setup;
+        info->irq_setup         = std_irq_setup;
+
+        info->io.addr_type      = IPMI_MEM_ADDR_SPACE;
+        info->io.addr_data      = resource.start;
+
+        info->io.regsize        = regsize ? *regsize : DEFAULT_REGSIZE;
+        info->io.regspacing     = regspacing ? *regspacing : DEFAULT_REGSPACING;
+        info->io.regshift       = regshift ? *regshift : 0;
+
+        info->irq               = irq_of_parse_and_map(dev->node, 0);
+        info->dev               = &dev->dev;
+
+        dev_dbg(&dev->dev, "addr 0x%lx regsize %ld spacing %ld irq %x\n",
+                info->io.addr_data, info->io.regsize, info->io.regspacing,
+                info->irq);
+
+        dev->dev.driver_data = (void*) info;
+
+        return try_smi_init(info);
+}
+
+static int __devexit ipmi_of_remove(struct of_device *dev)
+{
+        cleanup_one_si(dev->dev.driver_data);
+        return 0;
+}
+
+static struct of_device_id ipmi_match[] =
+{
+        { .type = "ipmi", .compatible = "ipmi-kcs",  .data = (void *)(unsigned long) SI_KCS },
+        { .type = "ipmi", .compatible = "ipmi-smic", .data = (void *)(unsigned long) SI_SMIC },
+        { .type = "ipmi", .compatible = "ipmi-bt",   .data = (void *)(unsigned long) SI_BT },
+        {},
+};
+
+static struct of_platform_driver ipmi_of_platform_driver =
+{
+        .name           = "ipmi",
+        .match_table    = ipmi_match,
+        .probe          = ipmi_of_probe,
+        .remove         = __devexit_p(ipmi_of_remove),
+};
+#endif /* CONFIG_PPC_OF */
+
+
 static int try_get_dev_id(struct smi_info *smi_info)
 {
         unsigned char         msg[2];
@@ -2801,6 +2953,10 @@ static __devinit int init_ipmi_si(void)
         }
 #endif
 
+#ifdef CONFIG_PPC_OF
+        of_register_platform_driver(&ipmi_of_platform_driver);
+#endif
+
         if (si_trydefaults) {
                 mutex_lock(&smi_infos_lock);
                 if (list_empty(&smi_infos)) {
@@ -2838,28 +2994,33 @@ static void cleanup_one_si(struct smi_info *to_clean)
 
         list_del(&to_clean->link);
 
-        /* Tell the timer and interrupt handlers that we are shutting
-           down. */
-        spin_lock_irqsave(&(to_clean->si_lock), flags);
-        spin_lock(&(to_clean->msg_lock));
-
+        /* Tell the driver that we are shutting down. */
         atomic_inc(&to_clean->stop_operation);
 
-        if (to_clean->irq_cleanup)
-                to_clean->irq_cleanup(to_clean);
-
-        spin_unlock(&(to_clean->msg_lock));
-        spin_unlock_irqrestore(&(to_clean->si_lock), flags);
-
-        /* Wait until we know that we are out of any interrupt
-           handlers might have been running before we freed the
-           interrupt. */
-        synchronize_sched();
-
+        /* Make sure the timer and thread are stopped and will not run
+           again. */
         wait_for_timer_and_thread(to_clean);
 
-        /* Interrupts and timeouts are stopped, now make sure the
-           interface is in a clean state. */
+        /* Timeouts are stopped, now make sure the interrupts are off
+           for the device.  A little tricky with locks to make sure
+           there are no races. */
+        spin_lock_irqsave(&to_clean->si_lock, flags);
+        while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
+                spin_unlock_irqrestore(&to_clean->si_lock, flags);
+                poll(to_clean);
+                schedule_timeout_uninterruptible(1);
+                spin_lock_irqsave(&to_clean->si_lock, flags);
+        }
+        disable_si_irq(to_clean);
+        spin_unlock_irqrestore(&to_clean->si_lock, flags);
+        while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
+                poll(to_clean);
+                schedule_timeout_uninterruptible(1);
+        }
+
+        /* Clean up interrupts and make sure that everything is done. */
+        if (to_clean->irq_cleanup)
+                to_clean->irq_cleanup(to_clean);
         while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
                 poll(to_clean);
                 schedule_timeout_uninterruptible(1);
@@ -2898,6 +3059,10 @@ static __exit void cleanup_ipmi_si(void)
         pci_unregister_driver(&ipmi_pci_driver);
 #endif
 
+#ifdef CONFIG_PPC_OF
+        of_unregister_platform_driver(&ipmi_of_platform_driver);
+#endif
+
         mutex_lock(&smi_infos_lock);
         list_for_each_entry_safe(e, tmp_e, &smi_infos, link)
                 cleanup_one_si(e);
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index 6b634e8d9519..147c12047cf3 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -39,6 +39,7 @@
 #include <linux/miscdevice.h>
 #include <linux/init.h>
 #include <linux/completion.h>
+#include <linux/kdebug.h>
 #include <linux/rwsem.h>
 #include <linux/errno.h>
 #include <asm/uaccess.h>
@@ -49,9 +50,18 @@
 #include <linux/poll.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
+#include <linux/delay.h>
 #include <asm/atomic.h>
-#ifdef CONFIG_X86_LOCAL_APIC
-#include <asm/apic.h>
+
+#ifdef CONFIG_X86
+/* This is ugly, but I've determined that x86 is the only architecture
+   that can reasonably support the IPMI NMI watchdog timeout at this
+   time.  If another architecture adds this capability somehow, it
+   will have to be a somewhat different mechanism and I have no idea
+   how it will work.  So in the unlikely event that another
+   architecture supports this, we can figure out a good generic
+   mechanism for it at that time. */
+#define HAVE_DIE_NMI_POST
 #endif
 
 #define PFX "IPMI Watchdog: "
@@ -317,6 +327,11 @@ static unsigned char ipmi_version_minor;
 /* If a pretimeout occurs, this is used to allow only one panic to happen. */
 static atomic_t preop_panic_excl = ATOMIC_INIT(-1);
 
+#ifdef HAVE_DIE_NMI_POST
+static int testing_nmi;
+static int nmi_handler_registered;
+#endif
+
 static int ipmi_heartbeat(void);
 static void panic_halt_ipmi_heartbeat(void);
 
@@ -358,6 +373,10 @@ static int i_ipmi_set_timeout(struct ipmi_smi_msg  *smi_msg,
         int                               hbnow = 0;
 
 
+        /* These can be cleared as we are setting the timeout. */
+        ipmi_start_timer_on_heartbeat = 0;
+        pretimeout_since_last_heartbeat = 0;
+
         data[0] = 0;
         WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
 
@@ -432,13 +451,12 @@ static int ipmi_set_timeout(int do_heartbeat)
 
         wait_for_completion(&set_timeout_wait);
 
+        mutex_unlock(&set_timeout_lock);
+
         if ((do_heartbeat == IPMI_SET_TIMEOUT_FORCE_HB)
             || ((send_heartbeat_now)
                 && (do_heartbeat == IPMI_SET_TIMEOUT_HB_IF_NECESSARY)))
-        {
                 rv = ipmi_heartbeat();
-        }
-        mutex_unlock(&set_timeout_lock);
 
 out:
         return rv;
@@ -518,12 +536,10 @@ static int ipmi_heartbeat(void)
         int                               rv;
         struct ipmi_system_interface_addr addr;
 
-        if (ipmi_ignore_heartbeat) {
+        if (ipmi_ignore_heartbeat)
                 return 0;
-        }
 
         if (ipmi_start_timer_on_heartbeat) {
-                ipmi_start_timer_on_heartbeat = 0;
                 ipmi_watchdog_state = action_val;
                 return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
         } else if (pretimeout_since_last_heartbeat) {
@@ -531,7 +547,6 @@ static int ipmi_heartbeat(void)
                    We don't want to set the action, though, we want to
                    leave that alone (thus it can't be combined with the
                    above operation. */
-                pretimeout_since_last_heartbeat = 0;
                 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
         }
 
@@ -919,6 +934,45 @@ static void ipmi_register_watchdog(int ipmi_intf)
                 printk(KERN_CRIT PFX "Unable to register misc device\n");
         }
 
+#ifdef HAVE_DIE_NMI_POST
+        if (nmi_handler_registered) {
+                int old_pretimeout = pretimeout;
+                int old_timeout = timeout;
+                int old_preop_val = preop_val;
+
+                /* Set the pretimeout to go off in a second and give
+                   ourselves plenty of time to stop the timer. */
+                ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
+                preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */
+                pretimeout = 99;
+                timeout = 100;
+
+                testing_nmi = 1;
+
+                rv = ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
+                if (rv) {
+                        printk(KERN_WARNING PFX "Error starting timer to"
+                               " test NMI: 0x%x.  The NMI pretimeout will"
+                               " likely not work\n", rv);
+                        rv = 0;
+                        goto out_restore;
+                }
+
+                msleep(1500);
+
+                if (testing_nmi != 2) {
+                        printk(KERN_WARNING PFX "IPMI NMI didn't seem to"
+                               " occur.  The NMI pretimeout will"
+                               " likely not work\n");
+                }
+        out_restore:
+                testing_nmi = 0;
+                preop_val = old_preop_val;
+                pretimeout = old_pretimeout;
+                timeout = old_timeout;
+        }
+#endif
+
  out:
         up_write(&register_sem);
 
@@ -928,6 +982,10 @@ static void ipmi_register_watchdog(int ipmi_intf)
                 ipmi_watchdog_state = action_val;
                 ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
                 printk(KERN_INFO PFX "Starting now!\n");
+        } else {
+                /* Stop the timer now. */
+                ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
+                ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
         }
 }
 
@@ -964,17 +1022,28 @@ static void ipmi_unregister_watchdog(int ipmi_intf)
         up_write(&register_sem);
 }
 
-#ifdef HAVE_NMI_HANDLER
+#ifdef HAVE_DIE_NMI_POST
 static int
-ipmi_nmi(void *dev_id, int cpu, int handled)
+ipmi_nmi(struct notifier_block *self, unsigned long val, void *data)
 {
+        if (val != DIE_NMI_POST)
+                return NOTIFY_OK;
+
+        if (testing_nmi) {
+                testing_nmi = 2;
+                return NOTIFY_STOP;
+        }
+
         /* If we are not expecting a timeout, ignore it. */
         if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
-                return NOTIFY_DONE;
+                return NOTIFY_OK;
+
+        if (preaction_val != WDOG_PRETIMEOUT_NMI)
+                return NOTIFY_OK;
 
         /* If no one else handled the NMI, we assume it was the IPMI
            watchdog. */
-        if ((!handled) && (preop_val == WDOG_PREOP_PANIC)) {
+        if (preop_val == WDOG_PREOP_PANIC) {
                 /* On some machines, the heartbeat will give
                    an error and not work unless we re-enable
                    the timer.   So do so. */
@@ -983,18 +1052,12 @@ ipmi_nmi(void *dev_id, int cpu, int handled)
                         panic(PFX "pre-timeout");
         }
 
-        return NOTIFY_DONE;
+        return NOTIFY_STOP;
 }
 
-static struct nmi_handler ipmi_nmi_handler =
-{
-        .link     = LIST_HEAD_INIT(ipmi_nmi_handler.link),
-        .dev_name = "ipmi_watchdog",
-        .dev_id   = NULL,
-        .handler  = ipmi_nmi,
-        .priority = 0, /* Call us last. */
+static struct notifier_block ipmi_nmi_handler = {
+        .notifier_call = ipmi_nmi
 };
-int nmi_handler_registered;
 #endif
 
 static int wdog_reboot_handler(struct notifier_block *this,
@@ -1111,7 +1174,7 @@ static int preaction_op(const char *inval, char *outval)
                 preaction_val = WDOG_PRETIMEOUT_NONE;
         else if (strcmp(inval, "pre_smi") == 0)
                 preaction_val = WDOG_PRETIMEOUT_SMI;
-#ifdef HAVE_NMI_HANDLER
+#ifdef HAVE_DIE_NMI_POST
         else if (strcmp(inval, "pre_nmi") == 0)
                 preaction_val = WDOG_PRETIMEOUT_NMI;
 #endif
@@ -1145,7 +1208,7 @@ static int preop_op(const char *inval, char *outval)
 
 static void check_parms(void)
 {
-#ifdef HAVE_NMI_HANDLER
+#ifdef HAVE_DIE_NMI_POST
         int do_nmi = 0;
         int rv;
 
@@ -1158,20 +1221,9 @@ static void check_parms(void)
                         preop_op("preop_none", NULL);
                         do_nmi = 0;
                 }
-#ifdef CONFIG_X86_LOCAL_APIC
-                if (nmi_watchdog == NMI_IO_APIC) {
-                        printk(KERN_WARNING PFX "nmi_watchdog is set to IO APIC"
-                               " mode (value is %d), that is incompatible"
-                               " with using NMI in the IPMI watchdog."
-                               " Disabling IPMI nmi pretimeout.\n",
-                               nmi_watchdog);
-                        preaction_val = WDOG_PRETIMEOUT_NONE;
-                        do_nmi = 0;
-                }
-#endif
         }
         if (do_nmi && !nmi_handler_registered) {
-                rv = request_nmi(&ipmi_nmi_handler);
+                rv = register_die_notifier(&ipmi_nmi_handler);
                 if (rv) {
                         printk(KERN_WARNING PFX
                                "Can't register nmi handler\n");
@@ -1179,7 +1231,7 @@ static void check_parms(void)
                 } else
                         nmi_handler_registered = 1;
         } else if (!do_nmi && nmi_handler_registered) {
-                release_nmi(&ipmi_nmi_handler);
+                unregister_die_notifier(&ipmi_nmi_handler);
                 nmi_handler_registered = 0;
         }
 #endif
@@ -1215,9 +1267,9 @@ static int __init ipmi_wdog_init(void)
 
         rv = ipmi_smi_watcher_register(&smi_watcher);
         if (rv) {
-#ifdef HAVE_NMI_HANDLER
-                if (preaction_val == WDOG_PRETIMEOUT_NMI)
-                        release_nmi(&ipmi_nmi_handler);
+#ifdef HAVE_DIE_NMI_POST
+                if (nmi_handler_registered)
+                        unregister_die_notifier(&ipmi_nmi_handler);
 #endif
                 atomic_notifier_chain_unregister(&panic_notifier_list,
                                                  &wdog_panic_notifier);
@@ -1236,9 +1288,9 @@ static void __exit ipmi_wdog_exit(void)
         ipmi_smi_watcher_unregister(&smi_watcher);
         ipmi_unregister_watchdog(watchdog_ifnum);
 
-#ifdef HAVE_NMI_HANDLER
+#ifdef HAVE_DIE_NMI_POST
         if (nmi_handler_registered)
-                release_nmi(&ipmi_nmi_handler);
+                unregister_die_notifier(&ipmi_nmi_handler);
 #endif
 
         atomic_notifier_chain_unregister(&panic_notifier_list,
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index 43ab9edc76f5..761f77740d67 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -137,11 +137,10 @@
 #define InterruptTheCard(base) outw(0, (base) + 0xc)
 #define ClearInterrupt(base) inw((base) + 0x0a)
 
+#define pr_dbg(str...) pr_debug("ISICOM: " str)
 #ifdef DEBUG
-#define pr_dbg(str...) printk(KERN_DEBUG "ISICOM: " str)
 #define isicom_paranoia_check(a, b, c) __isicom_paranoia_check((a), (b), (c))
 #else
-#define pr_dbg(str...) do { } while (0)
 #define isicom_paranoia_check(a, b, c) 0
 #endif
 
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index c06e86ad1dab..1b094509b1d2 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -109,7 +109,7 @@ struct kbd_struct kbd_table[MAX_NR_CONSOLES];
 static struct kbd_struct *kbd = kbd_table;
 
 struct vt_spawn_console vt_spawn_con = {
-        .lock = SPIN_LOCK_UNLOCKED,
+        .lock = __SPIN_LOCK_UNLOCKED(vt_spawn_con.lock),
         .pid  = NULL,
         .sig  = 0,
 };
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index b51d08be0bcf..62051f8b0910 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -118,7 +118,6 @@
 #include <linux/kernel.h>
 #include <linux/major.h>
 #include <linux/sched.h>
-#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <linux/fcntl.h>
 #include <linux/delay.h>
@@ -139,9 +138,6 @@
 /* if you have more than 8 printers, remember to increase LP_NO */
 #define LP_NO 8
 
-/* ROUND_UP macro from fs/select.c */
-#define ROUND_UP(x,y) (((x)+(y)-1)/(y))
-
 static struct lp_struct lp_table[LP_NO];
 
 static unsigned int lp_count = 0;
@@ -652,7 +648,7 @@ static int lp_ioctl(struct inode *inode, struct file *file,
                             (par_timeout.tv_usec < 0)) {
                                 return -EINVAL;
                         }
-                        to_jiffies = ROUND_UP(par_timeout.tv_usec, 1000000/HZ);
+                        to_jiffies = DIV_ROUND_UP(par_timeout.tv_usec, 1000000/HZ);
                         to_jiffies += par_timeout.tv_sec * (long) HZ;
                         if (to_jiffies <= 0) {
                                 return -EINVAL;
@@ -803,7 +799,7 @@ static int lp_register(int nr, struct parport *port)
         if (reset)
                 lp_reset(nr);
 
-        class_device_create(lp_class, NULL, MKDEV(LP_MAJOR, nr), NULL,
+        class_device_create(lp_class, NULL, MKDEV(LP_MAJOR, nr), port->dev,
                                 "lp%d", nr);
 
         printk(KERN_INFO "lp%d: using %s (%s).\n", nr, port->name, 
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 5f066963f171..cc9a9d0df979 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -18,7 +18,6 @@
 #include <linux/raw.h>
 #include <linux/tty.h>
 #include <linux/capability.h>
-#include <linux/smp_lock.h>
 #include <linux/ptrace.h>
 #include <linux/device.h>
 #include <linux/highmem.h>
@@ -552,7 +551,7 @@ static ssize_t write_kmem(struct file * file, const char __user * buf,
         return virtr + wrote;
 }
 
-#if (defined(CONFIG_ISA) || defined(CONFIG_PCI)) && !defined(__mc68000__)
+#ifdef CONFIG_DEVPORT
 static ssize_t read_port(struct file * file, char __user * buf,
                          size_t count, loff_t *ppos)
 {
@@ -835,7 +834,7 @@ static const struct file_operations null_fops = {
         .splice_write   = splice_write_null,
 };
 
-#if (defined(CONFIG_ISA) || defined(CONFIG_PCI)) && !defined(__mc68000__)
+#ifdef CONFIG_DEVPORT
 static const struct file_operations port_fops = {
         .llseek         = memory_lseek,
         .read           = read_port,
@@ -913,7 +912,7 @@ static int memory_open(struct inode * inode, struct file * filp)
                 case 3:
                         filp->f_op = &null_fops;
                         break;
-#if (defined(CONFIG_ISA) || defined(CONFIG_PCI)) && !defined(__mc68000__)
+#ifdef CONFIG_DEVPORT
                 case 4:
                         filp->f_op = &port_fops;
                         break;
@@ -960,7 +959,7 @@ static const struct {
         {1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops},
         {2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
         {3, "null",    S_IRUGO | S_IWUGO,           &null_fops},
-#if (defined(CONFIG_ISA) || defined(CONFIG_PCI)) && !defined(__mc68000__)
+#ifdef CONFIG_DEVPORT
         {4, "port",    S_IRUSR | S_IWUSR | S_IRGRP, &port_fops},
 #endif
         {5, "zero",    S_IRUGO | S_IWUGO,           &zero_fops},
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 7e975f606924..4e6fb9651a16 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -41,6 +41,7 @@
 #include <linux/kernel.h>
 #include <linux/major.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/stat.h>
@@ -53,7 +54,7 @@
  * Head entry for the doubly linked miscdevice list
  */
 static LIST_HEAD(misc_list);
-static DECLARE_MUTEX(misc_sem);
+static DEFINE_MUTEX(misc_mtx);
 
 /*
  * Assigned numbers, used for dynamic minors
@@ -69,7 +70,7 @@ static void *misc_seq_start(struct seq_file *seq, loff_t *pos)
         struct miscdevice *p;
         loff_t off = 0;
 
-        down(&misc_sem);
+        mutex_lock(&misc_mtx);
         list_for_each_entry(p, &misc_list, list) {
                 if (*pos == off++) 
                         return p;
@@ -89,7 +90,7 @@ static void *misc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 
 static void misc_seq_stop(struct seq_file *seq, void *v)
 {
-        up(&misc_sem);
+        mutex_unlock(&misc_mtx);
 }
 
 static int misc_seq_show(struct seq_file *seq, void *v)
@@ -129,7 +130,7 @@ static int misc_open(struct inode * inode, struct file * file)
         int err = -ENODEV;
         const struct file_operations *old_fops, *new_fops = NULL;
         
-        down(&misc_sem);
+        mutex_lock(&misc_mtx);
         
         list_for_each_entry(c, &misc_list, list) {
                 if (c->minor == minor) {
@@ -139,9 +140,9 @@ static int misc_open(struct inode * inode, struct file * file)
         }
                 
         if (!new_fops) {
-                up(&misc_sem);
+                mutex_unlock(&misc_mtx);
                 request_module("char-major-%d-%d", MISC_MAJOR, minor);
-                down(&misc_sem);
+                mutex_lock(&misc_mtx);
 
                 list_for_each_entry(c, &misc_list, list) {
                         if (c->minor == minor) {
@@ -165,7 +166,7 @@ static int misc_open(struct inode * inode, struct file * file)
         }
         fops_put(old_fops);
 fail:
-        up(&misc_sem);
+        mutex_unlock(&misc_mtx);
         return err;
 }
 
@@ -201,10 +202,10 @@ int misc_register(struct miscdevice * misc)
 
         INIT_LIST_HEAD(&misc->list);
 
-        down(&misc_sem);
+        mutex_lock(&misc_mtx);
         list_for_each_entry(c, &misc_list, list) {
                 if (c->minor == misc->minor) {
-                        up(&misc_sem);
+                        mutex_unlock(&misc_mtx);
                         return -EBUSY;
                 }
         }
@@ -215,7 +216,7 @@ int misc_register(struct miscdevice * misc)
                         if ( (misc_minors[i>>3] & (1 << (i&7))) == 0)
                                 break;
                 if (i<0) {
-                        up(&misc_sem);
+                        mutex_unlock(&misc_mtx);
                         return -EBUSY;
                 }
                 misc->minor = i;
@@ -238,7 +239,7 @@ int misc_register(struct miscdevice * misc)
          */
         list_add(&misc->list, &misc_list);
  out:
-        up(&misc_sem);
+        mutex_unlock(&misc_mtx);
         return err;
 }
 
@@ -259,13 +260,13 @@ int misc_deregister(struct miscdevice * misc)
         if (list_empty(&misc->list))
                 return -EINVAL;
 
-        down(&misc_sem);
+        mutex_lock(&misc_mtx);
         list_del(&misc->list);
         device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));
         if (i < DYNAMIC_MINORS && i>0) {
                 misc_minors[i>>3] &= ~(1 << (misc->minor & 7));
         }
-        up(&misc_sem);
+        mutex_unlock(&misc_mtx);
         return 0;
 }
 
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
index 7dbaee8d9402..e0d35c20c04f 100644
--- a/drivers/char/moxa.c
+++ b/drivers/char/moxa.c
@@ -1582,7 +1582,7 @@ copy:
 
         if(copy_from_user(&dltmp, argp, sizeof(struct dl_str)))
                 return -EFAULT;
-        if(dltmp.cardno < 0 || dltmp.cardno >= MAX_BOARDS)
+        if(dltmp.cardno < 0 || dltmp.cardno >= MAX_BOARDS || dltmp.len < 0)
                 return -EINVAL;
 
         switch(cmd)
@@ -2529,6 +2529,8 @@ static int moxaloadbios(int cardno, unsigned char __user *tmp, int len)
         void __iomem *baseAddr;
         int i;
 
+        if(len < 0 || len > sizeof(moxaBuff))
+                return -EINVAL;
         if(copy_from_user(moxaBuff, tmp, len))
                 return -EFAULT;
         baseAddr = moxa_boards[cardno].basemem;
@@ -2576,7 +2578,7 @@ static int moxaload320b(int cardno, unsigned char __user *tmp, int len)
         void __iomem *baseAddr;
         int i;
 
-        if(len > sizeof(moxaBuff))
+        if(len < 0 || len > sizeof(moxaBuff))
                 return -EINVAL;
         if(copy_from_user(moxaBuff, tmp, len))
                 return -EFAULT;
@@ -2596,6 +2598,8 @@ static int moxaloadcode(int cardno, unsigned char __user *tmp, int len)
         void __iomem *baseAddr, *ofsAddr;
         int retval, port, i;
 
+        if(len < 0 || len > sizeof(moxaBuff))
+                return -EINVAL;
         if(copy_from_user(moxaBuff, tmp, len))
                 return -EFAULT;
         baseAddr = moxa_boards[cardno].basemem;
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 80a01150b86c..5953a45d7e96 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -54,7 +54,6 @@
 #include <linux/gfp.h>
 #include <linux/ioport.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
 
diff --git a/drivers/char/mxser_new.c b/drivers/char/mxser_new.c
index f7603b6aeb87..6cde448cd5b2 100644
--- a/drivers/char/mxser_new.c
+++ b/drivers/char/mxser_new.c
@@ -37,7 +37,6 @@
 #include <linux/gfp.h>
 #include <linux/ioport.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
 
diff --git a/drivers/char/n_r3964.c b/drivers/char/n_r3964.c
index 65f2d3a96b85..14557a4822c0 100644
--- a/drivers/char/n_r3964.c
+++ b/drivers/char/n_r3964.c
@@ -1088,13 +1088,13 @@ static ssize_t r3964_read(struct tty_struct *tty, struct file *file,
                         /* block until there is a message: */
                         add_wait_queue(&pInfo->read_wait, &wait);
 repeat:
-                        current->state = TASK_INTERRUPTIBLE;
+                        __set_current_state(TASK_INTERRUPTIBLE);
                         pMsg = remove_msg(pInfo, pClient);
                         if (!pMsg && !signal_pending(current)) {
                                 schedule();
                                 goto repeat;
                         }
-                        current->state = TASK_RUNNING;
+                        __set_current_state(TASK_RUNNING);
                         remove_wait_queue(&pInfo->read_wait, &wait);
                 }
 
diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index 4abd1eff61d6..84ac64fc48a1 100644
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -66,7 +66,6 @@
 #include <linux/poll.h>
 #include <linux/major.h>
 #include <linux/ppdev.h>
-#include <linux/smp_lock.h>
 #include <linux/device.h>
 #include <asm/uaccess.h>
 
@@ -752,7 +751,7 @@ static const struct file_operations pp_fops = {
 
 static void pp_attach(struct parport *port)
 {
-        device_create(ppdev_class, NULL, MKDEV(PP_MAJOR, port->number),
+        device_create(ppdev_class, port->dev, MKDEV(PP_MAJOR, port->number),
                         "parport%d", port->number);
 }
 
diff --git a/drivers/char/riscom8.c b/drivers/char/riscom8.c
index 70145254fb9d..3494e3fc44bf 100644
--- a/drivers/char/riscom8.c
+++ b/drivers/char/riscom8.c
@@ -980,7 +980,7 @@ static int block_til_ready(struct tty_struct *tty, struct file * filp,
                 }
                 schedule();
         }
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&port->open_wait, &wait);
         if (!tty_hung_up_p(filp))
                 port->count++;
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index 76357c855ce3..61a63da420c2 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -65,10 +65,6 @@
 
 /****** Kernel includes ******/
 
-#ifdef MODVERSIONS
-#include <config/modversions.h>
-#endif                          
-
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/major.h>
@@ -85,6 +81,7 @@
 #include <linux/string.h>
 #include <linux/fcntl.h>
 #include <linux/ptrace.h>
+#include <linux/mutex.h>
 #include <linux/ioport.h>
 #include <linux/delay.h>
 #include <linux/wait.h>
@@ -93,7 +90,6 @@
 #include <asm/atomic.h>
 #include <linux/bitops.h>
 #include <linux/spinlock.h>
-#include <asm/semaphore.h>
 #include <linux/init.h>
 
 /****** RocketPort includes ******/
@@ -702,7 +698,7 @@ static void init_r_port(int board, int aiop, int chan, struct pci_dev *pci_dev)
                 }
         }
         spin_lock_init(&info->slock);
-        sema_init(&info->write_sem, 1);
+        mutex_init(&info->write_mtx);
         rp_table[line] = info;
         if (pci_dev)
                 tty_register_device(rocket_driver, line, &pci_dev->dev);
@@ -947,7 +943,7 @@ static int block_til_ready(struct tty_struct *tty, struct file *filp,
 #endif
                 schedule();     /*  Don't hold spinlock here, will hang PC */
         }
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&info->open_wait, &wait);
 
         spin_lock_irqsave(&info->slock, flags);
@@ -1602,7 +1598,7 @@ static void rp_wait_until_sent(struct tty_struct *tty, int timeout)
                 if (signal_pending(current))
                         break;
         }
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
         printk(KERN_INFO "txcnt = %d (jiff=%lu)...done\n", txcnt, jiffies);
 #endif
@@ -1661,8 +1657,11 @@ static void rp_put_char(struct tty_struct *tty, unsigned char ch)
         if (rocket_paranoia_check(info, "rp_put_char"))
                 return;
 
-        /*  Grab the port write semaphore, locking out other processes that try to write to this port */
-        down(&info->write_sem);
+        /*
+         * Grab the port write mutex, locking out other processes that try to
+         * write to this port
+         */
+        mutex_lock(&info->write_mtx);
 
 #ifdef ROCKET_DEBUG_WRITE
         printk(KERN_INFO "rp_put_char %c...", ch);
@@ -1684,12 +1683,12 @@ static void rp_put_char(struct tty_struct *tty, unsigned char ch)
                 info->xmit_fifo_room--;
         }
         spin_unlock_irqrestore(&info->slock, flags);
-        up(&info->write_sem);
+        mutex_unlock(&info->write_mtx);
 }
 
 /*
  *  Exception handler - write routine, called when user app writes to the device.
- *  A per port write semaphore is used to protect from another process writing to
+ *  A per port write mutex is used to protect from another process writing to
  *  this port at the same time.  This other process could be running on the other CPU
  *  or get control of the CPU if the copy_from_user() blocks due to a page fault (swapped out). 
  *  Spinlocks protect the info xmit members.
@@ -1706,7 +1705,7 @@ static int rp_write(struct tty_struct *tty,
         if (count <= 0 || rocket_paranoia_check(info, "rp_write"))
                 return 0;
 
-        down_interruptible(&info->write_sem);
+        mutex_lock_interruptible(&info->write_mtx);
 
 #ifdef ROCKET_DEBUG_WRITE
         printk(KERN_INFO "rp_write %d chars...", count);
@@ -1777,7 +1776,7 @@ end:
                 wake_up_interruptible(&tty->poll_wait);
 #endif
         }
-        up(&info->write_sem);
+        mutex_unlock(&info->write_mtx);
         return retval;
 }
 
@@ -1852,6 +1851,12 @@ static void rp_flush_buffer(struct tty_struct *tty)
 
 #ifdef CONFIG_PCI
 
+static struct pci_device_id __devinitdata rocket_pci_ids[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_ANY_ID) },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, rocket_pci_ids);
+
 /*
  *  Called when a PCI card is found.  Retrieves and stores model information,
  *  init's aiopic and serial port hardware.
diff --git a/drivers/char/rocket_int.h b/drivers/char/rocket_int.h
index 3a8bcc85bc14..89b4d7b10d12 100644
--- a/drivers/char/rocket_int.h
+++ b/drivers/char/rocket_int.h
@@ -15,6 +15,8 @@
 #define ROCKET_TYPE_MODEMIII    3
 #define ROCKET_TYPE_PC104       4
 
+#include <linux/mutex.h>
+
 #include <asm/io.h>
 #include <asm/byteorder.h>
 
@@ -1171,7 +1173,7 @@ struct r_port {
         struct wait_queue *close_wait;
 #endif
         spinlock_t slock;
-        struct semaphore write_sem;
+        struct mutex write_mtx;
 };
 
 #define RPORT_MAGIC 0x525001
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index c7dac9b13351..20380a2c4dee 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -388,7 +388,7 @@ static ssize_t rtc_read(struct file *file, char __user *buf,
         if (!retval)
                 retval = count;
  out:
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&rtc_wait, &wait);
 
         return retval;
diff --git a/drivers/char/selection.c b/drivers/char/selection.c
index 74cff839c857..a69f094d1ed3 100644
--- a/drivers/char/selection.c
+++ b/drivers/char/selection.c
@@ -299,7 +299,7 @@ int paste_selection(struct tty_struct *tty)
                 pasted += count;
         }
         remove_wait_queue(&vc->paste_wait, &wait);
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
 
         tty_ldisc_deref(ld);
         return 0;
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index 5fd314adc1f2..c585b4738f86 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -1892,7 +1892,7 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
 #endif
                     schedule();
         }
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&info->open_wait, &wait);
         if (!tty_hung_up_p(filp)) {
                 info->count++;
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index ce4db6f52362..f02a0795983f 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -4010,8 +4010,13 @@ static int mgsl_alloc_intermediate_txbuffer_memory(struct mgsl_struct *info)
         for ( i=0; i<info->num_tx_holding_buffers; ++i) {
                 info->tx_holding_buffers[i].buffer =
                         kmalloc(info->max_frame_size, GFP_KERNEL);
-                if ( info->tx_holding_buffers[i].buffer == NULL )
+                if (info->tx_holding_buffers[i].buffer == NULL) {
+                        for (--i; i >= 0; i--) {
+                                kfree(info->tx_holding_buffers[i].buffer);
+                                info->tx_holding_buffers[i].buffer = NULL;
+                        }
                         return -ENOMEM;
+                }
         }
 
         return 0;
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 0a367cd4121f..2a7736b5f2f7 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -3415,6 +3415,9 @@ static void device_init(int adapter_num, struct pci_dev *pdev)
                         }
                 }
         }
+
+        for (i=0; i < port_count; ++i)
+                tty_register_device(serial_driver, port_array[i]->line, &(port_array[i]->pdev->dev));
 }
 
 static int __devinit init_one(struct pci_dev *dev,
@@ -3466,6 +3469,8 @@ static void slgt_cleanup(void)
         printk("unload %s %s\n", driver_name, driver_version);
 
         if (serial_driver) {
+                for (info=slgt_device_list ; info != NULL ; info=info->next_device)
+                        tty_unregister_device(serial_driver, info->line);
                 if ((rc = tty_unregister_driver(serial_driver)))
                         DBGERR(("tty_unregister_driver error=%d\n", rc));
                 put_tty_driver(serial_driver);
@@ -3506,23 +3511,10 @@ static int __init slgt_init(void)
 
         printk("%s %s\n", driver_name, driver_version);
 
-        slgt_device_count = 0;
-        if ((rc = pci_register_driver(&pci_driver)) < 0) {
-                printk("%s pci_register_driver error=%d\n", driver_name, rc);
-                return rc;
-        }
-        pci_registered = 1;
-
-        if (!slgt_device_list) {
-                printk("%s no devices found\n",driver_name);
-                pci_unregister_driver(&pci_driver);
-                return -ENODEV;
-        }
-
         serial_driver = alloc_tty_driver(MAX_DEVICES);
         if (!serial_driver) {
-                rc = -ENOMEM;
-                goto error;
+                printk("%s can't allocate tty driver\n", driver_name);
+                return -ENOMEM;
         }
 
         /* Initialize the tty_driver structure */
@@ -3539,7 +3531,7 @@ static int __init slgt_init(void)
                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
         serial_driver->init_termios.c_ispeed = 9600;
         serial_driver->init_termios.c_ospeed = 9600;
-        serial_driver->flags = TTY_DRIVER_REAL_RAW;
+        serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
         tty_set_operations(serial_driver, &ops);
         if ((rc = tty_register_driver(serial_driver)) < 0) {
                 DBGERR(("%s can't register serial driver\n", driver_name));
@@ -3552,6 +3544,16 @@ static int __init slgt_init(void)
                 driver_name, driver_version,
                 serial_driver->major);
 
+        slgt_device_count = 0;
+        if ((rc = pci_register_driver(&pci_driver)) < 0) {
+                printk("%s pci_register_driver error=%d\n", driver_name, rc);
+                goto error;
+        }
+        pci_registered = 1;
+
+        if (!slgt_device_list)
+                printk("%s no devices found\n",driver_name);
+
         return 0;
 
 error:
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 1d8c4ae61551..39cc318011ea 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -24,7 +24,6 @@
 #include <linux/sysrq.h>
 #include <linux/kbd_kern.h>
 #include <linux/quotaops.h>
-#include <linux/smp_lock.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/suspend.h>
diff --git a/drivers/char/tipar.c b/drivers/char/tipar.c
index 47fb20f69695..35b40b996534 100644
--- a/drivers/char/tipar.c
+++ b/drivers/char/tipar.c
@@ -442,7 +442,7 @@ tipar_register(int nr, struct parport *port)
         }
 
         class_device_create(tipar_class, NULL, MKDEV(TIPAR_MAJOR,
-                        TIPAR_MINOR + nr), NULL, "par%d", nr);
+                        TIPAR_MINOR + nr), port->dev, "par%d", nr);
 
         /* Display informations */
         pr_info("tipar%d: using %s (%s)\n", nr, port->name, (port->irq ==
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index e5a254a434f8..9bb542913b86 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -24,7 +24,9 @@
  */
 
 #include <linux/poll.h>
+#include <linux/mutex.h>
 #include <linux/spinlock.h>
+
 #include "tpm.h"
 
 enum tpm_const {
@@ -328,10 +330,10 @@ static void timeout_work(struct work_struct *work)
 {
         struct tpm_chip *chip = container_of(work, struct tpm_chip, work);
 
-        down(&chip->buffer_mutex);
+        mutex_lock(&chip->buffer_mutex);
         atomic_set(&chip->data_pending, 0);
         memset(chip->data_buffer, 0, TPM_BUFSIZE);
-        up(&chip->buffer_mutex);
+        mutex_unlock(&chip->buffer_mutex);
 }
 
 /*
@@ -380,7 +382,7 @@ static ssize_t tpm_transmit(struct tpm_chip *chip, const char *buf,
                 return -E2BIG;
         }
 
-        down(&chip->tpm_mutex);
+        mutex_lock(&chip->tpm_mutex);
 
         if ((rc = chip->vendor.send(chip, (u8 *) buf, count)) < 0) {
                 dev_err(chip->dev,
@@ -419,7 +421,7 @@ out_recv:
                 dev_err(chip->dev,
                         "tpm_transmit: tpm_recv: error %zd\n", rc);
 out:
-        up(&chip->tpm_mutex);
+        mutex_unlock(&chip->tpm_mutex);
         return rc;
 }
 
@@ -942,12 +944,12 @@ int tpm_release(struct inode *inode, struct file *file)
 {
         struct tpm_chip *chip = file->private_data;
 
+        flush_scheduled_work();
         spin_lock(&driver_lock);
         file->private_data = NULL;
-        chip->num_opens--;
         del_singleshot_timer_sync(&chip->user_read_timer);
-        flush_scheduled_work();
         atomic_set(&chip->data_pending, 0);
+        chip->num_opens--;
         put_device(chip->dev);
         kfree(chip->data_buffer);
         spin_unlock(&driver_lock);
@@ -966,14 +968,14 @@ ssize_t tpm_write(struct file *file, const char __user *buf,
         while (atomic_read(&chip->data_pending) != 0)
                 msleep(TPM_TIMEOUT);
 
-        down(&chip->buffer_mutex);
+        mutex_lock(&chip->buffer_mutex);
 
         if (in_size > TPM_BUFSIZE)
                 in_size = TPM_BUFSIZE;
 
         if (copy_from_user
             (chip->data_buffer, (void __user *) buf, in_size)) {
-                up(&chip->buffer_mutex);
+                mutex_unlock(&chip->buffer_mutex);
                 return -EFAULT;
         }
 
@@ -981,7 +983,7 @@ ssize_t tpm_write(struct file *file, const char __user *buf,
         out_size = tpm_transmit(chip, chip->data_buffer, TPM_BUFSIZE);
 
         atomic_set(&chip->data_pending, out_size);
-        up(&chip->buffer_mutex);
+        mutex_unlock(&chip->buffer_mutex);
 
         /* Set a timeout by which the reader must come claim the result */
         mod_timer(&chip->user_read_timer, jiffies + (60 * HZ));
@@ -1004,10 +1006,10 @@ ssize_t tpm_read(struct file *file, char __user *buf,
                 if (size < ret_size)
                         ret_size = size;
 
-                down(&chip->buffer_mutex);
+                mutex_lock(&chip->buffer_mutex);
                 if (copy_to_user(buf, chip->data_buffer, ret_size))
                         ret_size = -EFAULT;
-                up(&chip->buffer_mutex);
+                mutex_unlock(&chip->buffer_mutex);
         }
 
         return ret_size;
@@ -1097,11 +1099,16 @@ struct tpm_chip *tpm_register_hardware(struct device *dev, const struct tpm_vend
 
         /* Driver specific per-device data */
         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
-        if (chip == NULL)
+        devname = kmalloc(DEVNAME_SIZE, GFP_KERNEL);
+
+        if (chip == NULL || devname == NULL) {
+                kfree(chip);
+                kfree(devname);
                 return NULL;
+        }
 
-        init_MUTEX(&chip->buffer_mutex);
-        init_MUTEX(&chip->tpm_mutex);
+        mutex_init(&chip->buffer_mutex);
+        mutex_init(&chip->tpm_mutex);
         INIT_LIST_HEAD(&chip->list);
 
         INIT_WORK(&chip->work, timeout_work);
@@ -1124,7 +1131,6 @@ struct tpm_chip *tpm_register_hardware(struct device *dev, const struct tpm_vend
 
         set_bit(chip->dev_num, dev_mask);
 
-        devname = kmalloc(DEVNAME_SIZE, GFP_KERNEL);
         scnprintf(devname, DEVNAME_SIZE, "%s%d", "tpm", chip->dev_num);
         chip->vendor.miscdev.name = devname;
 
diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h
index 9f273f032b0f..b2e2b002a1bb 100644
--- a/drivers/char/tpm/tpm.h
+++ b/drivers/char/tpm/tpm.h
@@ -21,6 +21,7 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/fs.h>
+#include <linux/mutex.h>
 #include <linux/sched.h>
 #include <linux/miscdevice.h>
 #include <linux/platform_device.h>
@@ -94,11 +95,11 @@ struct tpm_chip {
         /* Data passed to and from the tpm via the read/write calls */
         u8 *data_buffer;
         atomic_t data_pending;
-        struct semaphore buffer_mutex;
+        struct mutex buffer_mutex;
 
         struct timer_list user_read_timer;      /* user needs to claim result */
         struct work_struct work;
-        struct semaphore tpm_mutex;     /* tpm is processing */
+        struct mutex tpm_mutex; /* tpm is processing */
 
         struct tpm_vendor_specific vendor;
 
diff --git a/drivers/char/tpm/tpm_infineon.c b/drivers/char/tpm/tpm_infineon.c
index 1353b5a6bae8..967002a5a1e5 100644
--- a/drivers/char/tpm/tpm_infineon.c
+++ b/drivers/char/tpm/tpm_infineon.c
@@ -30,12 +30,60 @@
 #define TPM_MAX_TRIES           5000
 #define TPM_INFINEON_DEV_VEN_VALUE      0x15D1
 
-/* These values will be filled after PnP-call */
-static int TPM_INF_DATA;
-static int TPM_INF_ADDR;
-static int TPM_INF_BASE;
-static int TPM_INF_ADDR_LEN;
-static int TPM_INF_PORT_LEN;
+#define TPM_INF_IO_PORT         0x0
+#define TPM_INF_IO_MEM          0x1
+
+#define TPM_INF_ADDR            0x0
+#define TPM_INF_DATA            0x1
+
+struct tpm_inf_dev {
+        int iotype;
+
+        void __iomem *mem_base;         /* MMIO ioremap'd addr */
+        unsigned long map_base;         /* phys MMIO base */
+        unsigned long map_size;         /* MMIO region size */
+        unsigned int index_off;         /* index register offset */
+
+        unsigned int data_regs;         /* Data registers */
+        unsigned int data_size;
+
+        unsigned int config_port;       /* IO Port config index reg */
+        unsigned int config_size;
+};
+
+static struct tpm_inf_dev tpm_dev;
+
+static inline void tpm_data_out(unsigned char data, unsigned char offset)
+{
+        if (tpm_dev.iotype == TPM_INF_IO_PORT)
+                outb(data, tpm_dev.data_regs + offset);
+        else
+                writeb(data, tpm_dev.mem_base + tpm_dev.data_regs + offset);
+}
+
+static inline unsigned char tpm_data_in(unsigned char offset)
+{
+        if (tpm_dev.iotype == TPM_INF_IO_PORT)
+                return inb(tpm_dev.data_regs + offset);
+        else
+                return readb(tpm_dev.mem_base + tpm_dev.data_regs + offset);
+}
+
+static inline void tpm_config_out(unsigned char data, unsigned char offset)
+{
+        if (tpm_dev.iotype == TPM_INF_IO_PORT)
+                outb(data, tpm_dev.config_port + offset);
+        else
+                writeb(data, tpm_dev.mem_base + tpm_dev.index_off + offset);
+}
+
+static inline unsigned char tpm_config_in(unsigned char offset)
+{
+        if (tpm_dev.iotype == TPM_INF_IO_PORT)
+                return inb(tpm_dev.config_port + offset);
+        else
+                return readb(tpm_dev.mem_base + tpm_dev.index_off + offset);
+}
 
 /* TPM header definitions */
 enum infineon_tpm_header {
@@ -105,7 +153,7 @@ static int empty_fifo(struct tpm_chip *chip, int clear_wrfifo)
 
         if (clear_wrfifo) {
                 for (i = 0; i < 4096; i++) {
-                        status = inb(chip->vendor.base + WRFIFO);
+                        status = tpm_data_in(WRFIFO);
                         if (status == 0xff) {
                                 if (check == 5)
                                         break;
@@ -125,8 +173,8 @@ static int empty_fifo(struct tpm_chip *chip, int clear_wrfifo)
          */
         i = 0;
         do {
-                status = inb(chip->vendor.base + RDFIFO);
-                status = inb(chip->vendor.base + STAT);
+                status = tpm_data_in(RDFIFO);
+                status = tpm_data_in(STAT);
                 i++;
                 if (i == TPM_MAX_TRIES)
                         return -EIO;
@@ -139,7 +187,7 @@ static int wait(struct tpm_chip *chip, int wait_for_bit)
         int status;
         int i;
         for (i = 0; i < TPM_MAX_TRIES; i++) {
-                status = inb(chip->vendor.base + STAT);
+                status = tpm_data_in(STAT);
                 /* check the status-register if wait_for_bit is set */
                 if (status & 1 << wait_for_bit)
                         break;
@@ -158,7 +206,7 @@ static int wait(struct tpm_chip *chip, int wait_for_bit)
 static void wait_and_send(struct tpm_chip *chip, u8 sendbyte)
 {
         wait(chip, STAT_XFE);
-        outb(sendbyte, chip->vendor.base + WRFIFO);
+        tpm_data_out(sendbyte, WRFIFO);
 }
 
     /* Note: WTX means Waiting-Time-Extension. Whenever the TPM needs more
@@ -205,7 +253,7 @@ recv_begin:
                 ret = wait(chip, STAT_RDA);
                 if (ret)
                         return -EIO;
-                buf[i] = inb(chip->vendor.base + RDFIFO);
+                buf[i] = tpm_data_in(RDFIFO);
         }
 
         if (buf[0] != TPM_VL_VER) {
@@ -220,7 +268,7 @@ recv_begin:
 
                 for (i = 0; i < size; i++) {
                         wait(chip, STAT_RDA);
-                        buf[i] = inb(chip->vendor.base + RDFIFO);
+                        buf[i] = tpm_data_in(RDFIFO);
                 }
 
                 if ((size == 0x6D00) && (buf[1] == 0x80)) {
@@ -269,7 +317,7 @@ static int tpm_inf_send(struct tpm_chip *chip, u8 * buf, size_t count)
         u8 count_high, count_low, count_4, count_3, count_2, count_1;
 
         /* Disabling Reset, LP and IRQC */
-        outb(RESET_LP_IRQC_DISABLE, chip->vendor.base + CMD);
+        tpm_data_out(RESET_LP_IRQC_DISABLE, CMD);
 
         ret = empty_fifo(chip, 1);
         if (ret) {
@@ -320,7 +368,7 @@ static void tpm_inf_cancel(struct tpm_chip *chip)
 
 static u8 tpm_inf_status(struct tpm_chip *chip)
 {
-        return inb(chip->vendor.base + STAT);
+        return tpm_data_in(STAT);
 }
 
 static DEVICE_ATTR(pubek, S_IRUGO, tpm_show_pubek, NULL);
@@ -381,51 +429,88 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
         /* read IO-ports through PnP */
         if (pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) &&
             !(pnp_port_flags(dev, 0) & IORESOURCE_DISABLED)) {
-                TPM_INF_ADDR = pnp_port_start(dev, 0);
-                TPM_INF_ADDR_LEN = pnp_port_len(dev, 0);
-                TPM_INF_DATA = (TPM_INF_ADDR + 1);
-                TPM_INF_BASE = pnp_port_start(dev, 1);
-                TPM_INF_PORT_LEN = pnp_port_len(dev, 1);
-                if ((TPM_INF_PORT_LEN < 4) || (TPM_INF_ADDR_LEN < 2)) {
+
+                tpm_dev.iotype = TPM_INF_IO_PORT;
+
+                tpm_dev.config_port = pnp_port_start(dev, 0);
+                tpm_dev.config_size = pnp_port_len(dev, 0);
+                tpm_dev.data_regs = pnp_port_start(dev, 1);
+                tpm_dev.data_size = pnp_port_len(dev, 1);
+                if ((tpm_dev.data_size < 4) || (tpm_dev.config_size < 2)) {
                         rc = -EINVAL;
                         goto err_last;
                 }
                 dev_info(&dev->dev, "Found %s with ID %s\n",
                          dev->name, dev_id->id);
-                if (!((TPM_INF_BASE >> 8) & 0xff)) {
+                if (!((tpm_dev.data_regs >> 8) & 0xff)) {
                         rc = -EINVAL;
                         goto err_last;
                 }
                 /* publish my base address and request region */
-                if (request_region
-                    (TPM_INF_BASE, TPM_INF_PORT_LEN, "tpm_infineon0") == NULL) {
+                if (request_region(tpm_dev.data_regs, tpm_dev.data_size,
+                                   "tpm_infineon0") == NULL) {
                         rc = -EINVAL;
                         goto err_last;
                 }
-                if (request_region
-                    (TPM_INF_ADDR, TPM_INF_ADDR_LEN, "tpm_infineon0") == NULL) {
+                if (request_region(tpm_dev.config_port, tpm_dev.config_size,
+                                   "tpm_infineon0") == NULL) {
+                        release_region(tpm_dev.data_regs, tpm_dev.data_size);
                         rc = -EINVAL;
                         goto err_last;
                 }
+        } else if (pnp_mem_valid(dev, 0) &&
+                   !(pnp_mem_flags(dev, 0) & IORESOURCE_DISABLED)) {
+
+                tpm_dev.iotype = TPM_INF_IO_MEM;
+
+                tpm_dev.map_base = pnp_mem_start(dev, 0);
+                tpm_dev.map_size = pnp_mem_len(dev, 0);
+
+                dev_info(&dev->dev, "Found %s with ID %s\n",
+                         dev->name, dev_id->id);
+
+                /* publish my base address and request region */
+                if (request_mem_region(tpm_dev.map_base, tpm_dev.map_size,
+                                       "tpm_infineon0") == NULL) {
+                        rc = -EINVAL;
+                        goto err_last;
+                }
+
+                tpm_dev.mem_base = ioremap(tpm_dev.map_base, tpm_dev.map_size);
+                if (tpm_dev.mem_base == NULL) {
+                        release_mem_region(tpm_dev.map_base, tpm_dev.map_size);
+                        rc = -EINVAL;
+                        goto err_last;
+                }
+
+                /*
+                 * The only known MMIO based Infineon TPM system provides
+                 * a single large mem region with the device config
+                 * registers at the default TPM_ADDR.  The data registers
+                 * seem like they could be placed anywhere within the MMIO
+                 * region, but lets just put them at zero offset.
+                 */
+                tpm_dev.index_off = TPM_ADDR;
+                tpm_dev.data_regs = 0x0;
         } else {
                 rc = -EINVAL;
                 goto err_last;
         }
 
         /* query chip for its vendor, its version number a.s.o. */
-        outb(ENABLE_REGISTER_PAIR, TPM_INF_ADDR);
-        outb(IDVENL, TPM_INF_ADDR);
-        vendorid[1] = inb(TPM_INF_DATA);
-        outb(IDVENH, TPM_INF_ADDR);
-        vendorid[0] = inb(TPM_INF_DATA);
-        outb(IDPDL, TPM_INF_ADDR);
-        productid[1] = inb(TPM_INF_DATA);
-        outb(IDPDH, TPM_INF_ADDR);
-        productid[0] = inb(TPM_INF_DATA);
-        outb(CHIP_ID1, TPM_INF_ADDR);
-        version[1] = inb(TPM_INF_DATA);
-        outb(CHIP_ID2, TPM_INF_ADDR);
-        version[0] = inb(TPM_INF_DATA);
+        tpm_config_out(ENABLE_REGISTER_PAIR, TPM_INF_ADDR);
+        tpm_config_out(IDVENL, TPM_INF_ADDR);
+        vendorid[1] = tpm_config_in(TPM_INF_DATA);
+        tpm_config_out(IDVENH, TPM_INF_ADDR);
+        vendorid[0] = tpm_config_in(TPM_INF_DATA);
+        tpm_config_out(IDPDL, TPM_INF_ADDR);
+        productid[1] = tpm_config_in(TPM_INF_DATA);
+        tpm_config_out(IDPDH, TPM_INF_ADDR);
+        productid[0] = tpm_config_in(TPM_INF_DATA);
+        tpm_config_out(CHIP_ID1, TPM_INF_ADDR);
+        version[1] = tpm_config_in(TPM_INF_DATA);
+        tpm_config_out(CHIP_ID2, TPM_INF_ADDR);
+        version[0] = tpm_config_in(TPM_INF_DATA);
 
         switch ((productid[0] << 8) | productid[1]) {
         case 6:
@@ -442,51 +527,54 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
         if ((vendorid[0] << 8 | vendorid[1]) == (TPM_INFINEON_DEV_VEN_VALUE)) {
 
                 /* configure TPM with IO-ports */
-                outb(IOLIMH, TPM_INF_ADDR);
-                outb(((TPM_INF_BASE >> 8) & 0xff), TPM_INF_DATA);
-                outb(IOLIML, TPM_INF_ADDR);
-                outb((TPM_INF_BASE & 0xff), TPM_INF_DATA);
+                tpm_config_out(IOLIMH, TPM_INF_ADDR);
+                tpm_config_out((tpm_dev.data_regs >> 8) & 0xff, TPM_INF_DATA);
+                tpm_config_out(IOLIML, TPM_INF_ADDR);
+                tpm_config_out((tpm_dev.data_regs & 0xff), TPM_INF_DATA);
 
                 /* control if IO-ports are set correctly */
-                outb(IOLIMH, TPM_INF_ADDR);
-                ioh = inb(TPM_INF_DATA);
-                outb(IOLIML, TPM_INF_ADDR);
-                iol = inb(TPM_INF_DATA);
+                tpm_config_out(IOLIMH, TPM_INF_ADDR);
+                ioh = tpm_config_in(TPM_INF_DATA);
+                tpm_config_out(IOLIML, TPM_INF_ADDR);
+                iol = tpm_config_in(TPM_INF_DATA);
 
-                if ((ioh << 8 | iol) != TPM_INF_BASE) {
+                if ((ioh << 8 | iol) != tpm_dev.data_regs) {
                         dev_err(&dev->dev,
-                                "Could not set IO-ports to 0x%x\n",
-                                TPM_INF_BASE);
+                                "Could not set IO-data registers to 0x%x\n",
+                                tpm_dev.data_regs);
                         rc = -EIO;
                         goto err_release_region;
                 }
 
                 /* activate register */
-                outb(TPM_DAR, TPM_INF_ADDR);
-                outb(0x01, TPM_INF_DATA);
-                outb(DISABLE_REGISTER_PAIR, TPM_INF_ADDR);
+                tpm_config_out(TPM_DAR, TPM_INF_ADDR);
+                tpm_config_out(0x01, TPM_INF_DATA);
+                tpm_config_out(DISABLE_REGISTER_PAIR, TPM_INF_ADDR);
 
                 /* disable RESET, LP and IRQC */
-                outb(RESET_LP_IRQC_DISABLE, TPM_INF_BASE + CMD);
+                tpm_data_out(RESET_LP_IRQC_DISABLE, CMD);
 
                 /* Finally, we're done, print some infos */
                 dev_info(&dev->dev, "TPM found: "
-                         "config base 0x%x, "
-                         "io base 0x%x, "
+                         "config base 0x%lx, "
+                         "data base 0x%lx, "
                          "chip version 0x%02x%02x, "
                          "vendor id 0x%x%x (Infineon), "
                          "product id 0x%02x%02x"
                          "%s\n",
-                         TPM_INF_ADDR,
-                         TPM_INF_BASE,
+                         tpm_dev.iotype == TPM_INF_IO_PORT ?
+                                tpm_dev.config_port :
+                                tpm_dev.map_base + tpm_dev.index_off,
+                         tpm_dev.iotype == TPM_INF_IO_PORT ?
+                                tpm_dev.data_regs :
+                                tpm_dev.map_base + tpm_dev.data_regs,
                          version[0], version[1],
                          vendorid[0], vendorid[1],
                          productid[0], productid[1], chipname);
 
-                if (!(chip = tpm_register_hardware(&dev->dev, &tpm_inf))) {
+                if (!(chip = tpm_register_hardware(&dev->dev, &tpm_inf)))
                         goto err_release_region;
-                }
-                chip->vendor.base = TPM_INF_BASE;
+
                 return 0;
         } else {
                 rc = -ENODEV;
@@ -494,8 +582,13 @@ static int __devinit tpm_inf_pnp_probe(struct pnp_dev *dev,
         }
 
 err_release_region:
-        release_region(TPM_INF_BASE, TPM_INF_PORT_LEN);
-        release_region(TPM_INF_ADDR, TPM_INF_ADDR_LEN);
+        if (tpm_dev.iotype == TPM_INF_IO_PORT) {
+                release_region(tpm_dev.data_regs, tpm_dev.data_size);
+                release_region(tpm_dev.config_port, tpm_dev.config_size);
+        } else {
+                iounmap(tpm_dev.mem_base);
+                release_mem_region(tpm_dev.map_base, tpm_dev.map_size);
+        }
 
 err_last:
         return rc;
@@ -506,8 +599,14 @@ static __devexit void tpm_inf_pnp_remove(struct pnp_dev *dev)
         struct tpm_chip *chip = pnp_get_drvdata(dev);
 
         if (chip) {
-                release_region(TPM_INF_BASE, TPM_INF_PORT_LEN);
-                release_region(TPM_INF_ADDR, TPM_INF_ADDR_LEN);
+                if (tpm_dev.iotype == TPM_INF_IO_PORT) {
+                        release_region(tpm_dev.data_regs, tpm_dev.data_size);
+                        release_region(tpm_dev.config_port,
+                                       tpm_dev.config_size);
+                } else {
+                        iounmap(tpm_dev.mem_base);
+                        release_mem_region(tpm_dev.map_base, tpm_dev.map_size);
+                }
                 tpm_remove_hardware(chip->dev);
         }
 }
@@ -539,5 +638,5 @@ module_exit(cleanup_inf);
 
 MODULE_AUTHOR("Marcel Selhorst <selhorst@crypto.rub.de>");
 MODULE_DESCRIPTION("Driver for Infineon TPM SLD 9630 TT 1.1 / SLB 9635 TT 1.2");
-MODULE_VERSION("1.8");
+MODULE_VERSION("1.9");
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 389da364e6b6..7710a6a77d97 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -141,8 +141,6 @@ static DECLARE_MUTEX(allocated_ptys_lock);
 static int ptmx_open(struct inode *, struct file *);
 #endif
 
-extern void disable_early_printk(void);
-
 static void initialize_tty_struct(struct tty_struct *tty);
 
 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
@@ -155,8 +153,8 @@ int tty_ioctl(struct inode * inode, struct file * file,
               unsigned int cmd, unsigned long arg);
 static int tty_fasync(int fd, struct file * filp, int on);
 static void release_tty(struct tty_struct *tty, int idx);
-static struct pid *__proc_set_tty(struct task_struct *tsk,
-                                struct tty_struct *tty);
+static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
+static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
 
 /**
  *      alloc_tty_struct        -       allocate a tty object
@@ -1534,10 +1532,9 @@ void disassociate_ctty(int on_exit)
         }
 
         spin_lock_irq(&current->sighand->siglock);
-        tty_pgrp = current->signal->tty_old_pgrp;
+        put_pid(current->signal->tty_old_pgrp);
         current->signal->tty_old_pgrp = NULL;
         spin_unlock_irq(&current->sighand->siglock);
-        put_pid(tty_pgrp);
 
         mutex_lock(&tty_mutex);
         /* It is possible that do_tty_hangup has free'd this tty */
@@ -1562,6 +1559,18 @@ void disassociate_ctty(int on_exit)
         unlock_kernel();
 }
 
+/**
+ *
+ *      no_tty  - Ensure the current process does not have a controlling tty
+ */
+void no_tty(void)
+{
+        struct task_struct *tsk = current;
+        if (tsk->signal->leader)
+                disassociate_ctty(0);
+        proc_clear_tty(tsk);
+}
+
 
 /**
  *      stop_tty        -       propogate flow control
@@ -2508,7 +2517,6 @@ static int tty_open(struct inode * inode, struct file * filp)
         int index;
         dev_t device = inode->i_rdev;
         unsigned short saved_flags = filp->f_flags;
-        struct pid *old_pgrp;
 
         nonseekable_open(inode, filp);
         
@@ -2602,17 +2610,15 @@ got_driver:
                 goto retry_open;
         }
 
-        old_pgrp = NULL;
         mutex_lock(&tty_mutex);
         spin_lock_irq(&current->sighand->siglock);
         if (!noctty &&
             current->signal->leader &&
             !current->signal->tty &&
             tty->session == NULL)
-                old_pgrp = __proc_set_tty(current, tty);
+                __proc_set_tty(current, tty);
         spin_unlock_irq(&current->sighand->siglock);
         mutex_unlock(&tty_mutex);
-        put_pid(old_pgrp);
         return 0;
 }
 
@@ -3287,9 +3293,7 @@ int tty_ioctl(struct inode * inode, struct file * file,
                 case TIOCNOTTY:
                         if (current->signal->tty != tty)
                                 return -ENOTTY;
-                        if (current->signal->leader)
-                                disassociate_ctty(0);
-                        proc_clear_tty(current);
+                        no_tty();
                         return 0;
                 case TIOCSCTTY:
                         return tiocsctty(tty, arg);
@@ -3766,7 +3770,9 @@ int tty_register_driver(struct tty_driver *driver)
         if (!driver->put_char)
                 driver->put_char = tty_default_put_char;
         
+        mutex_lock(&tty_mutex);
         list_add(&driver->tty_drivers, &tty_drivers);
+        mutex_unlock(&tty_mutex);
         
         if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
                 for(i = 0; i < driver->num; i++)
@@ -3792,8 +3798,9 @@ int tty_unregister_driver(struct tty_driver *driver)
 
         unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
                                 driver->num);
-
+        mutex_lock(&tty_mutex);
         list_del(&driver->tty_drivers);
+        mutex_unlock(&tty_mutex);
 
         /*
          * Free the termios and termios_locked structures because
@@ -3836,11 +3843,9 @@ void proc_clear_tty(struct task_struct *p)
         p->signal->tty = NULL;
         spin_unlock_irq(&p->sighand->siglock);
 }
-EXPORT_SYMBOL(proc_clear_tty);
 
-static struct pid *__proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
+static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
 {
-        struct pid *old_pgrp;
         if (tty) {
                 /* We should not have a session or pgrp to here but.... */
                 put_pid(tty->session);
@@ -3848,21 +3853,16 @@ static struct pid *__proc_set_tty(struct task_struct *tsk, struct tty_struct *tt
                 tty->session = get_pid(task_session(tsk));
                 tty->pgrp = get_pid(task_pgrp(tsk));
         }
-        old_pgrp = tsk->signal->tty_old_pgrp;
+        put_pid(tsk->signal->tty_old_pgrp);
         tsk->signal->tty = tty;
         tsk->signal->tty_old_pgrp = NULL;
-        return old_pgrp;
 }
 
-void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
+static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
 {
-        struct pid *old_pgrp;
-
         spin_lock_irq(&tsk->sighand->siglock);
-        old_pgrp = __proc_set_tty(tsk, tty);
+        __proc_set_tty(tsk, tty);
         spin_unlock_irq(&tsk->sighand->siglock);
-
-        put_pid(old_pgrp);
 }
 
 struct tty_struct *get_current_tty(void)
@@ -3897,9 +3897,6 @@ void __init console_init(void)
          * set up the console device so that later boot sequences can 
          * inform about problems etc..
          */
-#ifdef CONFIG_EARLY_PRINTK
-        disable_early_printk();
-#endif
         call = __con_initcall_start;
         while (call < __con_initcall_end) {
                 (*call)();
diff --git a/drivers/char/vc_screen.c b/drivers/char/vc_screen.c
index 791930320a13..83aeedda200c 100644
--- a/drivers/char/vc_screen.c
+++ b/drivers/char/vc_screen.c
@@ -28,12 +28,13 @@
 #include <linux/interrupt.h>
 #include <linux/mm.h>
 #include <linux/init.h>
+#include <linux/mutex.h>
 #include <linux/vt_kern.h>
 #include <linux/selection.h>
 #include <linux/kbd_kern.h>
 #include <linux/console.h>
-#include <linux/smp_lock.h>
 #include <linux/device.h>
+
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
@@ -70,11 +71,11 @@ static loff_t vcs_lseek(struct file *file, loff_t offset, int orig)
 {
         int size;
 
-        down(&con_buf_sem);
+        mutex_lock(&con_buf_mtx);
         size = vcs_size(file->f_path.dentry->d_inode);
         switch (orig) {
                 default:
-                        up(&con_buf_sem);
+                        mutex_unlock(&con_buf_mtx);
                         return -EINVAL;
                 case 2:
                         offset += size;
@@ -85,11 +86,11 @@ static loff_t vcs_lseek(struct file *file, loff_t offset, int orig)
                         break;
         }
         if (offset < 0 || offset > size) {
-                up(&con_buf_sem);
+                mutex_unlock(&con_buf_mtx);
                 return -EINVAL;
         }
         file->f_pos = offset;
-        up(&con_buf_sem);
+        mutex_unlock(&con_buf_mtx);
         return file->f_pos;
 }
 
@@ -106,7 +107,7 @@ vcs_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
         unsigned short *org = NULL;
         ssize_t ret;
 
-        down(&con_buf_sem);
+        mutex_lock(&con_buf_mtx);
 
         pos = *ppos;
 
@@ -263,7 +264,7 @@ vcs_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
                 ret = read;
 unlock_out:
         release_console_sem();
-        up(&con_buf_sem);
+        mutex_unlock(&con_buf_mtx);
         return ret;
 }
 
@@ -280,7 +281,7 @@ vcs_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
         u16 *org0 = NULL, *org = NULL;
         size_t ret;
 
-        down(&con_buf_sem);
+        mutex_lock(&con_buf_mtx);
 
         pos = *ppos;
 
@@ -450,7 +451,7 @@ vcs_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 unlock_out:
         release_console_sem();
 
-        up(&con_buf_sem);
+        mutex_unlock(&con_buf_mtx);
 
         return ret;
 }
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 1bbb45b937fd..bbd9fc412877 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -86,6 +86,7 @@
 #include <linux/mm.h>
 #include <linux/console.h>
 #include <linux/init.h>
+#include <linux/mutex.h>
 #include <linux/vt_kern.h>
 #include <linux/selection.h>
 #include <linux/tiocl.h>
@@ -157,6 +158,8 @@ static void blank_screen_t(unsigned long dummy);
 static void set_palette(struct vc_data *vc);
 
 static int printable;           /* Is console ready for printing? */
+static int default_utf8;
+module_param(default_utf8, int, S_IRUGO | S_IWUSR);
 
 /*
  * ignore_poke: don't unblank the screen when things are typed.  This is
@@ -348,10 +351,12 @@ void update_region(struct vc_data *vc, unsigned long start, int count)
 
 /* Structure of attributes is hardware-dependent */
 
-static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink, u8 _underline, u8 _reverse)
+static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink,
+    u8 _underline, u8 _reverse, u8 _italic)
 {
         if (vc->vc_sw->con_build_attr)
-                return vc->vc_sw->con_build_attr(vc, _color, _intensity, _blink, _underline, _reverse);
+                return vc->vc_sw->con_build_attr(vc, _color, _intensity,
+                       _blink, _underline, _reverse, _italic);
 
 #ifndef VT_BUF_VRAM_ONLY
 /*
@@ -368,10 +373,13 @@ static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink, u8
         u8 a = vc->vc_color;
         if (!vc->vc_can_do_color)
                 return _intensity |
+                       (_italic ? 2 : 0) |
                        (_underline ? 4 : 0) |
                        (_reverse ? 8 : 0) |
                        (_blink ? 0x80 : 0);
-        if (_underline)
+        if (_italic)
+                a = (a & 0xF0) | vc->vc_itcolor;
+        else if (_underline)
                 a = (a & 0xf0) | vc->vc_ulcolor;
         else if (_intensity == 0)
                 a = (a & 0xf0) | vc->vc_ulcolor;
@@ -392,8 +400,10 @@ static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink, u8
 
 static void update_attr(struct vc_data *vc)
 {
-        vc->vc_attr = build_attr(vc, vc->vc_color, vc->vc_intensity, vc->vc_blink, vc->vc_underline, vc->vc_reverse ^ vc->vc_decscnm);
-        vc->vc_video_erase_char = (build_attr(vc, vc->vc_color, 1, vc->vc_blink, 0, vc->vc_decscnm) << 8) | ' ';
+        vc->vc_attr = build_attr(vc, vc->vc_color, vc->vc_intensity,
+                      vc->vc_blink, vc->vc_underline,
+                      vc->vc_reverse ^ vc->vc_decscnm, vc->vc_italic);
+        vc->vc_video_erase_char = (build_attr(vc, vc->vc_color, 1, vc->vc_blink, 0, vc->vc_decscnm, 0) << 8) | ' ';
 }
 
 /* Note: inverting the screen twice should revert to the original state */
@@ -934,6 +944,10 @@ int default_grn[] = {0x00,0x00,0xaa,0x55,0x00,0x00,0xaa,0xaa,
 int default_blu[] = {0x00,0x00,0x00,0x00,0xaa,0xaa,0xaa,0xaa,
     0x55,0x55,0x55,0x55,0xff,0xff,0xff,0xff};
 
+module_param_array(default_red, int, NULL, S_IRUGO | S_IWUSR);
+module_param_array(default_grn, int, NULL, S_IRUGO | S_IWUSR);
+module_param_array(default_blu, int, NULL, S_IRUGO | S_IWUSR);
+
 /*
  * gotoxy() must verify all boundaries, because the arguments
  * might also be negative. If the given position is out of
@@ -1132,6 +1146,7 @@ static void csi_X(struct vc_data *vc, int vpar) /* erase the following vpar posi
 static void default_attr(struct vc_data *vc)
 {
         vc->vc_intensity = 1;
+        vc->vc_italic = 0;
         vc->vc_underline = 0;
         vc->vc_reverse = 0;
         vc->vc_blink = 0;
@@ -1154,6 +1169,9 @@ static void csi_m(struct vc_data *vc)
                         case 2:
                                 vc->vc_intensity = 0;
                                 break;
+                        case 3:
+                                vc->vc_italic = 1;
+                                break;
                         case 4:
                                 vc->vc_underline = 1;
                                 break;
@@ -1194,6 +1212,9 @@ static void csi_m(struct vc_data *vc)
                         case 22:
                                 vc->vc_intensity = 1;
                                 break;
+                        case 23:
+                                vc->vc_italic = 0;
+                                break;
                         case 24:
                                 vc->vc_underline = 0;
                                 break;
@@ -1454,6 +1475,7 @@ static void save_cur(struct vc_data *vc)
         vc->vc_saved_x          = vc->vc_x;
         vc->vc_saved_y          = vc->vc_y;
         vc->vc_s_intensity      = vc->vc_intensity;
+        vc->vc_s_italic         = vc->vc_italic;
         vc->vc_s_underline      = vc->vc_underline;
         vc->vc_s_blink          = vc->vc_blink;
         vc->vc_s_reverse        = vc->vc_reverse;
@@ -1468,6 +1490,7 @@ static void restore_cur(struct vc_data *vc)
 {
         gotoxy(vc, vc->vc_saved_x, vc->vc_saved_y);
         vc->vc_intensity        = vc->vc_s_intensity;
+        vc->vc_italic           = vc->vc_s_italic;
         vc->vc_underline        = vc->vc_s_underline;
         vc->vc_blink            = vc->vc_s_blink;
         vc->vc_reverse          = vc->vc_s_reverse;
@@ -1497,7 +1520,7 @@ static void reset_terminal(struct vc_data *vc, int do_clear)
         vc->vc_charset          = 0;
         vc->vc_need_wrap        = 0;
         vc->vc_report_mouse     = 0;
-        vc->vc_utf              = 0;
+        vc->vc_utf              = default_utf8;
         vc->vc_utf_count        = 0;
 
         vc->vc_disp_ctrl        = 0;
@@ -1930,7 +1953,47 @@ static void do_con_trol(struct tty_struct *tty, struct vc_data *vc, int c)
  * kernel memory allocation is available.
  */
 char con_buf[CON_BUF_SIZE];
-DECLARE_MUTEX(con_buf_sem);
+DEFINE_MUTEX(con_buf_mtx);
+
+/* is_double_width() is based on the wcwidth() implementation by
+ * Markus Kuhn -- 2003-05-20 (Unicode 4.0)
+ * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+ */
+struct interval {
+        uint32_t first;
+        uint32_t last;
+};
+
+static int bisearch(uint32_t ucs, const struct interval *table, int max)
+{
+        int min = 0;
+        int mid;
+
+        if (ucs < table[0].first || ucs > table[max].last)
+                return 0;
+        while (max >= min) {
+                mid = (min + max) / 2;
+                if (ucs > table[mid].last)
+                        min = mid + 1;
+                else if (ucs < table[mid].first)
+                        max = mid - 1;
+                else
+                        return 1;
+        }
+        return 0;
+}
+
+static int is_double_width(uint32_t ucs)
+{
+        static const struct interval double_width[] = {
+                { 0x1100, 0x115F }, { 0x2329, 0x232A }, { 0x2E80, 0x303E },
+                { 0x3040, 0xA4CF }, { 0xAC00, 0xD7A3 }, { 0xF900, 0xFAFF },
+                { 0xFE30, 0xFE6F }, { 0xFF00, 0xFF60 }, { 0xFFE0, 0xFFE6 },
+                { 0x20000, 0x2FFFD }, { 0x30000, 0x3FFFD }
+        };
+        return bisearch(ucs, double_width,
+                sizeof(double_width) / sizeof(*double_width) - 1);
+}
 
 /* acquires console_sem */
 static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int count)
@@ -1948,6 +2011,10 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
         unsigned int currcons;
         unsigned long draw_from = 0, draw_to = 0;
         struct vc_data *vc;
+        unsigned char vc_attr;
+        uint8_t rescan;
+        uint8_t inverse;
+        uint8_t width;
         u16 himask, charmask;
         const unsigned char *orig_buf = NULL;
         int orig_count;
@@ -1983,7 +2050,7 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
 
         /* At this point 'buf' is guaranteed to be a kernel buffer
          * and therefore no access to userspace (and therefore sleeping)
-         * will be needed.  The con_buf_sem serializes all tty based
+         * will be needed.  The con_buf_mtx serializes all tty based
          * console rendering and vcs write/read operations.  We hold
          * the console spinlock during the entire write.
          */
@@ -2010,53 +2077,86 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
                 buf++;
                 n++;
                 count--;
+                rescan = 0;
+                inverse = 0;
+                width = 1;
 
                 /* Do no translation at all in control states */
                 if (vc->vc_state != ESnormal) {
                         tc = c;
                 } else if (vc->vc_utf && !vc->vc_disp_ctrl) {
-                    /* Combine UTF-8 into Unicode */
-                    /* Malformed sequences as sequences of replacement glyphs */
+                    /* Combine UTF-8 into Unicode in vc_utf_char.
+                     * vc_utf_count is the number of continuation bytes still
+                     * expected to arrive.
+                     * vc_npar is the number of continuation bytes arrived so
+                     * far
+                     */
 rescan_last_byte:
-                    if(c > 0x7f) {
+                    if ((c & 0xc0) == 0x80) {
+                        /* Continuation byte received */
+                        static const uint32_t utf8_length_changes[] = { 0x0000007f, 0x000007ff, 0x0000ffff, 0x001fffff, 0x03ffffff, 0x7fffffff };
                         if (vc->vc_utf_count) {
-                               if ((c & 0xc0) == 0x80) {
-                                       vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f);
-                                       if (--vc->vc_utf_count) {
-                                               vc->vc_npar++;
-                                               continue;
-                                       }
-                                       tc = c = vc->vc_utf_char;
-                               } else
-                                       goto replacement_glyph;
-                        } else {
-                                vc->vc_npar = 0;
-                                if ((c & 0xe0) == 0xc0) {
-                                    vc->vc_utf_count = 1;
-                                    vc->vc_utf_char = (c & 0x1f);
-                                } else if ((c & 0xf0) == 0xe0) {
-                                    vc->vc_utf_count = 2;
-                                    vc->vc_utf_char = (c & 0x0f);
-                                } else if ((c & 0xf8) == 0xf0) {
-                                    vc->vc_utf_count = 3;
-                                    vc->vc_utf_char = (c & 0x07);
-                                } else if ((c & 0xfc) == 0xf8) {
-                                    vc->vc_utf_count = 4;
-                                    vc->vc_utf_char = (c & 0x03);
-                                } else if ((c & 0xfe) == 0xfc) {
-                                    vc->vc_utf_count = 5;
-                                    vc->vc_utf_char = (c & 0x01);
-                                } else
-                                    goto replacement_glyph;
+                            vc->vc_utf_char = (vc->vc_utf_char << 6) | (c & 0x3f);
+                            vc->vc_npar++;
+                            if (--vc->vc_utf_count) {
+                                /* Still need some bytes */
                                 continue;
-                              }
+                            }
+                            /* Got a whole character */
+                            c = vc->vc_utf_char;
+                            /* Reject overlong sequences */
+                            if (c <= utf8_length_changes[vc->vc_npar - 1] ||
+                                        c > utf8_length_changes[vc->vc_npar])
+                                c = 0xfffd;
+                        } else {
+                            /* Unexpected continuation byte */
+                            vc->vc_utf_count = 0;
+                            c = 0xfffd;
+                        }
                     } else {
-                      if (vc->vc_utf_count)
-                              goto replacement_glyph;
-                      tc = c;
+                        /* Single ASCII byte or first byte of a sequence received */
+                        if (vc->vc_utf_count) {
+                            /* Continuation byte expected */
+                            rescan = 1;
+                            vc->vc_utf_count = 0;
+                            c = 0xfffd;
+                        } else if (c > 0x7f) {
+                            /* First byte of a multibyte sequence received */
+                            vc->vc_npar = 0;
+                            if ((c & 0xe0) == 0xc0) {
+                                vc->vc_utf_count = 1;
+                                vc->vc_utf_char = (c & 0x1f);
+                            } else if ((c & 0xf0) == 0xe0) {
+                                vc->vc_utf_count = 2;
+                                vc->vc_utf_char = (c & 0x0f);
+                            } else if ((c & 0xf8) == 0xf0) {
+                                vc->vc_utf_count = 3;
+                                vc->vc_utf_char = (c & 0x07);
+                            } else if ((c & 0xfc) == 0xf8) {
+                                vc->vc_utf_count = 4;
+                                vc->vc_utf_char = (c & 0x03);
+                            } else if ((c & 0xfe) == 0xfc) {
+                                vc->vc_utf_count = 5;
+                                vc->vc_utf_char = (c & 0x01);
+                            } else {
+                                /* 254 and 255 are invalid */
+                                c = 0xfffd;
+                            }
+                            if (vc->vc_utf_count) {
+                                /* Still need some bytes */
+                                continue;
+                            }
+                        }
+                        /* Nothing to do if an ASCII byte was received */
                     }
+                    /* End of UTF-8 decoding. */
+                    /* c is the received character, or U+FFFD for invalid sequences. */
+                    /* Replace invalid Unicode code points with U+FFFD too */
+                    if ((c >= 0xd800 && c <= 0xdfff) || c == 0xfffe || c == 0xffff)
+                        c = 0xfffd;
+                    tc = c;
                 } else {        /* no utf or alternate charset mode */
-                  tc = vc->vc_translate[vc->vc_toggle_meta ? (c | 0x80) : c];
+                    tc = vc->vc_translate[vc->vc_toggle_meta ? (c | 0x80) : c];
                 }
 
                 /* If the original code was a control character we
@@ -2076,56 +2176,80 @@ rescan_last_byte:
                         && (c != 128+27);
 
                 if (vc->vc_state == ESnormal && ok) {
+                        if (vc->vc_utf && !vc->vc_disp_ctrl) {
+                                if (is_double_width(c))
+                                        width = 2;
+                        }
                         /* Now try to find out how to display it */
                         tc = conv_uni_to_pc(vc, tc);
                         if (tc & ~charmask) {
-                                if ( tc == -4 ) {
-                                /* If we got -4 (not found) then see if we have
-                                   defined a replacement character (U+FFFD) */
-replacement_glyph:
-                                        tc = conv_uni_to_pc(vc, 0xfffd);
-                                        if (!(tc & ~charmask))
-                                                goto display_glyph;
-                                } else if ( tc != -3 )
-                                        continue; /* nothing to display */
-                                /* no hash table or no replacement --
-                                 * hope for the best */
-                                if ( c & ~charmask )
-                                        tc = '?';
-                                else
-                                        tc = c;
+                                if (tc == -1 || tc == -2) {
+                                    continue; /* nothing to display */
+                                }
+                                /* Glyph not found */
+                                if (!(vc->vc_utf && !vc->vc_disp_ctrl) && !(c & ~charmask)) {
+                                    /* In legacy mode use the glyph we get by a 1:1 mapping.
+                                       This would make absolutely no sense with Unicode in mind. */
+                                    tc = c;
+                                } else {
+                                    /* Display U+FFFD. If it's not found, display an inverse question mark. */
+                                    tc = conv_uni_to_pc(vc, 0xfffd);
+                                    if (tc < 0) {
+                                        inverse = 1;
+                                        tc = conv_uni_to_pc(vc, '?');
+                                        if (tc < 0) tc = '?';
+                                    }
+                                }
                         }
 
-display_glyph:
-                        if (vc->vc_need_wrap || vc->vc_decim)
-                                FLUSH
-                        if (vc->vc_need_wrap) {
-                                cr(vc);
-                                lf(vc);
-                        }
-                        if (vc->vc_decim)
-                                insert_char(vc, 1);
-                        scr_writew(himask ?
-                                     ((vc->vc_attr << 8) & ~himask) + ((tc & 0x100) ? himask : 0) + (tc & 0xff) :
-                                     (vc->vc_attr << 8) + tc,
-                                   (u16 *) vc->vc_pos);
-                        if (DO_UPDATE(vc) && draw_x < 0) {
-                                draw_x = vc->vc_x;
-                                draw_from = vc->vc_pos;
-                        }
-                        if (vc->vc_x == vc->vc_cols - 1) {
-                                vc->vc_need_wrap = vc->vc_decawm;
-                                draw_to = vc->vc_pos + 2;
+                        if (!inverse) {
+                                vc_attr = vc->vc_attr;
                         } else {
-                                vc->vc_x++;
-                                draw_to = (vc->vc_pos += 2);
+                                /* invert vc_attr */
+                                if (!vc->vc_can_do_color) {
+                                        vc_attr = (vc->vc_attr) ^ 0x08;
+                                } else if (vc->vc_hi_font_mask == 0x100) {
+                                        vc_attr = ((vc->vc_attr) & 0x11) | (((vc->vc_attr) & 0xe0) >> 4) | (((vc->vc_attr) & 0x0e) << 4);
+                                } else {
+                                        vc_attr = ((vc->vc_attr) & 0x88) | (((vc->vc_attr) & 0x70) >> 4) | (((vc->vc_attr) & 0x07) << 4);
+                                }
                         }
-                        if (vc->vc_utf_count) {
-                                if (vc->vc_npar) {
-                                        vc->vc_npar--;
-                                        goto display_glyph;
+
+                        while (1) {
+                                if (vc->vc_need_wrap || vc->vc_decim)
+                                        FLUSH
+                                if (vc->vc_need_wrap) {
+                                        cr(vc);
+                                        lf(vc);
+                                }
+                                if (vc->vc_decim)
+                                        insert_char(vc, 1);
+                                scr_writew(himask ?
+                                             ((vc_attr << 8) & ~himask) + ((tc & 0x100) ? himask : 0) + (tc & 0xff) :
+                                             (vc_attr << 8) + tc,
+                                           (u16 *) vc->vc_pos);
+                                if (DO_UPDATE(vc) && draw_x < 0) {
+                                        draw_x = vc->vc_x;
+                                        draw_from = vc->vc_pos;
+                                }
+                                if (vc->vc_x == vc->vc_cols - 1) {
+                                        vc->vc_need_wrap = vc->vc_decawm;
+                                        draw_to = vc->vc_pos + 2;
+                                } else {
+                                        vc->vc_x++;
+                                        draw_to = (vc->vc_pos += 2);
                                 }
-                                vc->vc_utf_count = 0;
+
+                                if (!--width) break;
+
+                                tc = conv_uni_to_pc(vc, ' '); /* A space is printed in the second column */
+                                if (tc < 0) tc = ' ';
+                        }
+
+                        if (rescan) {
+                                rescan = 0;
+                                inverse = 0;
+                                width = 1;
                                 c = orig;
                                 goto rescan_last_byte;
                         }
@@ -2581,6 +2705,11 @@ static void con_close(struct tty_struct *tty, struct file *filp)
         mutex_unlock(&tty_mutex);
 }
 
+static int default_italic_color    = 2; // green (ASCII)
+static int default_underline_color = 3; // cyan (ASCII)
+module_param_named(italic, default_italic_color, int, S_IRUGO | S_IWUSR);
+module_param_named(underline, default_underline_color, int, S_IRUGO | S_IWUSR);
+
 static void vc_init(struct vc_data *vc, unsigned int rows,
                     unsigned int cols, int do_clear)
 {
@@ -2600,7 +2729,8 @@ static void vc_init(struct vc_data *vc, unsigned int rows,
                 vc->vc_palette[k++] = default_blu[j] ;
         }
         vc->vc_def_color       = 0x07;   /* white */
-        vc->vc_ulcolor          = 0x0f;   /* bold white */
+        vc->vc_ulcolor         = default_underline_color;
+        vc->vc_itcolor         = default_italic_color;
         vc->vc_halfcolor       = 0x08;   /* grey */
         init_waitqueue_head(&vc->paste_wait);
         reset_terminal(vc, do_clear);
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index c9f2dd620e87..c6f6f4209739 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -1061,7 +1061,7 @@ int vt_waitactive(int vt)
                 schedule();
         }
         remove_wait_queue(&vt_activate_queue, &wait);
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         return retval;
 }
 
diff --git a/drivers/char/watchdog/omap_wdt.c b/drivers/char/watchdog/omap_wdt.c
index 84074a697dce..b36fa8de2131 100644
--- a/drivers/char/watchdog/omap_wdt.c
+++ b/drivers/char/watchdog/omap_wdt.c
@@ -34,7 +34,6 @@
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
 #include <linux/reboot.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 8d053f500fc2..8532bb79e5fc 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -470,7 +470,7 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
         dbs_info->enable = 1;
         ondemand_powersave_bias_init();
         dbs_info->sample_type = DBS_NORMAL_SAMPLE;
-        INIT_DELAYED_WORK(&dbs_info->work, do_dbs_timer);
+        INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer);
         queue_delayed_work_on(dbs_info->cpu, kondemand_wq, &dbs_info->work,
                               delay);
 }
diff --git a/drivers/edac/i82875p_edac.c b/drivers/edac/i82875p_edac.c
index 161fe09a6d38..2800b3e614a9 100644
--- a/drivers/edac/i82875p_edac.c
+++ b/drivers/edac/i82875p_edac.c
@@ -261,10 +261,6 @@ static void i82875p_check(struct mem_ctl_info *mci)
         i82875p_process_error_info(mci, &info, 1);
 }
 
-#ifdef CONFIG_PROC_FS
-extern int pci_proc_attach_device(struct pci_dev *);
-#endif
-
 /* Return 0 on success or 1 on failure. */
 static int i82875p_setup_overfl_dev(struct pci_dev *pdev,
                 struct pci_dev **ovrfl_pdev, void __iomem **ovrfl_window)
@@ -287,17 +283,12 @@ static int i82875p_setup_overfl_dev(struct pci_dev *pdev,
 
                 if (dev == NULL)
                         return 1;
+
+                pci_bus_add_device(dev);
         }
 
         *ovrfl_pdev = dev;
 
-#ifdef CONFIG_PROC_FS
-        if ((dev->procent == NULL) && pci_proc_attach_device(dev)) {
-                i82875p_printk(KERN_ERR, "%s(): Failed to attach overflow "
-                               "device\n", __func__);
-                return 1;
-        }
-#endif  /* CONFIG_PROC_FS */
         if (pci_enable_device(dev)) {
                 i82875p_printk(KERN_ERR, "%s(): Failed to enable overflow "
                                "device\n", __func__);
diff --git a/drivers/eisa/virtual_root.c b/drivers/eisa/virtual_root.c
index 9b4fcac03ad5..3074879f231f 100644
--- a/drivers/eisa/virtual_root.c
+++ b/drivers/eisa/virtual_root.c
@@ -47,7 +47,7 @@ static void virtual_eisa_release (struct device *dev)
         /* nothing really to do here */
 }
 
-static int virtual_eisa_root_init (void)
+static int __init virtual_eisa_root_init (void)
 {
         int r;
         
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 62e21cc73938..6ec04e79f685 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -20,7 +20,6 @@
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/spinlock.h>
 #include <asm/unaligned.h>
 #include <asm/byteorder.h>
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 6d105a1d41b1..25b72a491702 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -594,6 +594,30 @@ config SENSORS_HDAPS
           Say Y here if you have an applicable laptop and want to experience
           the awesome power of hdaps.
 
+config SENSORS_APPLESMC
+        tristate "Apple SMC (Motion sensor, light sensor, keyboard backlight)"
+        depends on HWMON && INPUT && X86
+        select NEW_LEDS
+        select LEDS_CLASS
+        default n
+        help
+          This driver provides support for the Apple System Management
+          Controller, which provides an accelerometer (Apple Sudden Motion
+          Sensor), light sensors, temperature sensors, keyboard backlight
+          control and fan control.
+
+          Only Intel-based Apple's computers are supported (MacBook Pro,
+          MacBook, MacMini).
+
+          Data from the different sensors, keyboard backlight control and fan
+          control are accessible via sysfs.
+
+          This driver also provides an absolute input class device, allowing
+          the laptop to act as a pinball machine-esque joystick.
+
+          Say Y here if you have an applicable laptop and want to experience
+          the awesome power of applesmc.
+
 config HWMON_DEBUG_CHIP
         bool "Hardware Monitoring Chip debugging messages"
         depends on HWMON
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 4165c27a2f25..544f8d8dff4e 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_SENSORS_ADM1026)	+= adm1026.o
 obj-$(CONFIG_SENSORS_ADM1029)   += adm1029.o
 obj-$(CONFIG_SENSORS_ADM1031)   += adm1031.o
 obj-$(CONFIG_SENSORS_ADM9240)   += adm9240.o
+obj-$(CONFIG_SENSORS_APPLESMC)  += applesmc.o
 obj-$(CONFIG_SENSORS_AMS)       += ams/
 obj-$(CONFIG_SENSORS_ATXP1)     += atxp1.o
 obj-$(CONFIG_SENSORS_DS1621)    += ds1621.o
diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
new file mode 100644
index 000000000000..3215f9c87f32
--- /dev/null
+++ b/drivers/hwmon/applesmc.c
@@ -0,0 +1,1339 @@
+/*
+ * drivers/hwmon/applesmc.c - driver for Apple's SMC (accelerometer, temperature
+ * sensors, fan control, keyboard backlight control) used in Intel-based Apple
+ * computers.
+ *
+ * Copyright (C) 2007 Nicolas Boichat <nicolas@boichat.ch>
+ *
+ * Based on hdaps.c driver:
+ * Copyright (C) 2005 Robert Love <rml@novell.com>
+ * Copyright (C) 2005 Jesper Juhl <jesper.juhl@gmail.com>
+ *
+ * Fan control based on smcFanControl:
+ * Copyright (C) 2006 Hendrik Holtmann <holtmann@mac.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License v2 as published by the
+ * Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/timer.h>
+#include <linux/dmi.h>
+#include <linux/mutex.h>
+#include <linux/hwmon-sysfs.h>
+#include <asm/io.h>
+#include <linux/leds.h>
+#include <linux/hwmon.h>
+#include <linux/workqueue.h>
+
+/* data port used by Apple SMC */
+#define APPLESMC_DATA_PORT      0x300
+/* command/status port used by Apple SMC */
+#define APPLESMC_CMD_PORT       0x304
+
+#define APPLESMC_NR_PORTS       32 /* 0x300-0x31f */
+
+#define APPLESMC_MAX_DATA_LENGTH 32
+
+#define APPLESMC_STATUS_MASK    0x0f
+#define APPLESMC_READ_CMD       0x10
+#define APPLESMC_WRITE_CMD      0x11
+#define APPLESMC_GET_KEY_BY_INDEX_CMD   0x12
+#define APPLESMC_GET_KEY_TYPE_CMD       0x13
+
+#define KEY_COUNT_KEY           "#KEY" /* r-o ui32 */
+
+#define LIGHT_SENSOR_LEFT_KEY   "ALV0" /* r-o {alv (6 bytes) */
+#define LIGHT_SENSOR_RIGHT_KEY  "ALV1" /* r-o {alv (6 bytes) */
+#define BACKLIGHT_KEY           "LKSB" /* w-o {lkb (2 bytes) */
+
+#define CLAMSHELL_KEY           "MSLD" /* r-o ui8 (unused) */
+
+#define MOTION_SENSOR_X_KEY     "MO_X" /* r-o sp78 (2 bytes) */
+#define MOTION_SENSOR_Y_KEY     "MO_Y" /* r-o sp78 (2 bytes) */
+#define MOTION_SENSOR_Z_KEY     "MO_Z" /* r-o sp78 (2 bytes) */
+#define MOTION_SENSOR_KEY       "MOCN" /* r/w ui16 */
+
+#define FANS_COUNT              "FNum" /* r-o ui8 */
+#define FANS_MANUAL             "FS! " /* r-w ui16 */
+#define FAN_ACTUAL_SPEED        "F0Ac" /* r-o fpe2 (2 bytes) */
+#define FAN_MIN_SPEED           "F0Mn" /* r-o fpe2 (2 bytes) */
+#define FAN_MAX_SPEED           "F0Mx" /* r-o fpe2 (2 bytes) */
+#define FAN_SAFE_SPEED          "F0Sf" /* r-o fpe2 (2 bytes) */
+#define FAN_TARGET_SPEED        "F0Tg" /* r-w fpe2 (2 bytes) */
+#define FAN_POSITION            "F0ID" /* r-o char[16] */
+
+/*
+ * Temperature sensors keys (sp78 - 2 bytes).
+ * First set for Macbook(Pro), second for Macmini.
+ */
+static const char* temperature_sensors_sets[][13] = {
+        { "TA0P", "TB0T", "TC0D", "TC0P", "TG0H", "TG0P", "TG0T", "Th0H",
+          "Th1H", "Tm0P", "Ts0P", "Ts1P", NULL },
+        { "TC0D", "TC0P", NULL }
+};
+
+/* List of keys used to read/write fan speeds */
+static const char* fan_speed_keys[] = {
+        FAN_ACTUAL_SPEED,
+        FAN_MIN_SPEED,
+        FAN_MAX_SPEED,
+        FAN_SAFE_SPEED,
+        FAN_TARGET_SPEED
+};
+
+#define INIT_TIMEOUT_MSECS      5000    /* wait up to 5s for device init ... */
+#define INIT_WAIT_MSECS         50      /* ... in 50ms increments */
+
+#define APPLESMC_POLL_PERIOD    (HZ/20) /* poll for input every 1/20s */
+#define APPLESMC_INPUT_FUZZ     4       /* input event threshold */
+#define APPLESMC_INPUT_FLAT     4
+
+#define SENSOR_X 0
+#define SENSOR_Y 1
+#define SENSOR_Z 2
+
+/* Structure to be passed to DMI_MATCH function */
+struct dmi_match_data {
+/* Indicates whether this computer has an accelerometer. */
+        int accelerometer;
+/* Indicates whether this computer has light sensors and keyboard backlight. */
+        int light;
+/* Indicates which temperature sensors set to use. */
+        int temperature_set;
+};
+
+static const int debug;
+static struct platform_device *pdev;
+static s16 rest_x;
+static s16 rest_y;
+static struct timer_list applesmc_timer;
+static struct input_dev *applesmc_idev;
+static struct class_device *hwmon_class_dev;
+
+/* Indicates whether this computer has an accelerometer. */
+static unsigned int applesmc_accelerometer;
+
+/* Indicates whether this computer has light sensors and keyboard backlight. */
+static unsigned int applesmc_light;
+
+/* Indicates which temperature sensors set to use. */
+static unsigned int applesmc_temperature_set;
+
+static struct mutex applesmc_lock;
+
+/*
+ * Last index written to key_at_index sysfs file, and value to use for all other
+ * key_at_index_* sysfs files.
+ */
+static unsigned int key_at_index;
+
+static struct workqueue_struct *applesmc_led_wq;
+
+/*
+ * __wait_status - Wait up to 2ms for the status port to get a certain value
+ * (masked with 0x0f), returning zero if the value is obtained.  Callers must
+ * hold applesmc_lock.
+ */
+static int __wait_status(u8 val)
+{
+        unsigned int i;
+
+        val = val & APPLESMC_STATUS_MASK;
+
+        for (i = 0; i < 200; i++) {
+                if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == val) {
+                        if (debug)
+                                printk(KERN_DEBUG
+                                                "Waited %d us for status %x\n",
+                                                i*10, val);
+                        return 0;
+                }
+                udelay(10);
+        }
+
+        printk(KERN_WARNING "applesmc: wait status failed: %x != %x\n",
+                                                val, inb(APPLESMC_CMD_PORT));
+
+        return -EIO;
+}
+
+/*
+ * applesmc_read_key - reads len bytes from a given key, and put them in buffer.
+ * Returns zero on success or a negative error on failure. Callers must
+ * hold applesmc_lock.
+ */
+static int applesmc_read_key(const char* key, u8* buffer, u8 len)
+{
+        int i;
+
+        if (len > APPLESMC_MAX_DATA_LENGTH) {
+                printk(KERN_ERR "applesmc_read_key: cannot read more than "
+                                        "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
+                return -EINVAL;
+        }
+
+        outb(APPLESMC_READ_CMD, APPLESMC_CMD_PORT);
+        if (__wait_status(0x0c))
+                return -EIO;
+
+        for (i = 0; i < 4; i++) {
+                outb(key[i], APPLESMC_DATA_PORT);
+                if (__wait_status(0x04))
+                        return -EIO;
+        }
+        if (debug)
+                printk(KERN_DEBUG "<%s", key);
+
+        outb(len, APPLESMC_DATA_PORT);
+        if (debug)
+                printk(KERN_DEBUG ">%x", len);
+
+        for (i = 0; i < len; i++) {
+                if (__wait_status(0x05))
+                        return -EIO;
+                buffer[i] = inb(APPLESMC_DATA_PORT);
+                if (debug)
+                        printk(KERN_DEBUG "<%x", buffer[i]);
+        }
+        if (debug)
+                printk(KERN_DEBUG "\n");
+
+        return 0;
+}
+
+/*
+ * applesmc_write_key - writes len bytes from buffer to a given key.
+ * Returns zero on success or a negative error on failure. Callers must
+ * hold applesmc_lock.
+ */
+static int applesmc_write_key(const char* key, u8* buffer, u8 len)
+{
+        int i;
+
+        if (len > APPLESMC_MAX_DATA_LENGTH) {
+                printk(KERN_ERR "applesmc_write_key: cannot write more than "
+                                        "%d bytes\n", APPLESMC_MAX_DATA_LENGTH);
+                return -EINVAL;
+        }
+
+        outb(APPLESMC_WRITE_CMD, APPLESMC_CMD_PORT);
+        if (__wait_status(0x0c))
+                return -EIO;
+
+        for (i = 0; i < 4; i++) {
+                outb(key[i], APPLESMC_DATA_PORT);
+                if (__wait_status(0x04))
+                        return -EIO;
+        }
+
+        outb(len, APPLESMC_DATA_PORT);
+
+        for (i = 0; i < len; i++) {
+                if (__wait_status(0x04))
+                        return -EIO;
+                outb(buffer[i], APPLESMC_DATA_PORT);
+        }
+
+        return 0;
+}
+
+/*
+ * applesmc_get_key_at_index - get key at index, and put the result in key
+ * (char[6]). Returns zero on success or a negative error on failure. Callers
+ * must hold applesmc_lock.
+ */
+static int applesmc_get_key_at_index(int index, char* key)
+{
+        int i;
+        u8 readkey[4];
+        readkey[0] = index >> 24;
+        readkey[1] = index >> 16;
+        readkey[2] = index >> 8;
+        readkey[3] = index;
+
+        outb(APPLESMC_GET_KEY_BY_INDEX_CMD, APPLESMC_CMD_PORT);
+        if (__wait_status(0x0c))
+                return -EIO;
+
+        for (i = 0; i < 4; i++) {
+                outb(readkey[i], APPLESMC_DATA_PORT);
+                if (__wait_status(0x04))
+                        return -EIO;
+        }
+
+        outb(4, APPLESMC_DATA_PORT);
+
+        for (i = 0; i < 4; i++) {
+                if (__wait_status(0x05))
+                        return -EIO;
+                key[i] = inb(APPLESMC_DATA_PORT);
+        }
+        key[4] = 0;
+
+        return 0;
+}
+
+/*
+ * applesmc_get_key_type - get key type, and put the result in type (char[6]).
+ * Returns zero on success or a negative error on failure. Callers must
+ * hold applesmc_lock.
+ */
+static int applesmc_get_key_type(char* key, char* type)
+{
+        int i;
+
+        outb(APPLESMC_GET_KEY_TYPE_CMD, APPLESMC_CMD_PORT);
+        if (__wait_status(0x0c))
+                return -EIO;
+
+        for (i = 0; i < 4; i++) {
+                outb(key[i], APPLESMC_DATA_PORT);
+                if (__wait_status(0x04))
+                        return -EIO;
+        }
+
+        outb(5, APPLESMC_DATA_PORT);
+
+        for (i = 0; i < 6; i++) {
+                if (__wait_status(0x05))
+                        return -EIO;
+                type[i] = inb(APPLESMC_DATA_PORT);
+        }
+        type[5] = 0;
+
+        return 0;
+}
+
+/*
+ * applesmc_read_motion_sensor - Read motion sensor (X, Y or Z). Callers must
+ * hold applesmc_lock.
+ */
+static int applesmc_read_motion_sensor(int index, s16* value)
+{
+        u8 buffer[2];
+        int ret;
+
+        switch (index) {
+        case SENSOR_X:
+                ret = applesmc_read_key(MOTION_SENSOR_X_KEY, buffer, 2);
+                break;
+        case SENSOR_Y:
+                ret = applesmc_read_key(MOTION_SENSOR_Y_KEY, buffer, 2);
+                break;
+        case SENSOR_Z:
+                ret = applesmc_read_key(MOTION_SENSOR_Z_KEY, buffer, 2);
+                break;
+        default:
+                ret = -EINVAL;
+        }
+
+        *value = ((s16)buffer[0] << 8) | buffer[1];
+
+        return ret;
+}
+
+/*
+ * applesmc_device_init - initialize the accelerometer.  Returns zero on success
+ * and negative error code on failure.  Can sleep.
+ */
+static int applesmc_device_init(void)
+{
+        int total, ret = -ENXIO;
+        u8 buffer[2];
+
+        if (!applesmc_accelerometer)
+                return 0;
+
+        mutex_lock(&applesmc_lock);
+
+        for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
+                if (debug)
+                        printk(KERN_DEBUG "applesmc try %d\n", total);
+                if (!applesmc_read_key(MOTION_SENSOR_KEY, buffer, 2) &&
+                                (buffer[0] != 0x00 || buffer[1] != 0x00)) {
+                        if (total == INIT_TIMEOUT_MSECS) {
+                                printk(KERN_DEBUG "applesmc: device has"
+                                                " already been initialized"
+                                                " (0x%02x, 0x%02x).\n",
+                                                buffer[0], buffer[1]);
+                        } else {
+                                printk(KERN_DEBUG "applesmc: device"
+                                                " successfully initialized"
+                                                " (0x%02x, 0x%02x).\n",
+                                                buffer[0], buffer[1]);
+                        }
+                        ret = 0;
+                        goto out;
+                }
+                buffer[0] = 0xe0;
+                buffer[1] = 0x00;
+                applesmc_write_key(MOTION_SENSOR_KEY, buffer, 2);
+                msleep(INIT_WAIT_MSECS);
+        }
+
+        printk(KERN_WARNING "applesmc: failed to init the device\n");
+
+out:
+        mutex_unlock(&applesmc_lock);
+        return ret;
+}
+
+/*
+ * applesmc_get_fan_count - get the number of fans. Callers must NOT hold
+ * applesmc_lock.
+ */
+static int applesmc_get_fan_count(void)
+{
+        int ret;
+        u8 buffer[1];
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_read_key(FANS_COUNT, buffer, 1);
+
+        mutex_unlock(&applesmc_lock);
+        if (ret)
+                return ret;
+        else
+                return buffer[0];
+}
+
+/* Device model stuff */
+static int applesmc_probe(struct platform_device *dev)
+{
+        int ret;
+
+        ret = applesmc_device_init();
+        if (ret)
+                return ret;
+
+        printk(KERN_INFO "applesmc: device successfully initialized.\n");
+        return 0;
+}
+
+static int applesmc_resume(struct platform_device *dev)
+{
+        return applesmc_device_init();
+}
+
+static struct platform_driver applesmc_driver = {
+        .probe = applesmc_probe,
+        .resume = applesmc_resume,
+        .driver = {
+                .name = "applesmc",
+                .owner = THIS_MODULE,
+        },
+};
+
+/*
+ * applesmc_calibrate - Set our "resting" values.  Callers must
+ * hold applesmc_lock.
+ */
+static void applesmc_calibrate(void)
+{
+        applesmc_read_motion_sensor(SENSOR_X, &rest_x);
+        applesmc_read_motion_sensor(SENSOR_Y, &rest_y);
+        rest_x = -rest_x;
+}
+
+static int applesmc_idev_open(struct input_dev *dev)
+{
+        add_timer(&applesmc_timer);
+
+        return 0;
+}
+
+static void applesmc_idev_close(struct input_dev *dev)
+{
+        del_timer_sync(&applesmc_timer);
+}
+
+static void applesmc_idev_poll(unsigned long unused)
+{
+        s16 x, y;
+
+        /* Cannot sleep.  Try nonblockingly.  If we fail, try again later. */
+        if (!mutex_trylock(&applesmc_lock)) {
+                mod_timer(&applesmc_timer, jiffies + APPLESMC_POLL_PERIOD);
+                return;
+        }
+
+        if (applesmc_read_motion_sensor(SENSOR_X, &x))
+                goto out;
+        if (applesmc_read_motion_sensor(SENSOR_Y, &y))
+                goto out;
+
+        x = -x;
+        input_report_abs(applesmc_idev, ABS_X, x - rest_x);
+        input_report_abs(applesmc_idev, ABS_Y, y - rest_y);
+        input_sync(applesmc_idev);
+
+out:
+        mod_timer(&applesmc_timer, jiffies + APPLESMC_POLL_PERIOD);
+
+        mutex_unlock(&applesmc_lock);
+}
+
+/* Sysfs Files */
+
+static ssize_t applesmc_position_show(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        int ret;
+        s16 x, y, z;
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_read_motion_sensor(SENSOR_X, &x);
+        if (ret)
+                goto out;
+        ret = applesmc_read_motion_sensor(SENSOR_Y, &y);
+        if (ret)
+                goto out;
+        ret = applesmc_read_motion_sensor(SENSOR_Z, &z);
+        if (ret)
+                goto out;
+
+out:
+        mutex_unlock(&applesmc_lock);
+        if (ret)
+                return ret;
+        else
+                return snprintf(buf, PAGE_SIZE, "(%d,%d,%d)\n", x, y, z);
+}
+
+static ssize_t applesmc_light_show(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        int ret;
+        u8 left = 0, right = 0;
+        u8 buffer[6];
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, 6);
+        left = buffer[2];
+        if (ret)
+                goto out;
+        ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, 6);
+        right = buffer[2];
+
+out:
+        mutex_unlock(&applesmc_lock);
+        if (ret)
+                return ret;
+        else
+                return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right);
+}
+
+/* Displays degree Celsius * 1000 */
+static ssize_t applesmc_show_temperature(struct device *dev,
+                        struct device_attribute *devattr, char *sysfsbuf)
+{
+        int ret;
+        u8 buffer[2];
+        unsigned int temp;
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        const char* key =
+                temperature_sensors_sets[applesmc_temperature_set][attr->index];
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_read_key(key, buffer, 2);
+        temp = buffer[0]*1000;
+        temp += (buffer[1] >> 6) * 250;
+
+        mutex_unlock(&applesmc_lock);
+
+        if (ret)
+                return ret;
+        else
+                return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", temp);
+}
+
+static ssize_t applesmc_show_fan_speed(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        int ret;
+        unsigned int speed = 0;
+        char newkey[5];
+        u8 buffer[2];
+        struct sensor_device_attribute_2 *sensor_attr =
+                                                to_sensor_dev_attr_2(attr);
+
+        newkey[0] = fan_speed_keys[sensor_attr->nr][0];
+        newkey[1] = '0' + sensor_attr->index;
+        newkey[2] = fan_speed_keys[sensor_attr->nr][2];
+        newkey[3] = fan_speed_keys[sensor_attr->nr][3];
+        newkey[4] = 0;
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_read_key(newkey, buffer, 2);
+        speed = ((buffer[0] << 8 | buffer[1]) >> 2);
+
+        mutex_unlock(&applesmc_lock);
+        if (ret)
+                return ret;
+        else
+                return snprintf(sysfsbuf, PAGE_SIZE, "%u\n", speed);
+}
+
+static ssize_t applesmc_store_fan_speed(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *sysfsbuf, size_t count)
+{
+        int ret;
+        u32 speed;
+        char newkey[5];
+        u8 buffer[2];
+        struct sensor_device_attribute_2 *sensor_attr =
+                                                to_sensor_dev_attr_2(attr);
+
+        speed = simple_strtoul(sysfsbuf, NULL, 10);
+
+        if (speed > 0x4000) /* Bigger than a 14-bit value */
+                return -EINVAL;
+
+        newkey[0] = fan_speed_keys[sensor_attr->nr][0];
+        newkey[1] = '0' + sensor_attr->index;
+        newkey[2] = fan_speed_keys[sensor_attr->nr][2];
+        newkey[3] = fan_speed_keys[sensor_attr->nr][3];
+        newkey[4] = 0;
+
+        mutex_lock(&applesmc_lock);
+
+        buffer[0] = (speed >> 6) & 0xff;
+        buffer[1] = (speed << 2) & 0xff;
+        ret = applesmc_write_key(newkey, buffer, 2);
+
+        mutex_unlock(&applesmc_lock);
+        if (ret)
+                return ret;
+        else
+                return count;
+}
+
+static ssize_t applesmc_show_fan_manual(struct device *dev,
+                        struct device_attribute *devattr, char *sysfsbuf)
+{
+        int ret;
+        u16 manual = 0;
+        u8 buffer[2];
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
+        manual = ((buffer[0] << 8 | buffer[1]) >> attr->index) & 0x01;
+
+        mutex_unlock(&applesmc_lock);
+        if (ret)
+                return ret;
+        else
+                return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", manual);
+}
+
+static ssize_t applesmc_store_fan_manual(struct device *dev,
+                                         struct device_attribute *devattr,
+                                         const char *sysfsbuf, size_t count)
+{
+        int ret;
+        u8 buffer[2];
+        u32 input;
+        u16 val;
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+
+        input = simple_strtoul(sysfsbuf, NULL, 10);
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_read_key(FANS_MANUAL, buffer, 2);
+        val = (buffer[0] << 8 | buffer[1]);
+        if (ret)
+                goto out;
+
+        if (input)
+                val = val | (0x01 << attr->index);
+        else
+                val = val & ~(0x01 << attr->index);
+
+        buffer[0] = (val >> 8) & 0xFF;
+        buffer[1] = val & 0xFF;
+
+        ret = applesmc_write_key(FANS_MANUAL, buffer, 2);
+
+out:
+        mutex_unlock(&applesmc_lock);
+        if (ret)
+                return ret;
+        else
+                return count;
+}
+
+static ssize_t applesmc_show_fan_position(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        int ret;
+        char newkey[5];
+        u8 buffer[17];
+        struct sensor_device_attribute_2 *sensor_attr =
+                                                to_sensor_dev_attr_2(attr);
+
+        newkey[0] = FAN_POSITION[0];
+        newkey[1] = '0' + sensor_attr->index;
+        newkey[2] = FAN_POSITION[2];
+        newkey[3] = FAN_POSITION[3];
+        newkey[4] = 0;
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_read_key(newkey, buffer, 16);
+        buffer[16] = 0;
+
+        mutex_unlock(&applesmc_lock);
+        if (ret)
+                return ret;
+        else
+                return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", buffer+4);
+}
+
+static ssize_t applesmc_calibrate_show(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", rest_x, rest_y);
+}
+
+static ssize_t applesmc_calibrate_store(struct device *dev,
+        struct device_attribute *attr, const char *sysfsbuf, size_t count)
+{
+        mutex_lock(&applesmc_lock);
+        applesmc_calibrate();
+        mutex_unlock(&applesmc_lock);
+
+        return count;
+}
+
+/* Store the next backlight value to be written by the work */
+static unsigned int backlight_value;
+
+static void applesmc_backlight_set(struct work_struct *work)
+{
+        u8 buffer[2];
+
+        mutex_lock(&applesmc_lock);
+        buffer[0] = backlight_value;
+        buffer[1] = 0x00;
+        applesmc_write_key(BACKLIGHT_KEY, buffer, 2);
+        mutex_unlock(&applesmc_lock);
+}
+static DECLARE_WORK(backlight_work, &applesmc_backlight_set);
+
+static void applesmc_brightness_set(struct led_classdev *led_cdev,
+                                                enum led_brightness value)
+{
+        int ret;
+
+        backlight_value = value;
+        ret = queue_work(applesmc_led_wq, &backlight_work);
+
+        if (debug && (!ret))
+                printk(KERN_DEBUG "applesmc: work was already on the queue.\n");
+}
+
+static ssize_t applesmc_key_count_show(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        int ret;
+        u8 buffer[4];
+        u32 count;
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_read_key(KEY_COUNT_KEY, buffer, 4);
+        count = ((u32)buffer[0]<<24) + ((u32)buffer[1]<<16) +
+                                                ((u32)buffer[2]<<8) + buffer[3];
+
+        mutex_unlock(&applesmc_lock);
+        if (ret)
+                return ret;
+        else
+                return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", count);
+}
+
+static ssize_t applesmc_key_at_index_read_show(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        char key[5];
+        char info[6];
+        int ret;
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_get_key_at_index(key_at_index, key);
+
+        if (ret || !key[0]) {
+                mutex_unlock(&applesmc_lock);
+
+                return -EINVAL;
+        }
+
+        ret = applesmc_get_key_type(key, info);
+
+        if (ret) {
+                mutex_unlock(&applesmc_lock);
+
+                return ret;
+        }
+
+        /*
+         * info[0] maximum value (APPLESMC_MAX_DATA_LENGTH) is much lower than
+         * PAGE_SIZE, so we don't need any checks before writing to sysfsbuf.
+         */
+        ret = applesmc_read_key(key, sysfsbuf, info[0]);
+
+        mutex_unlock(&applesmc_lock);
+
+        if (!ret) {
+                return info[0];
+        }
+        else {
+                return ret;
+        }
+}
+
+static ssize_t applesmc_key_at_index_data_length_show(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        char key[5];
+        char info[6];
+        int ret;
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_get_key_at_index(key_at_index, key);
+
+        if (ret || !key[0]) {
+                mutex_unlock(&applesmc_lock);
+
+                return -EINVAL;
+        }
+
+        ret = applesmc_get_key_type(key, info);
+
+        mutex_unlock(&applesmc_lock);
+
+        if (!ret)
+                return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", info[0]);
+        else
+                return ret;
+}
+
+static ssize_t applesmc_key_at_index_type_show(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        char key[5];
+        char info[6];
+        int ret;
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_get_key_at_index(key_at_index, key);
+
+        if (ret || !key[0]) {
+                mutex_unlock(&applesmc_lock);
+
+                return -EINVAL;
+        }
+
+        ret = applesmc_get_key_type(key, info);
+
+        mutex_unlock(&applesmc_lock);
+
+        if (!ret)
+                return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", info+1);
+        else
+                return ret;
+}
+
+static ssize_t applesmc_key_at_index_name_show(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        char key[5];
+        int ret;
+
+        mutex_lock(&applesmc_lock);
+
+        ret = applesmc_get_key_at_index(key_at_index, key);
+
+        mutex_unlock(&applesmc_lock);
+
+        if (!ret && key[0])
+                return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key);
+        else
+                return -EINVAL;
+}
+
+static ssize_t applesmc_key_at_index_show(struct device *dev,
+                                struct device_attribute *attr, char *sysfsbuf)
+{
+        return snprintf(sysfsbuf, PAGE_SIZE, "%d\n", key_at_index);
+}
+
+static ssize_t applesmc_key_at_index_store(struct device *dev,
+        struct device_attribute *attr, const char *sysfsbuf, size_t count)
+{
+        mutex_lock(&applesmc_lock);
+
+        key_at_index = simple_strtoul(sysfsbuf, NULL, 10);
+
+        mutex_unlock(&applesmc_lock);
+
+        return count;
+}
+
+static struct led_classdev applesmc_backlight = {
+        .name                   = "smc:kbd_backlight",
+        .default_trigger        = "nand-disk",
+        .brightness_set         = applesmc_brightness_set,
+};
+
+static DEVICE_ATTR(position, 0444, applesmc_position_show, NULL);
+static DEVICE_ATTR(calibrate, 0644,
+                        applesmc_calibrate_show, applesmc_calibrate_store);
+
+static struct attribute *accelerometer_attributes[] = {
+        &dev_attr_position.attr,
+        &dev_attr_calibrate.attr,
+        NULL
+};
+
+static const struct attribute_group accelerometer_attributes_group =
+        { .attrs = accelerometer_attributes };
+
+static DEVICE_ATTR(light, 0444, applesmc_light_show, NULL);
+
+static DEVICE_ATTR(key_count, 0444, applesmc_key_count_show, NULL);
+static DEVICE_ATTR(key_at_index, 0644,
+                applesmc_key_at_index_show, applesmc_key_at_index_store);
+static DEVICE_ATTR(key_at_index_name, 0444,
+                                        applesmc_key_at_index_name_show, NULL);
+static DEVICE_ATTR(key_at_index_type, 0444,
+                                        applesmc_key_at_index_type_show, NULL);
+static DEVICE_ATTR(key_at_index_data_length, 0444,
+                                applesmc_key_at_index_data_length_show, NULL);
+static DEVICE_ATTR(key_at_index_data, 0444,
+                                applesmc_key_at_index_read_show, NULL);
+
+static struct attribute *key_enumeration_attributes[] = {
+        &dev_attr_key_count.attr,
+        &dev_attr_key_at_index.attr,
+        &dev_attr_key_at_index_name.attr,
+        &dev_attr_key_at_index_type.attr,
+        &dev_attr_key_at_index_data_length.attr,
+        &dev_attr_key_at_index_data.attr,
+        NULL
+};
+
+static const struct attribute_group key_enumeration_group =
+        { .attrs = key_enumeration_attributes };
+
+/*
+ * Macro defining SENSOR_DEVICE_ATTR for a fan sysfs entries.
+ *  - show actual speed
+ *  - show/store minimum speed
+ *  - show maximum speed
+ *  - show safe speed
+ *  - show/store target speed
+ *  - show/store manual mode
+ */
+#define sysfs_fan_speeds_offset(offset) \
+static SENSOR_DEVICE_ATTR_2(fan##offset##_input, S_IRUGO, \
+                        applesmc_show_fan_speed, NULL, 0, offset-1); \
+\
+static SENSOR_DEVICE_ATTR_2(fan##offset##_min, S_IRUGO | S_IWUSR, \
+        applesmc_show_fan_speed, applesmc_store_fan_speed, 1, offset-1); \
+\
+static SENSOR_DEVICE_ATTR_2(fan##offset##_max, S_IRUGO, \
+                        applesmc_show_fan_speed, NULL, 2, offset-1); \
+\
+static SENSOR_DEVICE_ATTR_2(fan##offset##_safe, S_IRUGO, \
+                        applesmc_show_fan_speed, NULL, 3, offset-1); \
+\
+static SENSOR_DEVICE_ATTR_2(fan##offset##_output, S_IRUGO | S_IWUSR, \
+        applesmc_show_fan_speed, applesmc_store_fan_speed, 4, offset-1); \
+\
+static SENSOR_DEVICE_ATTR(fan##offset##_manual, S_IRUGO | S_IWUSR, \
+        applesmc_show_fan_manual, applesmc_store_fan_manual, offset-1); \
+\
+static SENSOR_DEVICE_ATTR(fan##offset##_position, S_IRUGO, \
+        applesmc_show_fan_position, NULL, offset-1); \
+\
+static struct attribute *fan##offset##_attributes[] = { \
+        &sensor_dev_attr_fan##offset##_input.dev_attr.attr, \
+        &sensor_dev_attr_fan##offset##_min.dev_attr.attr, \
+        &sensor_dev_attr_fan##offset##_max.dev_attr.attr, \
+        &sensor_dev_attr_fan##offset##_safe.dev_attr.attr, \
+        &sensor_dev_attr_fan##offset##_output.dev_attr.attr, \
+        &sensor_dev_attr_fan##offset##_manual.dev_attr.attr, \
+        &sensor_dev_attr_fan##offset##_position.dev_attr.attr, \
+        NULL \
+};
+
+/*
+ * Create the needed functions for each fan using the macro defined above
+ * (2 fans are supported)
+ */
+sysfs_fan_speeds_offset(1);
+sysfs_fan_speeds_offset(2);
+
+static const struct attribute_group fan_attribute_groups[] = {
+        { .attrs = fan1_attributes },
+        { .attrs = fan2_attributes }
+};
+
+/*
+ * Temperature sensors sysfs entries.
+ */
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 5);
+static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 6);
+static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 7);
+static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 8);
+static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 9);
+static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 10);
+static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO,
+                                        applesmc_show_temperature, NULL, 11);
+
+static struct attribute *temperature_attributes[] = {
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp3_input.dev_attr.attr,
+        &sensor_dev_attr_temp4_input.dev_attr.attr,
+        &sensor_dev_attr_temp5_input.dev_attr.attr,
+        &sensor_dev_attr_temp6_input.dev_attr.attr,
+        &sensor_dev_attr_temp7_input.dev_attr.attr,
+        &sensor_dev_attr_temp8_input.dev_attr.attr,
+        &sensor_dev_attr_temp9_input.dev_attr.attr,
+        &sensor_dev_attr_temp10_input.dev_attr.attr,
+        &sensor_dev_attr_temp11_input.dev_attr.attr,
+        &sensor_dev_attr_temp12_input.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group temperature_attributes_group =
+        { .attrs = temperature_attributes };
+
+/* Module stuff */
+
+/*
+ * applesmc_dmi_match - found a match.  return one, short-circuiting the hunt.
+ */
+static int applesmc_dmi_match(struct dmi_system_id *id)
+{
+        int i = 0;
+        struct dmi_match_data* dmi_data = id->driver_data;
+        printk(KERN_INFO "applesmc: %s detected:\n", id->ident);
+        applesmc_accelerometer = dmi_data->accelerometer;
+        printk(KERN_INFO "applesmc:  - Model %s accelerometer\n",
+                                applesmc_accelerometer ? "with" : "without");
+        applesmc_light = dmi_data->light;
+        printk(KERN_INFO "applesmc:  - Model %s light sensors and backlight\n",
+                                        applesmc_light ? "with" : "without");
+
+        applesmc_temperature_set =  dmi_data->temperature_set;
+        while (temperature_sensors_sets[applesmc_temperature_set][i] != NULL)
+                i++;
+        printk(KERN_INFO "applesmc:  - Model with %d temperature sensors\n", i);
+        return 1;
+}
+
+/* Create accelerometer ressources */
+static int applesmc_create_accelerometer(void)
+{
+        int ret;
+
+        ret = sysfs_create_group(&pdev->dev.kobj,
+                                        &accelerometer_attributes_group);
+        if (ret)
+                goto out;
+
+        applesmc_idev = input_allocate_device();
+        if (!applesmc_idev) {
+                ret = -ENOMEM;
+                goto out_sysfs;
+        }
+
+        /* initial calibrate for the input device */
+        applesmc_calibrate();
+
+        /* initialize the input class */
+        applesmc_idev->name = "applesmc";
+        applesmc_idev->id.bustype = BUS_HOST;
+        applesmc_idev->cdev.dev = &pdev->dev;
+        applesmc_idev->evbit[0] = BIT(EV_ABS);
+        applesmc_idev->open = applesmc_idev_open;
+        applesmc_idev->close = applesmc_idev_close;
+        input_set_abs_params(applesmc_idev, ABS_X,
+                        -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
+        input_set_abs_params(applesmc_idev, ABS_Y,
+                        -256, 256, APPLESMC_INPUT_FUZZ, APPLESMC_INPUT_FLAT);
+
+        ret = input_register_device(applesmc_idev);
+        if (ret)
+                goto out_idev;
+
+        /* start up our timer for the input device */
+        init_timer(&applesmc_timer);
+        applesmc_timer.function = applesmc_idev_poll;
+        applesmc_timer.expires = jiffies + APPLESMC_POLL_PERIOD;
+
+        return 0;
+
+out_idev:
+        input_free_device(applesmc_idev);
+
+out_sysfs:
+        sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
+
+out:
+        printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
+        return ret;
+}
+
+/* Release all ressources used by the accelerometer */
+static void applesmc_release_accelerometer(void)
+{
+        del_timer_sync(&applesmc_timer);
+        input_unregister_device(applesmc_idev);
+        sysfs_remove_group(&pdev->dev.kobj, &accelerometer_attributes_group);
+}
+
+static __initdata struct dmi_match_data applesmc_dmi_data[] = {
+/* MacBook Pro: accelerometer, backlight and temperature set 0 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 0 },
+/* MacBook: accelerometer and temperature set 0 */
+        { .accelerometer = 1, .light = 0, .temperature_set = 0 },
+/* MacBook: temperature set 1 */
+        { .accelerometer = 0, .light = 0, .temperature_set = 1 }
+};
+
+/* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
+ * So we need to put "Apple MacBook Pro" before "Apple MacBook". */
+static __initdata struct dmi_system_id applesmc_whitelist[] = {
+        { applesmc_dmi_match, "Apple MacBook Pro", {
+          DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME,"MacBookPro") },
+                (void*)&applesmc_dmi_data[0]},
+        { applesmc_dmi_match, "Apple MacBook", {
+          DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
+                (void*)&applesmc_dmi_data[1]},
+        { applesmc_dmi_match, "Apple Macmini", {
+          DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME,"Macmini") },
+                (void*)&applesmc_dmi_data[2]},
+        { .ident = NULL }
+};
+
+static int __init applesmc_init(void)
+{
+        int ret;
+        int count;
+        int i;
+
+        mutex_init(&applesmc_lock);
+
+        if (!dmi_check_system(applesmc_whitelist)) {
+                printk(KERN_WARNING "applesmc: supported laptop not found!\n");
+                ret = -ENODEV;
+                goto out;
+        }
+
+        if (!request_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS,
+                                                                "applesmc")) {
+                ret = -ENXIO;
+                goto out;
+        }
+
+        ret = platform_driver_register(&applesmc_driver);
+        if (ret)
+                goto out_region;
+
+        pdev = platform_device_register_simple("applesmc", -1, NULL, 0);
+        if (IS_ERR(pdev)) {
+                ret = PTR_ERR(pdev);
+                goto out_driver;
+        }
+
+        /* Create key enumeration sysfs files */
+        ret = sysfs_create_group(&pdev->dev.kobj, &key_enumeration_group);
+        if (ret)
+                goto out_device;
+
+        /* create fan files */
+        count = applesmc_get_fan_count();
+        if (count < 0) {
+                printk(KERN_ERR "applesmc: Cannot get the number of fans.\n");
+        } else {
+                printk(KERN_INFO "applesmc: %d fans found.\n", count);
+
+                switch (count) {
+                default:
+                        printk(KERN_WARNING "applesmc: More than 2 fans found,"
+                                        " but at most 2 fans are supported"
+                                                " by the driver.\n");
+                case 2:
+                        ret = sysfs_create_group(&pdev->dev.kobj,
+                                                 &fan_attribute_groups[1]);
+                        if (ret)
+                                goto out_key_enumeration;
+                case 1:
+                        ret = sysfs_create_group(&pdev->dev.kobj,
+                                                 &fan_attribute_groups[0]);
+                        if (ret)
+                                goto out_fan_1;
+                case 0:
+                        ;
+                }
+        }
+
+        for (i = 0;
+             temperature_sensors_sets[applesmc_temperature_set][i] != NULL;
+             i++) {
+                if (temperature_attributes[i] == NULL) {
+                        printk(KERN_ERR "applesmc: More temperature sensors "
+                                "in temperature_sensors_sets (at least %i)"
+                                "than available sysfs files in "
+                                "temperature_attributes (%i), please report "
+                                "this bug.\n", i, i-1);
+                        goto out_temperature;
+                }
+                ret = sysfs_create_file(&pdev->dev.kobj,
+                                                temperature_attributes[i]);
+                if (ret)
+                        goto out_temperature;
+        }
+
+        if (applesmc_accelerometer) {
+                ret = applesmc_create_accelerometer();
+                if (ret)
+                        goto out_temperature;
+        }
+
+        if (applesmc_light) {
+                /* Add light sensor file */
+                ret = sysfs_create_file(&pdev->dev.kobj, &dev_attr_light.attr);
+                if (ret)
+                        goto out_accelerometer;
+
+                /* Create the workqueue */
+                applesmc_led_wq = create_singlethread_workqueue("applesmc-led");
+                if (!applesmc_led_wq) {
+                        ret = -ENOMEM;
+                        goto out_light_sysfs;
+                }
+
+                /* register as a led device */
+                ret = led_classdev_register(&pdev->dev, &applesmc_backlight);
+                if (ret < 0)
+                        goto out_light_wq;
+        }
+
+        hwmon_class_dev = hwmon_device_register(&pdev->dev);
+        if (IS_ERR(hwmon_class_dev)) {
+                ret = PTR_ERR(hwmon_class_dev);
+                goto out_light_ledclass;
+        }
+
+        printk(KERN_INFO "applesmc: driver successfully loaded.\n");
+
+        return 0;
+
+out_light_ledclass:
+        if (applesmc_light)
+                led_classdev_unregister(&applesmc_backlight);
+out_light_wq:
+        if (applesmc_light)
+                destroy_workqueue(applesmc_led_wq);
+out_light_sysfs:
+        if (applesmc_light)
+                sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
+out_accelerometer:
+        if (applesmc_accelerometer)
+                applesmc_release_accelerometer();
+out_temperature:
+        sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
+        sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]);
+out_fan_1:
+        sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]);
+out_key_enumeration:
+        sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
+out_device:
+        platform_device_unregister(pdev);
+out_driver:
+        platform_driver_unregister(&applesmc_driver);
+out_region:
+        release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
+out:
+        printk(KERN_WARNING "applesmc: driver init failed (ret=%d)!\n", ret);
+        return ret;
+}
+
+static void __exit applesmc_exit(void)
+{
+        hwmon_device_unregister(hwmon_class_dev);
+        if (applesmc_light) {
+                led_classdev_unregister(&applesmc_backlight);
+                destroy_workqueue(applesmc_led_wq);
+                sysfs_remove_file(&pdev->dev.kobj, &dev_attr_light.attr);
+        }
+        if (applesmc_accelerometer)
+                applesmc_release_accelerometer();
+        sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
+        sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[0]);
+        sysfs_remove_group(&pdev->dev.kobj, &fan_attribute_groups[1]);
+        sysfs_remove_group(&pdev->dev.kobj, &key_enumeration_group);
+        platform_device_unregister(pdev);
+        platform_driver_unregister(&applesmc_driver);
+        release_region(APPLESMC_DATA_PORT, APPLESMC_NR_PORTS);
+
+        printk(KERN_INFO "applesmc: driver unloaded.\n");
+}
+
+module_init(applesmc_init);
+module_exit(applesmc_exit);
+
+MODULE_AUTHOR("Nicolas Boichat");
+MODULE_DESCRIPTION("Apple SMC");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/hwmon/hdaps.c b/drivers/hwmon/hdaps.c
index bf759ea545ac..f82fa2d23f95 100644
--- a/drivers/hwmon/hdaps.c
+++ b/drivers/hwmon/hdaps.c
@@ -30,10 +30,12 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/kernel.h>
+#include <linux/mutex.h>
 #include <linux/module.h>
 #include <linux/timer.h>
 #include <linux/dmi.h>
 #include <linux/jiffies.h>
+
 #include <asm/io.h>
 
 #define HDAPS_LOW_PORT          0x1600  /* first port used by hdaps */
@@ -71,10 +73,10 @@ static u8 km_activity;
 static int rest_x;
 static int rest_y;
 
-static DECLARE_MUTEX(hdaps_sem);
+static DEFINE_MUTEX(hdaps_mtx);
 
 /*
- * __get_latch - Get the value from a given port.  Callers must hold hdaps_sem.
+ * __get_latch - Get the value from a given port.  Callers must hold hdaps_mtx.
  */
 static inline u8 __get_latch(u16 port)
 {
@@ -83,7 +85,7 @@ static inline u8 __get_latch(u16 port)
 
 /*
  * __check_latch - Check a port latch for a given value.  Returns zero if the
- * port contains the given value.  Callers must hold hdaps_sem.
+ * port contains the given value.  Callers must hold hdaps_mtx.
  */
 static inline int __check_latch(u16 port, u8 val)
 {
@@ -94,7 +96,7 @@ static inline int __check_latch(u16 port, u8 val)
 
 /*
  * __wait_latch - Wait up to 100us for a port latch to get a certain value,
- * returning zero if the value is obtained.  Callers must hold hdaps_sem.
+ * returning zero if the value is obtained.  Callers must hold hdaps_mtx.
  */
 static int __wait_latch(u16 port, u8 val)
 {
@@ -111,7 +113,7 @@ static int __wait_latch(u16 port, u8 val)
 
 /*
  * __device_refresh - request a refresh from the accelerometer.  Does not wait
- * for refresh to complete.  Callers must hold hdaps_sem.
+ * for refresh to complete.  Callers must hold hdaps_mtx.
  */
 static void __device_refresh(void)
 {
@@ -125,7 +127,7 @@ static void __device_refresh(void)
 /*
  * __device_refresh_sync - request a synchronous refresh from the
  * accelerometer.  We wait for the refresh to complete.  Returns zero if
- * successful and nonzero on error.  Callers must hold hdaps_sem.
+ * successful and nonzero on error.  Callers must hold hdaps_mtx.
  */
 static int __device_refresh_sync(void)
 {
@@ -135,7 +137,7 @@ static int __device_refresh_sync(void)
 
 /*
  * __device_complete - indicate to the accelerometer that we are done reading
- * data, and then initiate an async refresh.  Callers must hold hdaps_sem.
+ * data, and then initiate an async refresh.  Callers must hold hdaps_mtx.
  */
 static inline void __device_complete(void)
 {
@@ -153,7 +155,7 @@ static int hdaps_readb_one(unsigned int port, u8 *val)
 {
         int ret;
 
-        down(&hdaps_sem);
+        mutex_lock(&hdaps_mtx);
 
         /* do a sync refresh -- we need to be sure that we read fresh data */
         ret = __device_refresh_sync();
@@ -164,7 +166,7 @@ static int hdaps_readb_one(unsigned int port, u8 *val)
         __device_complete();
 
 out:
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mtx);
         return ret;
 }
 
@@ -199,9 +201,9 @@ static int hdaps_read_pair(unsigned int port1, unsigned int port2,
 {
         int ret;
 
-        down(&hdaps_sem);
+        mutex_lock(&hdaps_mtx);
         ret = __hdaps_read_pair(port1, port2, val1, val2);
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mtx);
 
         return ret;
 }
@@ -214,7 +216,7 @@ static int hdaps_device_init(void)
 {
         int total, ret = -ENXIO;
 
-        down(&hdaps_sem);
+        mutex_lock(&hdaps_mtx);
 
         outb(0x13, 0x1610);
         outb(0x01, 0x161f);
@@ -280,7 +282,7 @@ static int hdaps_device_init(void)
         }
 
 out:
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mtx);
         return ret;
 }
 
@@ -314,7 +316,7 @@ static struct platform_driver hdaps_driver = {
 };
 
 /*
- * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_sem.
+ * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_mtx.
  */
 static void hdaps_calibrate(void)
 {
@@ -326,7 +328,7 @@ static void hdaps_mousedev_poll(unsigned long unused)
         int x, y;
 
         /* Cannot sleep.  Try nonblockingly.  If we fail, try again later. */
-        if (down_trylock(&hdaps_sem)) {
+        if (mutex_trylock(&hdaps_mtx)) {
                 mod_timer(&hdaps_timer,jiffies + HDAPS_POLL_PERIOD);
                 return;
         }
@@ -341,7 +343,7 @@ static void hdaps_mousedev_poll(unsigned long unused)
         mod_timer(&hdaps_timer, jiffies + HDAPS_POLL_PERIOD);
 
 out:
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mtx);
 }
 
 
@@ -421,9 +423,9 @@ static ssize_t hdaps_calibrate_store(struct device *dev,
                                      struct device_attribute *attr,
                                      const char *buf, size_t count)
 {
-        down(&hdaps_sem);
+        mutex_lock(&hdaps_mtx);
         hdaps_calibrate();
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mtx);
 
         return count;
 }
diff --git a/drivers/i2c/busses/i2c-parport.c b/drivers/i2c/busses/i2c-parport.c
index 8c953707253f..039a07fde908 100644
--- a/drivers/i2c/busses/i2c-parport.c
+++ b/drivers/i2c/busses/i2c-parport.c
@@ -175,6 +175,7 @@ static void i2c_parport_attach (struct parport *port)
         }
         adapter->algo_data.data = port;
         adapter->adapter.algo_data = &adapter->algo_data;
+        adapter->adapter.dev.parent = port->physport->dev;
 
         if (parport_claim_or_block(adapter->pdev) < 0) {
                 printk(KERN_ERR "i2c-parport: Could not claim parallel port\n");
diff --git a/drivers/i2c/busses/scx200_acb.c b/drivers/i2c/busses/scx200_acb.c
index 0db56e7bc34e..0d6bd4f7b7fa 100644
--- a/drivers/i2c/busses/scx200_acb.c
+++ b/drivers/i2c/busses/scx200_acb.c
@@ -28,7 +28,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/i2c.h>
-#include <linux/smp_lock.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/mutex.h>
diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c
index cb4fa9bef8cd..e7a709710592 100644
--- a/drivers/i2c/i2c-dev.c
+++ b/drivers/i2c/i2c-dev.c
@@ -30,7 +30,6 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/i2c.h>
diff --git a/drivers/ieee1394/dv1394.c b/drivers/ieee1394/dv1394.c
index 026e38face5c..208141377612 100644
--- a/drivers/ieee1394/dv1394.c
+++ b/drivers/ieee1394/dv1394.c
@@ -94,7 +94,6 @@
 #include <linux/pci.h>
 #include <linux/fs.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 #include <linux/bitops.h>
 #include <asm/byteorder.h>
diff --git a/drivers/ieee1394/raw1394.c b/drivers/ieee1394/raw1394.c
index c6aefd9ad0e8..d382500f4210 100644
--- a/drivers/ieee1394/raw1394.c
+++ b/drivers/ieee1394/raw1394.c
@@ -35,7 +35,6 @@
 #include <linux/poll.h>
 #include <linux/module.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/interrupt.h>
 #include <linux/vmalloc.h>
 #include <linux/cdev.h>
diff --git a/drivers/ieee1394/video1394.c b/drivers/ieee1394/video1394.c
index 95ca26d75272..87ebd0846c34 100644
--- a/drivers/ieee1394/video1394.c
+++ b/drivers/ieee1394/video1394.c
@@ -39,7 +39,6 @@
 #include <linux/pci.h>
 #include <linux/fs.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 #include <linux/delay.h>
 #include <linux/bitops.h>
 #include <linux/types.h>
diff --git a/drivers/infiniband/hw/ipath/ipath_fs.c b/drivers/infiniband/hw/ipath/ipath_fs.c
index 036ed1ef1796..ebd5c7bd2cdb 100644
--- a/drivers/infiniband/hw/ipath/ipath_fs.c
+++ b/drivers/infiniband/hw/ipath/ipath_fs.c
@@ -523,7 +523,7 @@ static int ipathfs_fill_super(struct super_block *sb, void *data,
         int ret;
 
         static struct tree_descr files[] = {
-                [1] = {"atomic_stats", &atomic_stats_ops, S_IRUGO},
+                [2] = {"atomic_stats", &atomic_stats_ops, S_IRUGO},
                 {""},
         };
 
diff --git a/drivers/infiniband/ulp/iser/iser_verbs.c b/drivers/infiniband/ulp/iser/iser_verbs.c
index 89d6008bb673..3702e2375553 100644
--- a/drivers/infiniband/ulp/iser/iser_verbs.c
+++ b/drivers/infiniband/ulp/iser/iser_verbs.c
@@ -35,7 +35,6 @@
 #include <asm/io.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/smp_lock.h>
 #include <linux/delay.h>
 #include <linux/version.h>
 
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index 1f6fcec0c6fc..be3dbc1ae67d 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -18,7 +18,6 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/major.h>
-#include <linux/smp_lock.h>
 #include <linux/device.h>
 #include <linux/compat.h>
 
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 915e9ab7cab0..ccd8abafcb70 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -11,7 +11,6 @@
  */
 
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/input.h>
 #include <linux/module.h>
 #include <linux/random.h>
diff --git a/drivers/input/joydev.c b/drivers/input/joydev.c
index 9bcc5425049b..06f0541b24da 100644
--- a/drivers/input/joydev.c
+++ b/drivers/input/joydev.c
@@ -24,7 +24,6 @@
 #include <linux/module.h>
 #include <linux/poll.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/device.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
diff --git a/drivers/input/mousedev.c b/drivers/input/mousedev.c
index 7678e9876550..8675f9509393 100644
--- a/drivers/input/mousedev.c
+++ b/drivers/input/mousedev.c
@@ -19,7 +19,6 @@
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/input.h>
-#include <linux/smp_lock.h>
 #include <linux/random.h>
 #include <linux/major.h>
 #include <linux/device.h>
diff --git a/drivers/input/tsdev.c b/drivers/input/tsdev.c
index 5e5b5c91d75b..8238b13874c2 100644
--- a/drivers/input/tsdev.c
+++ b/drivers/input/tsdev.c
@@ -48,7 +48,6 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/major.h>
-#include <linux/smp_lock.h>
 #include <linux/random.h>
 #include <linux/time.h>
 #include <linux/device.h>
diff --git a/drivers/isdn/capi/capi.c b/drivers/isdn/capi/capi.c
index db1260f73f10..81661b8bd3a8 100644
--- a/drivers/isdn/capi/capi.c
+++ b/drivers/isdn/capi/capi.c
@@ -18,8 +18,8 @@
 #include <linux/fcntl.h>
 #include <linux/fs.h>
 #include <linux/signal.h>
+#include <linux/mutex.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/timer.h>
 #include <linux/wait.h>
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
@@ -147,7 +147,7 @@ struct capidev {
 
         struct capincci *nccis;
 
-        struct semaphore ncci_list_sem;
+        struct mutex ncci_list_mtx;
 };
 
 /* -------- global variables ---------------------------------------- */
@@ -395,7 +395,7 @@ static struct capidev *capidev_alloc(void)
         if (!cdev)
                 return NULL;
 
-        init_MUTEX(&cdev->ncci_list_sem);
+        mutex_init(&cdev->ncci_list_mtx);
         skb_queue_head_init(&cdev->recvqueue);
         init_waitqueue_head(&cdev->recvwait);
         write_lock_irqsave(&capidev_list_lock, flags);
@@ -414,9 +414,9 @@ static void capidev_free(struct capidev *cdev)
         }
         skb_queue_purge(&cdev->recvqueue);
 
-        down(&cdev->ncci_list_sem);
+        mutex_lock(&cdev->ncci_list_mtx);
         capincci_free(cdev, 0xffffffff);
-        up(&cdev->ncci_list_sem);
+        mutex_unlock(&cdev->ncci_list_mtx);
 
         write_lock_irqsave(&capidev_list_lock, flags);
         list_del(&cdev->list);
@@ -603,15 +603,15 @@ static void capi_recv_message(struct capi20_appl *ap, struct sk_buff *skb)
         if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_CONF) {
                 u16 info = CAPIMSG_U16(skb->data, 12); // Info field
                 if (info == 0) {
-                        down(&cdev->ncci_list_sem);
+                        mutex_lock(&cdev->ncci_list_mtx);
                         capincci_alloc(cdev, CAPIMSG_NCCI(skb->data));
-                        up(&cdev->ncci_list_sem);
+                        mutex_unlock(&cdev->ncci_list_mtx);
                 }
         }
         if (CAPIMSG_CMD(skb->data) == CAPI_CONNECT_B3_IND) {
-                down(&cdev->ncci_list_sem);
+                mutex_lock(&cdev->ncci_list_mtx);
                 capincci_alloc(cdev, CAPIMSG_NCCI(skb->data));
-                up(&cdev->ncci_list_sem);
+                mutex_unlock(&cdev->ncci_list_mtx);
         }
         spin_lock_irqsave(&workaround_lock, flags);
         if (CAPIMSG_COMMAND(skb->data) != CAPI_DATA_B3) {
@@ -752,9 +752,9 @@ capi_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos
         CAPIMSG_SETAPPID(skb->data, cdev->ap.applid);
 
         if (CAPIMSG_CMD(skb->data) == CAPI_DISCONNECT_B3_RESP) {
-                down(&cdev->ncci_list_sem);
+                mutex_lock(&cdev->ncci_list_mtx);
                 capincci_free(cdev, CAPIMSG_NCCI(skb->data));
-                up(&cdev->ncci_list_sem);
+                mutex_unlock(&cdev->ncci_list_mtx);
         }
 
         cdev->errcode = capi20_put_message(&cdev->ap, skb);
@@ -939,9 +939,9 @@ capi_ioctl(struct inode *inode, struct file *file,
                         if (copy_from_user(&ncci, argp, sizeof(ncci)))
                                 return -EFAULT;
 
-                        down(&cdev->ncci_list_sem);
+                        mutex_lock(&cdev->ncci_list_mtx);
                         if ((nccip = capincci_find(cdev, (u32) ncci)) == 0) {
-                                up(&cdev->ncci_list_sem);
+                                mutex_unlock(&cdev->ncci_list_mtx);
                                 return 0;
                         }
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
@@ -949,7 +949,7 @@ capi_ioctl(struct inode *inode, struct file *file,
                                 count += atomic_read(&mp->ttyopencount);
                         }
 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
-                        up(&cdev->ncci_list_sem);
+                        mutex_unlock(&cdev->ncci_list_mtx);
                         return count;
                 }
                 return 0;
@@ -964,14 +964,14 @@ capi_ioctl(struct inode *inode, struct file *file,
                         if (copy_from_user(&ncci, argp,
                                            sizeof(ncci)))
                                 return -EFAULT;
-                        down(&cdev->ncci_list_sem);
+                        mutex_lock(&cdev->ncci_list_mtx);
                         nccip = capincci_find(cdev, (u32) ncci);
                         if (!nccip || (mp = nccip->minorp) == 0) {
-                                up(&cdev->ncci_list_sem);
+                                mutex_unlock(&cdev->ncci_list_mtx);
                                 return -ESRCH;
                         }
                         unit = mp->minor;
-                        up(&cdev->ncci_list_sem);
+                        mutex_unlock(&cdev->ncci_list_mtx);
                         return unit;
                 }
                 return 0;
diff --git a/drivers/isdn/capi/capiutil.c b/drivers/isdn/capi/capiutil.c
index ad1e2702c2d1..22379b94e88f 100644
--- a/drivers/isdn/capi/capiutil.c
+++ b/drivers/isdn/capi/capiutil.c
@@ -855,7 +855,7 @@ static _cdebbuf *g_debbuf;
 static u_long g_debbuf_lock;
 static _cmsg *g_cmsg;
 
-_cdebbuf *cdebbuf_alloc(void)
+static _cdebbuf *cdebbuf_alloc(void)
 {
         _cdebbuf *cdb;
 
@@ -989,11 +989,6 @@ _cdebbuf *capi_cmsg2str(_cmsg * cmsg)
         return &g_debbuf;
 }
 
-_cdebbuf *cdebbuf_alloc(void)
-{
-        return &g_debbuf;
-}
-
 void cdebbuf_free(_cdebbuf *cdb)
 {
 }
@@ -1009,7 +1004,6 @@ void __exit cdebug_exit(void)
 
 #endif
 
-EXPORT_SYMBOL(cdebbuf_alloc);
 EXPORT_SYMBOL(cdebbuf_free);
 EXPORT_SYMBOL(capi_cmsg2message);
 EXPORT_SYMBOL(capi_message2cmsg);
diff --git a/drivers/isdn/divert/divert_procfs.c b/drivers/isdn/divert/divert_procfs.c
index 53a189003355..be77ee625bb7 100644
--- a/drivers/isdn/divert/divert_procfs.c
+++ b/drivers/isdn/divert/divert_procfs.c
@@ -11,7 +11,6 @@
 
 #include <linux/module.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 #ifdef CONFIG_PROC_FS
 #include <linux/proc_fs.h>
 #else
diff --git a/drivers/isdn/hardware/eicon/capimain.c b/drivers/isdn/hardware/eicon/capimain.c
index 7a74ed35b1bf..98fcdfc7ca55 100644
--- a/drivers/isdn/hardware/eicon/capimain.c
+++ b/drivers/isdn/hardware/eicon/capimain.c
@@ -13,7 +13,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <asm/uaccess.h>
-#include <linux/smp_lock.h>
 #include <linux/skbuff.h>
 
 #include "os_capi.h"
diff --git a/drivers/isdn/hardware/eicon/dbgioctl.h b/drivers/isdn/hardware/eicon/dbgioctl.h
deleted file mode 100644
index 0fb6f5e88b60..000000000000
--- a/drivers/isdn/hardware/eicon/dbgioctl.h
+++ /dev/null
@@ -1,198 +0,0 @@
-
-/*
- *
-  Copyright (c) Eicon Technology Corporation, 2000.
- *
-  This source file is supplied for the use with Eicon
-  Technology Corporation's range of DIVA Server Adapters.
- *
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
- *
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the GNU General Public License for more details.
- *
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-/*------------------------------------------------------------------*/
-/* file: dbgioctl.h                                                 */
-/*------------------------------------------------------------------*/
-
-#if !defined(__DBGIOCTL_H__)
-
-#define __DBGIOCTL_H__
-
-#ifdef NOT_YET_NEEDED
-/*
- * The requested operation is passed in arg0 of DbgIoctlArgs,
- * additional arguments (if any) in arg1, arg2 and arg3.
- */
-
-typedef struct
-{       ULONG   arg0 ;
-        ULONG   arg1 ;
-        ULONG   arg2 ;
-        ULONG   arg3 ;
-} DbgIoctlArgs ;
-
-#define DBG_COPY_LOGS   0       /* copy debugs to user until buffer full        */
-                                                        /* arg1: size threshold                                         */
-                                                        /* arg2: timeout in milliseconds                        */
-
-#define DBG_FLUSH_LOGS  1       /* flush pending debugs to user buffer          */
-                                                        /* arg1: internal driver id                                     */
-
-#define DBG_LIST_DRVS   2       /* return the list of registered drivers        */
-
-#define DBG_GET_MASK    3       /* get current debug mask of driver                     */
-                                                        /* arg1: internal driver id                                     */
-
-#define DBG_SET_MASK    4       /* set/change debug mask of driver                      */
-                                                        /* arg1: internal driver id                                     */
-                                                        /* arg2: new debug mask                                         */
-
-#define DBG_GET_BUFSIZE 5       /* get current buffer size of driver            */
-                                                        /* arg1: internal driver id                                     */
-                                                        /* arg2: new debug mask                                         */
-
-#define DBG_SET_BUFSIZE 6       /* set new buffer size of driver                        */
-                                                        /* arg1: new buffer size                                        */
-
-/*
- *      common internal debug message structure
- */
-
-typedef struct
-{       unsigned short id ;             /* virtual driver id                  */
-        unsigned short type ;   /* special message type               */
-        unsigned long  seq ;    /* sequence number of message         */
-        unsigned long  size ;   /* size of message in bytes           */
-        unsigned long  next ;   /* offset to next buffered message    */
-        LARGE_INTEGER  NTtime ; /* 100 ns  since 1.1.1601             */
-        unsigned char  data[4] ;/* message data                       */
-} OldDbgMessage ;
-
-typedef struct
-{       LARGE_INTEGER  NTtime ; /* 100 ns  since 1.1.1601             */
-        unsigned short size ;   /* size of message in bytes           */
-        unsigned short ffff ;   /* always 0xffff to indicate new msg  */
-        unsigned short id ;             /* virtual driver id                  */
-        unsigned short type ;   /* special message type               */
-        unsigned long  seq ;    /* sequence number of message         */
-        unsigned char  data[4] ;/* message data                       */
-} DbgMessage ;
-
-#endif
-
-#define DRV_ID_UNKNOWN          0x0C    /* for messages via prtComp() */
-
-#define MSG_PROC_FLAG           0x80
-#define MSG_PROC_NO_GET(x)      (((x) & MSG_PROC_FLAG) ? (((x) >> 4) & 7) : -1)
-#define MSG_PROC_NO_SET(x)      (MSG_PROC_FLAG | (((x) & 7) << 4))
-
-#define MSG_TYPE_DRV_ID         0x0001
-#define MSG_TYPE_FLAGS          0x0002
-#define MSG_TYPE_STRING         0x0003
-#define MSG_TYPE_BINARY         0x0004
-
-#define MSG_HEAD_SIZE   ((unsigned long)&(((DbgMessage *)0)->data[0]))
-#define MSG_ALIGN(len)  (((unsigned long)(len) + MSG_HEAD_SIZE + 3) & ~3)
-#define MSG_SIZE(pMsg)  MSG_ALIGN((pMsg)->size)
-#define MSG_NEXT(pMsg)  ((DbgMessage *)( ((char *)(pMsg)) + MSG_SIZE(pMsg) ))
-
-#define OLD_MSG_HEAD_SIZE       ((unsigned long)&(((OldDbgMessage *)0)->data[0]))
-#define OLD_MSG_ALIGN(len)      (((unsigned long)(len)+OLD_MSG_HEAD_SIZE+3) & ~3)
-
-/*
- * manifest constants
- */
-
-#define MSG_FRAME_MAX_SIZE      2150            /* maximum size of B1 frame      */
-#define MSG_TEXT_MAX_SIZE       1024            /* maximum size of msg text      */
-#define MSG_MAX_SIZE            MSG_ALIGN(MSG_FRAME_MAX_SIZE)
-#define DBG_MIN_BUFFER_SIZE     0x00008000      /* minimal total buffer size  32 KB */
-#define DBG_DEF_BUFFER_SIZE     0x00020000      /* default total buffer size 128 KB */
-#define DBG_MAX_BUFFER_SIZE     0x00400000      /* maximal total buffer size   4 MB */
-
-#define DBGDRV_NAME             "Diehl_DIMAINT"
-#define UNIDBG_DRIVER   L"\\Device\\Diehl_DIMAINT" /* UNICODE name for kernel */
-#define DEBUG_DRIVER    "\\\\.\\" DBGDRV_NAME  /* traditional string for apps */
-#define DBGVXD_NAME             "DIMAINT"
-#define DEBUG_VXD               "\\\\.\\" DBGVXD_NAME  /* traditional string for apps */
-
-/*
- *      Special IDI interface debug construction
- */
-
-#define DBG_IDI_SIG_REQ         (unsigned long)0xF479C402
-#define DBG_IDI_SIG_IND         (unsigned long)0xF479C403
-#define DBG_IDI_NL_REQ          (unsigned long)0xF479C404
-#define DBG_IDI_NL_IND          (unsigned long)0xF479C405
-
-typedef struct
-{       unsigned long  magic_type ;
-        unsigned short data_len ;
-        unsigned char  layer_ID ;
-        unsigned char  entity_ID ;
-        unsigned char  request ;
-        unsigned char  ret_code ;
-        unsigned char  indication ;
-        unsigned char  complete ;
-        unsigned char  data[4] ;
-} DbgIdiAct, *DbgIdiAction ;
-
-/*
- * We want to use the same IOCTL codes in Win95 and WinNT.
- * The official constructor for IOCTL codes is the CTL_CODE macro
- * from <winoctl.h> (<devioctl.h> in WinNT DDK environment).
- * The problem here is that we don't know how to get <winioctl.h>
- * working in a Win95 DDK environment!
- */
-
-# ifdef CTL_CODE        /*{*/
-
-/* Assert that we have the same idea of the CTL_CODE macro.     */
-
-#define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
-    ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
-)
-
-# else  /* !CTL_CODE */ /*}{*/
-
-/* Use the definitions stolen from <winioctl.h>.  */
-
-#define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
-    ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
-)
-
-#define METHOD_BUFFERED                 0
-#define METHOD_IN_DIRECT                1
-#define METHOD_OUT_DIRECT               2
-#define METHOD_NEITHER                  3
-
-#define FILE_ANY_ACCESS                 0
-#define FILE_READ_ACCESS          ( 0x0001 )    // file & pipe
-#define FILE_WRITE_ACCESS         ( 0x0002 )    // file & pipe
-
-# endif /* CTL_CODE */ /*}*/
-
-/*
- * Now we can define WinNT/Win95 DeviceIoControl codes.
- *
- * These codes are defined in di_defs.h too, a possible mismatch will be
- * detected when the dbgtool is compiled.
- */
-
-#define IOCTL_DRIVER_LNK \
-        CTL_CODE(0x8001U,0x701,METHOD_OUT_DIRECT,FILE_ANY_ACCESS)
-#define IOCTL_DRIVER_DBG \
-        CTL_CODE(0x8001U,0x702,METHOD_OUT_DIRECT,FILE_ANY_ACCESS)
-
-#endif /* __DBGIOCTL_H__ */
diff --git a/drivers/isdn/hardware/eicon/divamnt.c b/drivers/isdn/hardware/eicon/divamnt.c
index 4aba5c502d8e..c90928974249 100644
--- a/drivers/isdn/hardware/eicon/divamnt.c
+++ b/drivers/isdn/hardware/eicon/divamnt.c
@@ -13,7 +13,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
-#include <linux/smp_lock.h>
 #include <linux/poll.h>
 #include <asm/uaccess.h>
 
diff --git a/drivers/isdn/hardware/eicon/divasi.c b/drivers/isdn/hardware/eicon/divasi.c
index 556b19615bc7..78f141e77466 100644
--- a/drivers/isdn/hardware/eicon/divasi.c
+++ b/drivers/isdn/hardware/eicon/divasi.c
@@ -14,7 +14,6 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/smp_lock.h>
 #include <linux/poll.h>
 #include <linux/proc_fs.h>
 #include <linux/skbuff.h>
diff --git a/drivers/isdn/hardware/eicon/divasmain.c b/drivers/isdn/hardware/eicon/divasmain.c
index 5e862e244117..6d39f9360766 100644
--- a/drivers/isdn/hardware/eicon/divasmain.c
+++ b/drivers/isdn/hardware/eicon/divasmain.c
@@ -17,7 +17,6 @@
 #include <linux/ioport.h>
 #include <linux/workqueue.h>
 #include <linux/pci.h>
-#include <linux/smp_lock.h>
 #include <linux/interrupt.h>
 #include <linux/list.h>
 #include <linux/poll.h>
diff --git a/drivers/isdn/hardware/eicon/main_if.h b/drivers/isdn/hardware/eicon/main_if.h
deleted file mode 100644
index 0ea339afd424..000000000000
--- a/drivers/isdn/hardware/eicon/main_if.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- *
-  Copyright (c) Eicon Technology Corporation, 2000.
- *
-  This source file is supplied for the use with Eicon
-  Technology Corporation's range of DIVA Server Adapters.
- *
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2, or (at your option)
-  any later version.
- *
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the GNU General Public License for more details.
- *
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-/*------------------------------------------------------------------*/
-/* file: main_if.h                                                  */
-/*------------------------------------------------------------------*/
-# ifndef MAIN_IF___H
-# define MAIN_IF___H
-
-# include "debug_if.h"
-
-void  DI_lock (void) ;
-void  DI_unlock (void) ;
-
-#ifdef NOT_YET_NEEDED
-void  DI_nttime (LARGE_INTEGER *NTtime) ;
-void  DI_ntlcltime(LARGE_INTEGER *NTtime, LARGE_INTEGER *lclNTtime) ;
-void  DI_nttimefields(LARGE_INTEGER *NTtime, TIME_FIELDS *TimeFields);
-unsigned long  DI_wintime(LARGE_INTEGER *NTtime) ;
-
-unsigned short  DiInsertProcessorNumber (int type) ;
-void DiProcessEventLog (unsigned short id, unsigned long msgID, va_list ap);
-
-void  StartIoctlTimer (void (*Handler)(void), unsigned long msec) ;
-void  StopIoctlTimer (void) ;
-void  UnpendIoctl (DbgRequest *pDbgReq) ;
-#endif
-
-void add_to_q(int, char* , unsigned int);
-# endif /* MAIN_IF___H */
-
diff --git a/drivers/isdn/hardware/eicon/platform.h b/drivers/isdn/hardware/eicon/platform.h
index ff09f07f440a..15d4942de53b 100644
--- a/drivers/isdn/hardware/eicon/platform.h
+++ b/drivers/isdn/hardware/eicon/platform.h
@@ -26,7 +26,6 @@
 #include <linux/vmalloc.h>
 #include <linux/proc_fs.h>
 #include <linux/interrupt.h>
-#include <linux/smp_lock.h>
 #include <linux/delay.h>
 #include <linux/list.h>
 #include <asm/types.h>
diff --git a/drivers/isdn/hisax/hfc_usb.c b/drivers/isdn/hisax/hfc_usb.c
index 9f44d3e69fb0..99e70d4103b6 100644
--- a/drivers/isdn/hisax/hfc_usb.c
+++ b/drivers/isdn/hisax/hfc_usb.c
@@ -37,7 +37,6 @@
 #include <linux/kernel_stat.h>
 #include <linux/usb.h>
 #include <linux/kernel.h>
-#include <linux/smp_lock.h>
 #include "hisax.h"
 #include "hisax_if.h"
 #include "hfc_usb.h"
diff --git a/drivers/isdn/hysdn/boardergo.c b/drivers/isdn/hysdn/boardergo.c
index 84dccd526ac0..6cdbad3a9926 100644
--- a/drivers/isdn/hysdn/boardergo.c
+++ b/drivers/isdn/hysdn/boardergo.c
@@ -443,7 +443,7 @@ ergo_inithardware(hysdn_card * card)
         card->waitpofready = ergo_waitpofready;
         card->set_errlog_state = ergo_set_errlog_state;
         INIT_WORK(&card->irq_queue, ergo_irq_bh);
-        card->hysdn_lock = SPIN_LOCK_UNLOCKED;
+        spin_lock_init(&card->hysdn_lock);
 
         return (0);
 }                               /* ergo_inithardware */
diff --git a/drivers/isdn/hysdn/hysdn_proclog.c b/drivers/isdn/hysdn/hysdn_proclog.c
index 4c7dedac0e51..27b3991fb0ec 100644
--- a/drivers/isdn/hysdn/hysdn_proclog.c
+++ b/drivers/isdn/hysdn/hysdn_proclog.c
@@ -297,8 +297,6 @@ hysdn_log_close(struct inode *ino, struct file *filep)
         struct procdata *pd;
         hysdn_card *card;
         int retval = 0;
-        unsigned long flags;
-        spinlock_t hysdn_lock = SPIN_LOCK_UNLOCKED;
 
         lock_kernel();
         if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
@@ -308,7 +306,6 @@ hysdn_log_close(struct inode *ino, struct file *filep)
                 /* read access -> log/debug read, mark one further file as closed */
 
                 pd = NULL;
-                spin_lock_irqsave(&hysdn_lock, flags);
                 inf = *((struct log_data **) filep->private_data);      /* get first log entry */
                 if (inf)
                         pd = (struct procdata *) inf->proc_ctrl;        /* still entries there */
@@ -331,7 +328,6 @@ hysdn_log_close(struct inode *ino, struct file *filep)
                         inf->usage_cnt--;       /* decrement usage count for buffers */
                         inf = inf->next;
                 }
-                spin_unlock_irqrestore(&hysdn_lock, flags);
 
                 if (pd)
                         if (pd->if_used <= 0)   /* delete buffers if last file closed */
diff --git a/drivers/isdn/isdnloop/isdnloop.c b/drivers/isdn/isdnloop/isdnloop.c
index e93ad59f60bf..bb92e3cd9334 100644
--- a/drivers/isdn/isdnloop/isdnloop.c
+++ b/drivers/isdn/isdnloop/isdnloop.c
@@ -1462,7 +1462,7 @@ isdnloop_initcard(char *id)
                 skb_queue_head_init(&card->bqueue[i]);
         }
         skb_queue_head_init(&card->dqueue);
-        card->isdnloop_lock = SPIN_LOCK_UNLOCKED;
+        spin_lock_init(&card->isdnloop_lock);
         card->next = cards;
         cards = card;
         if (!register_isdn(&card->interface)) {
diff --git a/drivers/macintosh/therm_adt746x.c b/drivers/macintosh/therm_adt746x.c
index 178afa1fd56c..bd55e6ab99fc 100644
--- a/drivers/macintosh/therm_adt746x.c
+++ b/drivers/macintosh/therm_adt746x.c
@@ -19,7 +19,6 @@
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/wait.h>
 #include <linux/suspend.h>
 #include <linux/kthread.h>
diff --git a/drivers/macintosh/therm_pm72.c b/drivers/macintosh/therm_pm72.c
index 78ff18617139..dbb22403979f 100644
--- a/drivers/macintosh/therm_pm72.c
+++ b/drivers/macintosh/therm_pm72.c
@@ -117,7 +117,6 @@
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/wait.h>
 #include <linux/reboot.h>
 #include <linux/kmod.h>
diff --git a/drivers/macintosh/windfarm_core.c b/drivers/macintosh/windfarm_core.c
index 94c117ef20c1..192b26e97777 100644
--- a/drivers/macintosh/windfarm_core.c
+++ b/drivers/macintosh/windfarm_core.c
@@ -27,7 +27,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/kthread.h>
 #include <linux/jiffies.h>
 #include <linux/reboot.h>
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index e61e0efe9ec7..5a4a74c1097c 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -1456,10 +1456,10 @@ int bitmap_create(mddev_t *mddev)
         bitmap->offset = mddev->bitmap_offset;
         if (file) {
                 get_file(file);
-                do_sync_file_range(file, 0, LLONG_MAX,
-                                   SYNC_FILE_RANGE_WAIT_BEFORE |
-                                   SYNC_FILE_RANGE_WRITE |
-                                   SYNC_FILE_RANGE_WAIT_AFTER);
+                do_sync_mapping_range(file->f_mapping, 0, LLONG_MAX,
+                                      SYNC_FILE_RANGE_WAIT_BEFORE |
+                                      SYNC_FILE_RANGE_WRITE |
+                                      SYNC_FILE_RANGE_WAIT_AFTER);
         }
         /* read superblock from bitmap file (this sets bitmap->chunksize) */
         err = bitmap_read_sb(bitmap);
diff --git a/drivers/media/dvb/bt8xx/dst_common.h b/drivers/media/dvb/bt8xx/dst_common.h
index 3bf084f2e522..87623d203a89 100644
--- a/drivers/media/dvb/bt8xx/dst_common.h
+++ b/drivers/media/dvb/bt8xx/dst_common.h
@@ -22,7 +22,6 @@
 #ifndef DST_COMMON_H
 #define DST_COMMON_H
 
-#include <linux/smp_lock.h>
 #include <linux/dvb/frontend.h>
 #include <linux/device.h>
 #include <linux/mutex.h>
diff --git a/drivers/media/dvb/ttpci/av7110_av.c b/drivers/media/dvb/ttpci/av7110_av.c
index 654c9e919e04..58678c05aa53 100644
--- a/drivers/media/dvb/ttpci/av7110_av.c
+++ b/drivers/media/dvb/ttpci/av7110_av.c
@@ -32,7 +32,6 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/delay.h>
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 
 #include "av7110.h"
diff --git a/drivers/media/dvb/ttpci/av7110_ca.c b/drivers/media/dvb/ttpci/av7110_ca.c
index e9b4e88e7932..e1c1294bb767 100644
--- a/drivers/media/dvb/ttpci/av7110_ca.c
+++ b/drivers/media/dvb/ttpci/av7110_ca.c
@@ -34,7 +34,6 @@
 #include <linux/fs.h>
 #include <linux/timer.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 
 #include "av7110.h"
 #include "av7110_hw.h"
diff --git a/drivers/media/dvb/ttpci/av7110_hw.c b/drivers/media/dvb/ttpci/av7110_hw.c
index 4d7150e15d1e..70aee4eb5da4 100644
--- a/drivers/media/dvb/ttpci/av7110_hw.c
+++ b/drivers/media/dvb/ttpci/av7110_hw.c
@@ -33,7 +33,6 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/delay.h>
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 
 #include "av7110.h"
diff --git a/drivers/media/dvb/ttpci/av7110_v4l.c b/drivers/media/dvb/ttpci/av7110_v4l.c
index cde5d3ae7ec7..fcd9994058d0 100644
--- a/drivers/media/dvb/ttpci/av7110_v4l.c
+++ b/drivers/media/dvb/ttpci/av7110_v4l.c
@@ -31,7 +31,6 @@
 #include <linux/fs.h>
 #include <linux/timer.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 
 #include "av7110.h"
 #include "av7110_hw.h"
diff --git a/drivers/media/radio/dsbr100.c b/drivers/media/radio/dsbr100.c
index df8d0520d1d1..449df1bb00d3 100644
--- a/drivers/media/radio/dsbr100.c
+++ b/drivers/media/radio/dsbr100.c
@@ -79,7 +79,6 @@
 #include <linux/videodev2.h>
 #include <media/v4l2-common.h>
 #include <linux/usb.h>
-#include <linux/smp_lock.h>
 
 /*
  * Version Information
diff --git a/drivers/media/video/cpia.h b/drivers/media/video/cpia.h
index 6eaa692021c5..78392fb6f94e 100644
--- a/drivers/media/video/cpia.h
+++ b/drivers/media/video/cpia.h
@@ -47,7 +47,6 @@
 #include <linux/videodev.h>
 #include <media/v4l2-common.h>
 #include <linux/list.h>
-#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 
 struct cpia_camera_ops
diff --git a/drivers/media/video/cpia_pp.c b/drivers/media/video/cpia_pp.c
index 19711aaf9a3e..c431df8248d6 100644
--- a/drivers/media/video/cpia_pp.c
+++ b/drivers/media/video/cpia_pp.c
@@ -34,7 +34,6 @@
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/workqueue.h>
-#include <linux/smp_lock.h>
 #include <linux/sched.h>
 
 #include <linux/kmod.h>
diff --git a/drivers/media/video/cx88/cx88-tvaudio.c b/drivers/media/video/cx88/cx88-tvaudio.c
index e627062fde3a..259ea08e784f 100644
--- a/drivers/media/video/cx88/cx88-tvaudio.c
+++ b/drivers/media/video/cx88/cx88-tvaudio.c
@@ -49,7 +49,6 @@
 #include <linux/interrupt.h>
 #include <linux/vmalloc.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
 
diff --git a/drivers/media/video/dabusb.c b/drivers/media/video/dabusb.c
index ff4b238090ac..a5731f90be0f 100644
--- a/drivers/media/video/dabusb.c
+++ b/drivers/media/video/dabusb.c
@@ -37,7 +37,6 @@
 #include <asm/atomic.h>
 #include <linux/delay.h>
 #include <linux/usb.h>
-#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 
 #include "dabusb.h"
diff --git a/drivers/media/video/ov511.h b/drivers/media/video/ov511.h
index 68b082bcee1d..18c64222dd11 100644
--- a/drivers/media/video/ov511.h
+++ b/drivers/media/video/ov511.h
@@ -4,7 +4,6 @@
 #include <asm/uaccess.h>
 #include <linux/videodev.h>
 #include <media/v4l2-common.h>
-#include <linux/smp_lock.h>
 #include <linux/usb.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/media/video/pvrusb2/pvrusb2-main.c b/drivers/media/video/pvrusb2/pvrusb2-main.c
index e976c484c058..9ea41c6699bb 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-main.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-main.c
@@ -25,7 +25,6 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
-#include <linux/smp_lock.h>
 #include <linux/usb.h>
 #include <linux/videodev2.h>
 
diff --git a/drivers/media/video/saa7134/saa7134-tvaudio.c b/drivers/media/video/saa7134/saa7134-tvaudio.c
index dd759d6d8d25..7b56041186dc 100644
--- a/drivers/media/video/saa7134/saa7134-tvaudio.c
+++ b/drivers/media/video/saa7134/saa7134-tvaudio.c
@@ -27,7 +27,6 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
-#include <linux/smp_lock.h>
 #include <asm/div64.h>
 
 #include "saa7134-reg.h"
diff --git a/drivers/media/video/se401.h b/drivers/media/video/se401.h
index c0891b3e0018..835ef872e803 100644
--- a/drivers/media/video/se401.h
+++ b/drivers/media/video/se401.h
@@ -5,7 +5,6 @@
 #include <asm/uaccess.h>
 #include <linux/videodev.h>
 #include <media/v4l2-common.h>
-#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 
 #define se401_DEBUG     /* Turn on debug messages */
diff --git a/drivers/media/video/tvaudio.c b/drivers/media/video/tvaudio.c
index a2da5d2affff..c9bf9dbc2ea3 100644
--- a/drivers/media/video/tvaudio.c
+++ b/drivers/media/video/tvaudio.c
@@ -26,7 +26,6 @@
 #include <linux/videodev.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/kthread.h>
 #include <linux/freezer.h>
 
diff --git a/drivers/media/video/usbvideo/usbvideo.c b/drivers/media/video/usbvideo/usbvideo.c
index 687f026753b2..37ce36b9e587 100644
--- a/drivers/media/video/usbvideo/usbvideo.c
+++ b/drivers/media/video/usbvideo/usbvideo.c
@@ -20,7 +20,6 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/vmalloc.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
diff --git a/drivers/media/video/usbvision/usbvision-core.c b/drivers/media/video/usbvision/usbvision-core.c
index bcb551adb7e6..9118a6227ea6 100644
--- a/drivers/media/video/usbvision/usbvision-core.c
+++ b/drivers/media/video/usbvision/usbvision-core.c
@@ -30,7 +30,6 @@
 #include <linux/mm.h>
 #include <linux/utsname.h>
 #include <linux/highmem.h>
-#include <linux/smp_lock.h>
 #include <linux/videodev.h>
 #include <linux/vmalloc.h>
 #include <linux/module.h>
diff --git a/drivers/media/video/usbvision/usbvision-video.c b/drivers/media/video/usbvision/usbvision-video.c
index 216704170a4c..aa3258bbb4af 100644
--- a/drivers/media/video/usbvision/usbvision-video.c
+++ b/drivers/media/video/usbvision/usbvision-video.c
@@ -52,7 +52,6 @@
 #include <linux/mm.h>
 #include <linux/utsname.h>
 #include <linux/highmem.h>
-#include <linux/smp_lock.h>
 #include <linux/videodev.h>
 #include <linux/vmalloc.h>
 #include <linux/module.h>
diff --git a/drivers/media/video/v4l1-compat.c b/drivers/media/video/v4l1-compat.c
index d2c1ae0dbfba..a861e150865e 100644
--- a/drivers/media/video/v4l1-compat.c
+++ b/drivers/media/video/v4l1-compat.c
@@ -23,7 +23,6 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/smp_lock.h>
 #include <linux/mm.h>
 #include <linux/fs.h>
 #include <linux/file.h>
diff --git a/drivers/media/video/v4l2-common.c b/drivers/media/video/v4l2-common.c
index 49f1df74aa21..13ee550d3215 100644
--- a/drivers/media/video/v4l2-common.c
+++ b/drivers/media/video/v4l2-common.c
@@ -47,7 +47,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/smp_lock.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/errno.h>
diff --git a/drivers/media/video/videodev.c b/drivers/media/video/videodev.c
index 80ac5f86d9e5..5263b50463e1 100644
--- a/drivers/media/video/videodev.c
+++ b/drivers/media/video/videodev.c
@@ -30,7 +30,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/smp_lock.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/errno.h>
diff --git a/drivers/media/video/zoran_driver.c b/drivers/media/video/zoran_driver.c
index 074323733352..cf0ed6cbb0e3 100644
--- a/drivers/media/video/zoran_driver.c
+++ b/drivers/media/video/zoran_driver.c
@@ -2034,7 +2034,7 @@ zoran_do_ioctl (struct inode *inode,
          * but moving the free code outside the munmap() handler fixes
          * all this... If someone knows why, please explain me (Ronald)
          */
-        if (!!mutex_trylock(&zr->resource_lock)) {
+        if (mutex_trylock(&zr->resource_lock)) {
                 /* we obtained it! Let's try to free some things */
                 if (fh->jpg_buffers.ready_to_be_freed)
                         jpg_fbuffer_free(file);
diff --git a/drivers/message/i2o/i2o_lan.h b/drivers/message/i2o/i2o_lan.h
deleted file mode 100644
index 6502b817df58..000000000000
--- a/drivers/message/i2o/i2o_lan.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- *      i2o_lan.h                       I2O LAN Class definitions
- *
- *      I2O LAN CLASS OSM               May 26th 2000
- *
- *      (C) Copyright 1999, 2000        University of Helsinki,
- *                                      Department of Computer Science
- *
- *      This code is still under development / test.
- *
- *      Author:         Auvo Häkkinen <Auvo.Hakkinen@cs.Helsinki.FI>
- *                      Juha Sievänen <Juha.Sievanen@cs.Helsinki.FI>
- *                      Taneli Vähäkangas <Taneli.Vahakangas@cs.Helsinki.FI>
- */
-
-#ifndef _I2O_LAN_H
-#define _I2O_LAN_H
-
-/* Default values for tunable parameters first */
-
-#define I2O_LAN_MAX_BUCKETS_OUT 96
-#define I2O_LAN_BUCKET_THRESH   18      /* 9 buckets in one message */
-#define I2O_LAN_RX_COPYBREAK    200
-#define I2O_LAN_TX_TIMEOUT      (1*HZ)
-#define I2O_LAN_TX_BATCH_MODE   2       /* 2=automatic, 1=on, 0=off */
-#define I2O_LAN_EVENT_MASK      0       /* 0=None, 0xFFC00002=All */
-
-/* LAN types */
-#define I2O_LAN_ETHERNET        0x0030
-#define I2O_LAN_100VG           0x0040
-#define I2O_LAN_TR              0x0050
-#define I2O_LAN_FDDI            0x0060
-#define I2O_LAN_FIBRE_CHANNEL   0x0070
-#define I2O_LAN_UNKNOWN         0x00000000
-
-/* Connector types */
-
-/* Ethernet */
-#define I2O_LAN_AUI             (I2O_LAN_ETHERNET << 4) + 0x00000001
-#define I2O_LAN_10BASE5         (I2O_LAN_ETHERNET << 4) + 0x00000002
-#define I2O_LAN_FIORL           (I2O_LAN_ETHERNET << 4) + 0x00000003
-#define I2O_LAN_10BASE2         (I2O_LAN_ETHERNET << 4) + 0x00000004
-#define I2O_LAN_10BROAD36       (I2O_LAN_ETHERNET << 4) + 0x00000005
-#define I2O_LAN_10BASE_T        (I2O_LAN_ETHERNET << 4) + 0x00000006
-#define I2O_LAN_10BASE_FP       (I2O_LAN_ETHERNET << 4) + 0x00000007
-#define I2O_LAN_10BASE_FB       (I2O_LAN_ETHERNET << 4) + 0x00000008
-#define I2O_LAN_10BASE_FL       (I2O_LAN_ETHERNET << 4) + 0x00000009
-#define I2O_LAN_100BASE_TX      (I2O_LAN_ETHERNET << 4) + 0x0000000A
-#define I2O_LAN_100BASE_FX      (I2O_LAN_ETHERNET << 4) + 0x0000000B
-#define I2O_LAN_100BASE_T4      (I2O_LAN_ETHERNET << 4) + 0x0000000C
-#define I2O_LAN_1000BASE_SX     (I2O_LAN_ETHERNET << 4) + 0x0000000D
-#define I2O_LAN_1000BASE_LX     (I2O_LAN_ETHERNET << 4) + 0x0000000E
-#define I2O_LAN_1000BASE_CX     (I2O_LAN_ETHERNET << 4) + 0x0000000F
-#define I2O_LAN_1000BASE_T      (I2O_LAN_ETHERNET << 4) + 0x00000010
-
-/* AnyLAN */
-#define I2O_LAN_100VG_ETHERNET  (I2O_LAN_100VG << 4) + 0x00000001
-#define I2O_LAN_100VG_TR        (I2O_LAN_100VG << 4) + 0x00000002
-
-/* Token Ring */
-#define I2O_LAN_4MBIT           (I2O_LAN_TR << 4) + 0x00000001
-#define I2O_LAN_16MBIT          (I2O_LAN_TR << 4) + 0x00000002
-
-/* FDDI */
-#define I2O_LAN_125MBAUD        (I2O_LAN_FDDI << 4) + 0x00000001
-
-/* Fibre Channel */
-#define I2O_LAN_POINT_POINT     (I2O_LAN_FIBRE_CHANNEL << 4) + 0x00000001
-#define I2O_LAN_ARB_LOOP        (I2O_LAN_FIBRE_CHANNEL << 4) + 0x00000002
-#define I2O_LAN_PUBLIC_LOOP     (I2O_LAN_FIBRE_CHANNEL << 4) + 0x00000003
-#define I2O_LAN_FABRIC          (I2O_LAN_FIBRE_CHANNEL << 4) + 0x00000004
-
-#define I2O_LAN_EMULATION       0x00000F00
-#define I2O_LAN_OTHER           0x00000F01
-#define I2O_LAN_DEFAULT         0xFFFFFFFF
-
-/* LAN class functions */
-
-#define LAN_PACKET_SEND         0x3B
-#define LAN_SDU_SEND            0x3D
-#define LAN_RECEIVE_POST        0x3E
-#define LAN_RESET               0x35
-#define LAN_SUSPEND             0x37
-
-/* LAN DetailedStatusCode defines */
-#define I2O_LAN_DSC_SUCCESS                     0x00
-#define I2O_LAN_DSC_DEVICE_FAILURE              0x01
-#define I2O_LAN_DSC_DESTINATION_NOT_FOUND       0x02
-#define I2O_LAN_DSC_TRANSMIT_ERROR              0x03
-#define I2O_LAN_DSC_TRANSMIT_ABORTED            0x04
-#define I2O_LAN_DSC_RECEIVE_ERROR               0x05
-#define I2O_LAN_DSC_RECEIVE_ABORTED             0x06
-#define I2O_LAN_DSC_DMA_ERROR                   0x07
-#define I2O_LAN_DSC_BAD_PACKET_DETECTED         0x08
-#define I2O_LAN_DSC_OUT_OF_MEMORY               0x09
-#define I2O_LAN_DSC_BUCKET_OVERRUN              0x0A
-#define I2O_LAN_DSC_IOP_INTERNAL_ERROR          0x0B
-#define I2O_LAN_DSC_CANCELED                    0x0C
-#define I2O_LAN_DSC_INVALID_TRANSACTION_CONTEXT 0x0D
-#define I2O_LAN_DSC_DEST_ADDRESS_DETECTED       0x0E
-#define I2O_LAN_DSC_DEST_ADDRESS_OMITTED        0x0F
-#define I2O_LAN_DSC_PARTIAL_PACKET_RETURNED     0x10
-#define I2O_LAN_DSC_SUSPENDED                   0x11
-
-struct i2o_packet_info {
-        u32 offset:24;
-        u32 flags:8;
-        u32 len:24;
-        u32 status:8;
-};
-
-struct i2o_bucket_descriptor {
-        u32 context;            /* FIXME: 64bit support */
-        struct i2o_packet_info packet_info[1];
-};
-
-/* Event Indicator Mask Flags for LAN OSM */
-
-#define I2O_LAN_EVT_LINK_DOWN           0x01
-#define I2O_LAN_EVT_LINK_UP             0x02
-#define I2O_LAN_EVT_MEDIA_CHANGE        0x04
-
-#include <linux/netdevice.h>
-#include <linux/fddidevice.h>
-
-struct i2o_lan_local {
-        u8 unit;
-        struct i2o_device *i2o_dev;
-
-        struct fddi_statistics stats;   /* see also struct net_device_stats */
-        unsigned short (*type_trans) (struct sk_buff *, struct net_device *);
-        atomic_t buckets_out;   /* nbr of unused buckets on DDM */
-        atomic_t tx_out;        /* outstanding TXes */
-        u8 tx_count;            /* packets in one TX message frame */
-        u16 tx_max_out;         /* DDM's Tx queue len */
-        u8 sgl_max;             /* max SGLs in one message frame */
-        u32 m;                  /* IOP address of the batch msg frame */
-
-        struct work_struct i2o_batch_send_task;
-        int send_active;
-        struct sk_buff **i2o_fbl;       /* Free bucket list (to reuse skbs) */
-        int i2o_fbl_tail;
-        spinlock_t fbl_lock;
-
-        spinlock_t tx_lock;
-
-        u32 max_size_mc_table;  /* max number of multicast addresses */
-
-        /* LAN OSM configurable parameters are here: */
-
-        u16 max_buckets_out;    /* max nbr of buckets to send to DDM */
-        u16 bucket_thresh;      /* send more when this many used */
-        u16 rx_copybreak;
-
-        u8 tx_batch_mode;       /* Set when using batch mode sends */
-        u32 i2o_event_mask;     /* To turn on interesting event flags */
-};
-
-#endif                          /* _I2O_LAN_H */
diff --git a/drivers/mfd/ucb1x00-ts.c b/drivers/mfd/ucb1x00-ts.c
index ce1a48108210..cb8c264eaff0 100644
--- a/drivers/mfd/ucb1x00-ts.c
+++ b/drivers/mfd/ucb1x00-ts.c
@@ -21,7 +21,6 @@
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/sched.h>
 #include <linux/completion.h>
 #include <linux/delay.h>
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index a3c525b2616a..877e7909a0e5 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -25,6 +25,15 @@ config IBM_ASM
           information on the specific driver level and support statement
           for your IBM server.
 
+config PHANTOM
+        tristate "Sensable PHANToM"
+        depends on PCI
+        help
+          Say Y here if you want to build a driver for Sensable PHANToM device.
+
+          If you choose to build module, its name will be phantom. If unsure,
+          say N here.
+
 
           If unsure, say N.
 
@@ -178,4 +187,13 @@ config THINKPAD_ACPI_BAY
 
           If you are not sure, say Y here.
 
+config BLINK
+        tristate "Keyboard blink driver"
+        help
+          Driver that when loaded will blink the keyboard LEDs continuously.
+          This is useful for debugging and for kernels that cannot necessarily
+          output something to the screen like kexec kernels to give the user
+          a visual indication that the kernel is doing something.
+
+
 endmenu
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index e32516459138..5b6d46de005c 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -7,9 +7,11 @@ obj-$(CONFIG_IBM_ASM)		+= ibmasm/
 obj-$(CONFIG_HDPU_FEATURES)     += hdpuftrs/
 obj-$(CONFIG_MSI_LAPTOP)     += msi-laptop.o
 obj-$(CONFIG_ASUS_LAPTOP)     += asus-laptop.o
+obj-$(CONFIG_BLINK)             += blink.o
 obj-$(CONFIG_LKDTM)             += lkdtm.o
 obj-$(CONFIG_TIFM_CORE)         += tifm_core.o
 obj-$(CONFIG_TIFM_7XX1)         += tifm_7xx1.o
+obj-$(CONFIG_PHANTOM)           += phantom.o
 obj-$(CONFIG_SGI_IOC4)          += ioc4.o
 obj-$(CONFIG_SONY_LAPTOP)       += sony-laptop.o
 obj-$(CONFIG_THINKPAD_ACPI)     += thinkpad_acpi.o
diff --git a/drivers/misc/blink.c b/drivers/misc/blink.c
new file mode 100644
index 000000000000..634431ce1184
--- /dev/null
+++ b/drivers/misc/blink.c
@@ -0,0 +1,27 @@
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/timer.h>
+#include <linux/jiffies.h>
+
+static void do_blink(unsigned long data);
+
+static DEFINE_TIMER(blink_timer, do_blink, 0 ,0);
+
+static void do_blink(unsigned long data)
+{
+        static long count;
+        if (panic_blink)
+                panic_blink(count++);
+        blink_timer.expires = jiffies + msecs_to_jiffies(1);
+        add_timer(&blink_timer);
+}
+
+static int blink_init(void)
+{
+        printk(KERN_INFO "Enabling keyboard blinking\n");
+        do_blink(0);
+        return 0;
+}
+
+module_init(blink_init);
+
diff --git a/drivers/misc/phantom.c b/drivers/misc/phantom.c
new file mode 100644
index 000000000000..35b139b0e5f2
--- /dev/null
+++ b/drivers/misc/phantom.c
@@ -0,0 +1,463 @@
+/*
+ *  Copyright (C) 2005-2007 Jiri Slaby <jirislaby@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  You need an userspace library to cooperate with this driver. It (and other
+ *  info) may be obtained here:
+ *  http://www.fi.muni.cz/~xslaby/phantom.html
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/pci.h>
+#include <linux/fs.h>
+#include <linux/poll.h>
+#include <linux/interrupt.h>
+#include <linux/cdev.h>
+#include <linux/phantom.h>
+
+#include <asm/atomic.h>
+#include <asm/io.h>
+
+#define PHANTOM_VERSION         "n0.9.5"
+
+#define PHANTOM_MAX_MINORS      8
+
+#define PHN_IRQCTL              0x4c    /* irq control in caddr space */
+
+#define PHB_RUNNING             1
+
+static struct class *phantom_class;
+static int phantom_major;
+
+struct phantom_device {
+        unsigned int opened;
+        void __iomem *caddr;
+        u32 __iomem *iaddr;
+        u32 __iomem *oaddr;
+        unsigned long status;
+        atomic_t counter;
+
+        wait_queue_head_t wait;
+        struct cdev cdev;
+
+        struct mutex open_lock;
+};
+
+static unsigned char phantom_devices[PHANTOM_MAX_MINORS];
+
+static int phantom_status(struct phantom_device *dev, unsigned long newstat)
+{
+        pr_debug("phantom_status %lx %lx\n", dev->status, newstat);
+
+        if (!(dev->status & PHB_RUNNING) && (newstat & PHB_RUNNING)) {
+                atomic_set(&dev->counter, 0);
+                iowrite32(PHN_CTL_IRQ, dev->iaddr + PHN_CONTROL);
+                iowrite32(0x43, dev->caddr + PHN_IRQCTL);
+        } else if ((dev->status & PHB_RUNNING) && !(newstat & PHB_RUNNING))
+                iowrite32(0, dev->caddr + PHN_IRQCTL);
+
+        dev->status = newstat;
+
+        return 0;
+}
+
+/*
+ * File ops
+ */
+
+static int phantom_ioctl(struct inode *inode, struct file *file, u_int cmd,
+        u_long arg)
+{
+        struct phantom_device *dev = file->private_data;
+        struct phm_regs rs;
+        struct phm_reg r;
+        void __user *argp = (void __user *)arg;
+        unsigned int i;
+
+        if (_IOC_TYPE(cmd) != PH_IOC_MAGIC ||
+                        _IOC_NR(cmd) > PH_IOC_MAXNR)
+                return -ENOTTY;
+
+        switch (cmd) {
+        case PHN_SET_REG:
+                if (copy_from_user(&r, argp, sizeof(r)))
+                        return -EFAULT;
+
+                if (r.reg > 7)
+                        return -EINVAL;
+
+                if (r.reg == PHN_CONTROL && (r.value & PHN_CTL_IRQ) &&
+                                phantom_status(dev, dev->status | PHB_RUNNING))
+                        return -ENODEV;
+
+                pr_debug("phantom: writing %x to %u\n", r.value, r.reg);
+                iowrite32(r.value, dev->iaddr + r.reg);
+
+                if (r.reg == PHN_CONTROL && !(r.value & PHN_CTL_IRQ))
+                        phantom_status(dev, dev->status & ~PHB_RUNNING);
+                break;
+        case PHN_SET_REGS:
+                if (copy_from_user(&rs, argp, sizeof(rs)))
+                        return -EFAULT;
+
+                pr_debug("phantom: SRS %u regs %x\n", rs.count, rs.mask);
+                for (i = 0; i < min(rs.count, 8U); i++)
+                        if ((1 << i) & rs.mask)
+                                iowrite32(rs.values[i], dev->oaddr + i);
+                break;
+        case PHN_GET_REG:
+                if (copy_from_user(&r, argp, sizeof(r)))
+                        return -EFAULT;
+
+                if (r.reg > 7)
+                        return -EINVAL;
+
+                r.value = ioread32(dev->iaddr + r.reg);
+
+                if (copy_to_user(argp, &r, sizeof(r)))
+                        return -EFAULT;
+                break;
+        case PHN_GET_REGS:
+                if (copy_from_user(&rs, argp, sizeof(rs)))
+                        return -EFAULT;
+
+                pr_debug("phantom: GRS %u regs %x\n", rs.count, rs.mask);
+                for (i = 0; i < min(rs.count, 8U); i++)
+                        if ((1 << i) & rs.mask)
+                                rs.values[i] = ioread32(dev->iaddr + i);
+
+                if (copy_to_user(argp, &rs, sizeof(rs)))
+                        return -EFAULT;
+                break;
+        default:
+                return -ENOTTY;
+        }
+
+        return 0;
+}
+
+static int phantom_open(struct inode *inode, struct file *file)
+{
+        struct phantom_device *dev = container_of(inode->i_cdev,
+                        struct phantom_device, cdev);
+
+        nonseekable_open(inode, file);
+
+        if (mutex_lock_interruptible(&dev->open_lock))
+                return -ERESTARTSYS;
+
+        if (dev->opened) {
+                mutex_unlock(&dev->open_lock);
+                return -EINVAL;
+        }
+
+        file->private_data = dev;
+
+        dev->opened++;
+        mutex_unlock(&dev->open_lock);
+
+        return 0;
+}
+
+static int phantom_release(struct inode *inode, struct file *file)
+{
+        struct phantom_device *dev = file->private_data;
+
+        mutex_lock(&dev->open_lock);
+
+        dev->opened = 0;
+        phantom_status(dev, dev->status & ~PHB_RUNNING);
+
+        mutex_unlock(&dev->open_lock);
+
+        return 0;
+}
+
+static unsigned int phantom_poll(struct file *file, poll_table *wait)
+{
+        struct phantom_device *dev = file->private_data;
+        unsigned int mask = 0;
+
+        pr_debug("phantom_poll: %d\n", atomic_read(&dev->counter));
+        poll_wait(file, &dev->wait, wait);
+        if (atomic_read(&dev->counter)) {
+                mask = POLLIN | POLLRDNORM;
+                atomic_dec(&dev->counter);
+        } else if ((dev->status & PHB_RUNNING) == 0)
+                mask = POLLIN | POLLRDNORM | POLLERR;
+        pr_debug("phantom_poll end: %x/%d\n", mask, atomic_read(&dev->counter));
+
+        return mask;
+}
+
+static struct file_operations phantom_file_ops = {
+        .open = phantom_open,
+        .release = phantom_release,
+        .ioctl = phantom_ioctl,
+        .poll = phantom_poll,
+};
+
+static irqreturn_t phantom_isr(int irq, void *data)
+{
+        struct phantom_device *dev = data;
+
+        if (!(ioread32(dev->iaddr + PHN_CONTROL) & PHN_CTL_IRQ))
+                return IRQ_NONE;
+
+        iowrite32(0, dev->iaddr);
+        iowrite32(0xc0, dev->iaddr);
+
+        atomic_inc(&dev->counter);
+        wake_up_interruptible(&dev->wait);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * Init and deinit driver
+ */
+
+static unsigned int __devinit phantom_get_free(void)
+{
+        unsigned int i;
+
+        for (i = 0; i < PHANTOM_MAX_MINORS; i++)
+                if (phantom_devices[i] == 0)
+                        break;
+
+        return i;
+}
+
+static int __devinit phantom_probe(struct pci_dev *pdev,
+        const struct pci_device_id *pci_id)
+{
+        struct phantom_device *pht;
+        unsigned int minor;
+        int retval;
+
+        retval = pci_enable_device(pdev);
+        if (retval)
+                goto err;
+
+        minor = phantom_get_free();
+        if (minor == PHANTOM_MAX_MINORS) {
+                dev_err(&pdev->dev, "too many devices found!\n");
+                retval = -EIO;
+                goto err_dis;
+        }
+
+        phantom_devices[minor] = 1;
+
+        retval = pci_request_regions(pdev, "phantom");
+        if (retval)
+                goto err_null;
+
+        retval = -ENOMEM;
+        pht = kzalloc(sizeof(*pht), GFP_KERNEL);
+        if (pht == NULL) {
+                dev_err(&pdev->dev, "unable to allocate device\n");
+                goto err_reg;
+        }
+
+        pht->caddr = pci_iomap(pdev, 0, 0);
+        if (pht->caddr == NULL) {
+                dev_err(&pdev->dev, "can't remap conf space\n");
+                goto err_fr;
+        }
+        pht->iaddr = pci_iomap(pdev, 2, 0);
+        if (pht->iaddr == NULL) {
+                dev_err(&pdev->dev, "can't remap input space\n");
+                goto err_unmc;
+        }
+        pht->oaddr = pci_iomap(pdev, 3, 0);
+        if (pht->oaddr == NULL) {
+                dev_err(&pdev->dev, "can't remap output space\n");
+                goto err_unmi;
+        }
+
+        mutex_init(&pht->open_lock);
+        init_waitqueue_head(&pht->wait);
+        cdev_init(&pht->cdev, &phantom_file_ops);
+        pht->cdev.owner = THIS_MODULE;
+
+        iowrite32(0, pht->caddr + PHN_IRQCTL);
+        retval = request_irq(pdev->irq, phantom_isr,
+                        IRQF_SHARED | IRQF_DISABLED, "phantom", pht);
+        if (retval) {
+                dev_err(&pdev->dev, "can't establish ISR\n");
+                goto err_unmo;
+        }
+
+        retval = cdev_add(&pht->cdev, MKDEV(phantom_major, minor), 1);
+        if (retval) {
+                dev_err(&pdev->dev, "chardev registration failed\n");
+                goto err_irq;
+        }
+
+        if (IS_ERR(device_create(phantom_class, &pdev->dev, MKDEV(phantom_major,
+                        minor), "phantom%u", minor)))
+                dev_err(&pdev->dev, "can't create device\n");
+
+        pci_set_drvdata(pdev, pht);
+
+        return 0;
+err_irq:
+        free_irq(pdev->irq, pht);
+err_unmo:
+        pci_iounmap(pdev, pht->oaddr);
+err_unmi:
+        pci_iounmap(pdev, pht->iaddr);
+err_unmc:
+        pci_iounmap(pdev, pht->caddr);
+err_fr:
+        kfree(pht);
+err_reg:
+        pci_release_regions(pdev);
+err_null:
+        phantom_devices[minor] = 0;
+err_dis:
+        pci_disable_device(pdev);
+err:
+        return retval;
+}
+
+static void __devexit phantom_remove(struct pci_dev *pdev)
+{
+        struct phantom_device *pht = pci_get_drvdata(pdev);
+        unsigned int minor = MINOR(pht->cdev.dev);
+
+        device_destroy(phantom_class, MKDEV(phantom_major, minor));
+
+        cdev_del(&pht->cdev);
+
+        iowrite32(0, pht->caddr + PHN_IRQCTL);
+        free_irq(pdev->irq, pht);
+
+        pci_iounmap(pdev, pht->oaddr);
+        pci_iounmap(pdev, pht->iaddr);
+        pci_iounmap(pdev, pht->caddr);
+
+        kfree(pht);
+
+        pci_release_regions(pdev);
+
+        phantom_devices[minor] = 0;
+
+        pci_disable_device(pdev);
+}
+
+#ifdef CONFIG_PM
+static int phantom_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        struct phantom_device *dev = pci_get_drvdata(pdev);
+
+        iowrite32(0, dev->caddr + PHN_IRQCTL);
+
+        return 0;
+}
+
+static int phantom_resume(struct pci_dev *pdev)
+{
+        struct phantom_device *dev = pci_get_drvdata(pdev);
+
+        iowrite32(0, dev->caddr + PHN_IRQCTL);
+
+        return 0;
+}
+#else
+#define phantom_suspend NULL
+#define phantom_resume  NULL
+#endif
+
+static struct pci_device_id phantom_pci_tbl[] __devinitdata = {
+        { PCI_DEVICE(PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050),
+                .class = PCI_CLASS_BRIDGE_OTHER << 8, .class_mask = 0xffff00 },
+        { 0, }
+};
+MODULE_DEVICE_TABLE(pci, phantom_pci_tbl);
+
+static struct pci_driver phantom_pci_driver = {
+        .name = "phantom",
+        .id_table = phantom_pci_tbl,
+        .probe = phantom_probe,
+        .remove = __devexit_p(phantom_remove),
+        .suspend = phantom_suspend,
+        .resume = phantom_resume
+};
+
+static ssize_t phantom_show_version(struct class *cls, char *buf)
+{
+        return sprintf(buf, PHANTOM_VERSION "\n");
+}
+
+static CLASS_ATTR(version, 0444, phantom_show_version, NULL);
+
+static int __init phantom_init(void)
+{
+        int retval;
+        dev_t dev;
+
+        phantom_class = class_create(THIS_MODULE, "phantom");
+        if (IS_ERR(phantom_class)) {
+                retval = PTR_ERR(phantom_class);
+                printk(KERN_ERR "phantom: can't register phantom class\n");
+                goto err;
+        }
+        retval = class_create_file(phantom_class, &class_attr_version);
+        if (retval) {
+                printk(KERN_ERR "phantom: can't create sysfs version file\n");
+                goto err_class;
+        }
+
+        retval = alloc_chrdev_region(&dev, 0, PHANTOM_MAX_MINORS, "phantom");
+        if (retval) {
+                printk(KERN_ERR "phantom: can't register character device\n");
+                goto err_attr;
+        }
+        phantom_major = MAJOR(dev);
+
+        retval = pci_register_driver(&phantom_pci_driver);
+        if (retval) {
+                printk(KERN_ERR "phantom: can't register pci driver\n");
+                goto err_unchr;
+        }
+
+        printk(KERN_INFO "Phantom Linux Driver, version " PHANTOM_VERSION ", "
+                        "init OK\n");
+
+        return 0;
+err_unchr:
+        unregister_chrdev_region(dev, PHANTOM_MAX_MINORS);
+err_attr:
+        class_remove_file(phantom_class, &class_attr_version);
+err_class:
+        class_destroy(phantom_class);
+err:
+        return retval;
+}
+
+static void __exit phantom_exit(void)
+{
+        pci_unregister_driver(&phantom_pci_driver);
+
+        unregister_chrdev_region(MKDEV(phantom_major, 0), PHANTOM_MAX_MINORS);
+
+        class_remove_file(phantom_class, &class_attr_version);
+        class_destroy(phantom_class);
+
+        pr_debug("phantom: module successfully removed\n");
+}
+
+module_init(phantom_init);
+module_exit(phantom_exit);
+
+MODULE_AUTHOR("Jiri Slaby <jirislaby@gmail.com>");
+MODULE_DESCRIPTION("Sensable Phantom driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(PHANTOM_VERSION);
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index 524b83b5ebf5..51bc7e2f1f22 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -216,7 +216,7 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
         int last_devnum = -1;
         struct gendisk *gd;
 
-        if (!!mutex_trylock(&mtd_table_mutex)) {
+        if (mutex_trylock(&mtd_table_mutex)) {
                 mutex_unlock(&mtd_table_mutex);
                 BUG();
         }
@@ -294,7 +294,7 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
 
 int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
 {
-        if (!!mutex_trylock(&mtd_table_mutex)) {
+        if (mutex_trylock(&mtd_table_mutex)) {
                 mutex_unlock(&mtd_table_mutex);
                 BUG();
         }
diff --git a/drivers/net/irda/sir_dev.c b/drivers/net/irda/sir_dev.c
index 17b0c3ab6201..9d6c8f391b2d 100644
--- a/drivers/net/irda/sir_dev.c
+++ b/drivers/net/irda/sir_dev.c
@@ -14,7 +14,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/delay.h>
 
 #include <net/irda/irda.h>
diff --git a/drivers/net/irda/sir_dongle.c b/drivers/net/irda/sir_dongle.c
index d7e32d9554fc..25d5b8a96bdc 100644
--- a/drivers/net/irda/sir_dongle.c
+++ b/drivers/net/irda/sir_dongle.c
@@ -14,7 +14,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/kmod.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/net/irda/smsc-ircc2.c b/drivers/net/irda/smsc-ircc2.c
index 198bf3bfa70f..9043bf4aa49e 100644
--- a/drivers/net/irda/smsc-ircc2.c
+++ b/drivers/net/irda/smsc-ircc2.c
@@ -79,11 +79,17 @@ MODULE_AUTHOR("Daniele Peri <peri@csai.unipa.it>");
 MODULE_DESCRIPTION("SMC IrCC SIR/FIR controller driver");
 MODULE_LICENSE("GPL");
 
-static int ircc_dma = 255;
+static int smsc_nopnp;
+module_param_named(nopnp, smsc_nopnp, bool, 0);
+MODULE_PARM_DESC(nopnp, "Do not use PNP to detect controller settings");
+
+#define DMA_INVAL 255
+static int ircc_dma = DMA_INVAL;
 module_param(ircc_dma, int, 0);
 MODULE_PARM_DESC(ircc_dma, "DMA channel");
 
-static int ircc_irq = 255;
+#define IRQ_INVAL 255
+static int ircc_irq = IRQ_INVAL;
 module_param(ircc_irq, int, 0);
 MODULE_PARM_DESC(ircc_irq, "IRQ line");
 
@@ -360,7 +366,6 @@ static inline void register_bank(int iobase, int bank)
                iobase + IRCC_MASTER);
 }
 
-#ifdef  CONFIG_PNP
 /* PNP hotplug support */
 static const struct pnp_device_id smsc_ircc_pnp_table[] = {
         { .id = "SMCf010", .driver_data = 0 },
@@ -368,7 +373,35 @@ static const struct pnp_device_id smsc_ircc_pnp_table[] = {
         { }
 };
 MODULE_DEVICE_TABLE(pnp, smsc_ircc_pnp_table);
-#endif
+
+static int pnp_driver_registered;
+
+static int __init smsc_ircc_pnp_probe(struct pnp_dev *dev,
+                                      const struct pnp_device_id *dev_id)
+{
+        unsigned int firbase, sirbase;
+        u8 dma, irq;
+
+        if (!(pnp_port_valid(dev, 0) && pnp_port_valid(dev, 1) &&
+              pnp_dma_valid(dev, 0) && pnp_irq_valid(dev, 0)))
+                return -EINVAL;
+
+        sirbase = pnp_port_start(dev, 0);
+        firbase = pnp_port_start(dev, 1);
+        dma = pnp_dma(dev, 0);
+        irq = pnp_irq(dev, 0);
+
+        if (smsc_ircc_open(firbase, sirbase, dma, irq))
+                return -ENODEV;
+
+        return 0;
+}
+
+static struct pnp_driver smsc_ircc_pnp_driver = {
+        .name           = "smsc-ircc2",
+        .id_table       = smsc_ircc_pnp_table,
+        .probe          = smsc_ircc_pnp_probe,
+};
 
 
 /*******************************************************************************
@@ -379,6 +412,35 @@ MODULE_DEVICE_TABLE(pnp, smsc_ircc_pnp_table);
  *
  *******************************************************************************/
 
+static int __init smsc_ircc_legacy_probe(void)
+{
+        int ret = 0;
+
+        if (ircc_fir > 0 && ircc_sir > 0) {
+                IRDA_MESSAGE(" Overriding FIR address 0x%04x\n", ircc_fir);
+                IRDA_MESSAGE(" Overriding SIR address 0x%04x\n", ircc_sir);
+
+                if (smsc_ircc_open(ircc_fir, ircc_sir, ircc_dma, ircc_irq))
+                        ret = -ENODEV;
+        } else {
+                ret = -ENODEV;
+
+                /* try user provided configuration register base address */
+                if (ircc_cfg > 0) {
+                        IRDA_MESSAGE(" Overriding configuration address "
+                                     "0x%04x\n", ircc_cfg);
+                        if (!smsc_superio_fdc(ircc_cfg))
+                                ret = 0;
+                        if (!smsc_superio_lpc(ircc_cfg))
+                                ret = 0;
+                }
+
+                if (smsc_ircc_look_for_chips() > 0)
+                        ret = 0;
+        }
+        return ret;
+}
+
 /*
  * Function smsc_ircc_init ()
  *
@@ -406,31 +468,20 @@ static int __init smsc_ircc_init(void)
 
         dev_count = 0;
 
-        if (ircc_fir > 0 && ircc_sir > 0) {
-                IRDA_MESSAGE(" Overriding FIR address 0x%04x\n", ircc_fir);
-                IRDA_MESSAGE(" Overriding SIR address 0x%04x\n", ircc_sir);
-
-                if (smsc_ircc_open(ircc_fir, ircc_sir, ircc_dma, ircc_irq))
-                        ret = -ENODEV;
+        if (smsc_nopnp || !pnp_platform_devices ||
+            ircc_cfg || ircc_fir || ircc_sir ||
+            ircc_dma != DMA_INVAL || ircc_irq != IRQ_INVAL) {
+                ret = smsc_ircc_legacy_probe();
         } else {
-                ret = -ENODEV;
-
-                /* try user provided configuration register base address */
-                if (ircc_cfg > 0) {
-                        IRDA_MESSAGE(" Overriding configuration address "
-                                     "0x%04x\n", ircc_cfg);
-                        if (!smsc_superio_fdc(ircc_cfg))
-                                ret = 0;
-                        if (!smsc_superio_lpc(ircc_cfg))
-                                ret = 0;
-                }
-
-                if (smsc_ircc_look_for_chips() > 0)
-                        ret = 0;
+                if (pnp_register_driver(&smsc_ircc_pnp_driver) == 0)
+                        pnp_driver_registered = 1;
         }
 
-        if (ret)
+        if (ret) {
+                if (pnp_driver_registered)
+                        pnp_unregister_driver(&smsc_ircc_pnp_driver);
                 platform_driver_unregister(&smsc_ircc_driver);
+        }
 
         return ret;
 }
@@ -646,7 +697,7 @@ static void smsc_ircc_setup_io(struct smsc_ircc_cb *self,
         self->io.fifo_size = SMSC_IRCC2_FIFO_SIZE;
         self->io.speed = SMSC_IRCC2_C_IRDA_FALLBACK_SPEED;
 
-        if (irq < 255) {
+        if (irq != IRQ_INVAL) {
                 if (irq != chip_irq)
                         IRDA_MESSAGE("%s, Overriding IRQ - chip says %d, using %d\n",
                                      driver_name, chip_irq, irq);
@@ -654,7 +705,7 @@ static void smsc_ircc_setup_io(struct smsc_ircc_cb *self,
         } else
                 self->io.irq = chip_irq;
 
-        if (dma < 255) {
+        if (dma != DMA_INVAL) {
                 if (dma != chip_dma)
                         IRDA_MESSAGE("%s, Overriding DMA - chip says %d, using %d\n",
                                      driver_name, chip_dma, dma);
@@ -1840,6 +1891,9 @@ static void __exit smsc_ircc_cleanup(void)
                         smsc_ircc_close(dev_self[i]);
         }
 
+        if (pnp_driver_registered)
+                pnp_unregister_driver(&smsc_ircc_pnp_driver);
+
         platform_driver_unregister(&smsc_ircc_driver);
 }
 
@@ -2836,9 +2890,9 @@ static int __init smsc_ircc_preconfigure_subsystems(unsigned short ircc_cfg,
                                         tmpconf.fir_io = ircc_fir;
                                 if (ircc_sir != 0)
                                         tmpconf.sir_io = ircc_sir;
-                                if (ircc_dma != 0xff)
+                                if (ircc_dma != DMA_INVAL)
                                         tmpconf.fir_dma = ircc_dma;
-                                if (ircc_irq != 0xff)
+                                if (ircc_irq != IRQ_INVAL)
                                         tmpconf.fir_irq = ircc_irq;
 
                                 IRDA_MESSAGE("Detected unconfigured %s SMSC IrDA chip, pre-configuring device.\n", conf->name);
diff --git a/drivers/net/irda/vlsi_ir.c b/drivers/net/irda/vlsi_ir.c
index c4be973867a6..bf78ef1120ad 100644
--- a/drivers/net/irda/vlsi_ir.c
+++ b/drivers/net/irda/vlsi_ir.c
@@ -44,7 +44,6 @@ MODULE_LICENSE("GPL");
 #include <linux/time.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
-#include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
 
diff --git a/drivers/net/ns83820.c b/drivers/net/ns83820.c
index 6a32338623f1..3439f8c649f9 100644
--- a/drivers/net/ns83820.c
+++ b/drivers/net/ns83820.c
@@ -104,7 +104,6 @@
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/delay.h>
-#include <linux/smp_lock.h>
 #include <linux/workqueue.h>
 #include <linux/init.h>
 #include <linux/ip.h>   /* for iph */
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index 6d596ca50cfd..541168713f1f 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -40,7 +40,6 @@
 #include <linux/ip.h>
 #include <linux/tcp.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/rwsem.h>
 #include <linux/stddef.h>
 #include <linux/device.h>
diff --git a/drivers/net/wan/cosa.c b/drivers/net/wan/cosa.c
index 23464735fa88..9ef49ce148b2 100644
--- a/drivers/net/wan/cosa.c
+++ b/drivers/net/wan/cosa.c
@@ -90,7 +90,6 @@
 #include <linux/ioport.h>
 #include <linux/netdevice.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/device.h>
 
 #undef COSA_SLOW_IO     /* for testing purposes only */
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index f21bbafcb728..2d3a180dada0 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -25,7 +25,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/proc_fs.h>
-#include <linux/smp_lock.h>
 
 #include <linux/sched.h>
 #include <linux/ptrace.h>
diff --git a/drivers/net/wireless/hostap/hostap_ioctl.c b/drivers/net/wireless/hostap/hostap_ioctl.c
index cb08bc5db2bd..cdea7f71b9eb 100644
--- a/drivers/net/wireless/hostap/hostap_ioctl.c
+++ b/drivers/net/wireless/hostap/hostap_ioctl.c
@@ -1,7 +1,6 @@
 /* ioctl() (mostly Linux Wireless Extensions) routines for Host AP driver */
 
 #include <linux/types.h>
-#include <linux/smp_lock.h>
 #include <linux/ethtool.h>
 #include <net/ieee80211_crypt.h>
 
diff --git a/drivers/parisc/lba_pci.c b/drivers/parisc/lba_pci.c
index 21c4c299b3d6..5b86ee5c1eeb 100644
--- a/drivers/parisc/lba_pci.c
+++ b/drivers/parisc/lba_pci.c
@@ -38,7 +38,6 @@
 #include <linux/pci.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 
 #include <asm/byteorder.h>
 #include <asm/pdc.h>
diff --git a/drivers/parport/parport_cs.c b/drivers/parport/parport_cs.c
index 316c06f4423c..8b7d84eca05d 100644
--- a/drivers/parport/parport_cs.c
+++ b/drivers/parport/parport_cs.c
@@ -201,7 +201,7 @@ static int parport_config(struct pcmcia_device *link)
 
     p = parport_pc_probe_port(link->io.BasePort1, link->io.BasePort2,
                               link->irq.AssignedIRQ, PARPORT_DMA_NONE,
-                              NULL);
+                              &link->dev);
     if (p == NULL) {
         printk(KERN_NOTICE "parport_cs: parport_pc_probe_port() at "
                "0x%3x, irq %u failed\n", link->io.BasePort1,
diff --git a/drivers/parport/parport_mfc3.c b/drivers/parport/parport_mfc3.c
index e5b0a544de40..77726fc49766 100644
--- a/drivers/parport/parport_mfc3.c
+++ b/drivers/parport/parport_mfc3.c
@@ -356,6 +356,7 @@ static int __init parport_mfc3_init(void)
                                 if (request_irq(IRQ_AMIGA_PORTS, mfc3_interrupt, IRQF_SHARED, p->name, &pp_mfc3_ops))
                                         goto out_irq;
                 }
+                p->dev = &z->dev;
 
                 this_port[pias++] = p;
                 printk(KERN_INFO "%s: Multiface III port using irq\n", p->name);
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index 3de2623afa13..02c0d52c9f76 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -53,6 +53,7 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/pnp.h>
+#include <linux/platform_device.h>
 #include <linux/sysctl.h>
 
 #include <asm/io.h>
@@ -620,6 +621,7 @@ static size_t parport_pc_fifo_write_block_dma (struct parport *port,
         unsigned long dmaflag;
         size_t left = length;
         const struct parport_pc_private *priv = port->physport->private_data;
+        struct device *dev = port->physport->dev;
         dma_addr_t dma_addr, dma_handle;
         size_t maxlen = 0x10000; /* max 64k per DMA transfer */
         unsigned long start = (unsigned long) buf;
@@ -631,8 +633,8 @@ dump_parport_state ("enter fifo_write_block_dma", port);
                 if ((start ^ end) & ~0xffffUL)
                         maxlen = 0x10000 - (start & 0xffff);
 
-                dma_addr = dma_handle = pci_map_single(priv->dev, (void *)buf, length,
-                                                       PCI_DMA_TODEVICE);
+                dma_addr = dma_handle = dma_map_single(dev, (void *)buf, length,
+                                                       DMA_TO_DEVICE);
         } else {
                 /* above 16 MB we use a bounce buffer as ISA-DMA is not possible */
                 maxlen   = PAGE_SIZE;          /* sizeof(priv->dma_buf) */
@@ -728,9 +730,9 @@ dump_parport_state ("enter fifo_write_block_dma", port);
 
         /* Turn off DMA mode */
         frob_econtrol (port, 1<<3, 0);
-        
+
         if (dma_handle)
-                pci_unmap_single(priv->dev, dma_handle, length, PCI_DMA_TODEVICE);
+                dma_unmap_single(dev, dma_handle, length, DMA_TO_DEVICE);
 
 dump_parport_state ("leave fifo_write_block_dma", port);
         return length - left;
@@ -2146,7 +2148,7 @@ static DEFINE_SPINLOCK(ports_lock);
 struct parport *parport_pc_probe_port (unsigned long int base,
                                        unsigned long int base_hi,
                                        int irq, int dma,
-                                       struct pci_dev *dev)
+                                       struct device *dev)
 {
         struct parport_pc_private *priv;
         struct parport_operations *ops;
@@ -2155,6 +2157,17 @@ struct parport *parport_pc_probe_port (unsigned long int base,
         struct resource *base_res;
         struct resource *ECR_res = NULL;
         struct resource *EPP_res = NULL;
+        struct platform_device *pdev = NULL;
+
+        if (!dev) {
+                /* We need a physical device to attach to, but none was
+                 * provided. Create our own. */
+                pdev = platform_device_register_simple("parport_pc",
+                                                       base, NULL, 0);
+                if (IS_ERR(pdev))
+                        return NULL;
+                dev = &pdev->dev;
+        }
 
         ops = kmalloc(sizeof (struct parport_operations), GFP_KERNEL);
         if (!ops)
@@ -2180,9 +2193,10 @@ struct parport *parport_pc_probe_port (unsigned long int base,
         priv->fifo_depth = 0;
         priv->dma_buf = NULL;
         priv->dma_handle = 0;
-        priv->dev = dev;
         INIT_LIST_HEAD(&priv->list);
         priv->port = p;
+
+        p->dev = dev;
         p->base_hi = base_hi;
         p->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_SAFEININT;
         p->private_data = priv;
@@ -2305,9 +2319,10 @@ struct parport *parport_pc_probe_port (unsigned long int base,
                                 p->dma = PARPORT_DMA_NONE;
                         } else {
                                 priv->dma_buf =
-                                  pci_alloc_consistent(priv->dev,
+                                  dma_alloc_coherent(dev,
                                                        PAGE_SIZE,
-                                                       &priv->dma_handle);
+                                                       &priv->dma_handle,
+                                                       GFP_KERNEL);
                                 if (! priv->dma_buf) {
                                         printk (KERN_WARNING "%s: "
                                                 "cannot get buffer for DMA, "
@@ -2356,6 +2371,8 @@ out3:
 out2:
         kfree (ops);
 out1:
+        if (pdev)
+                platform_device_unregister(pdev);
         return NULL;
 }
 
@@ -2383,7 +2400,7 @@ void parport_pc_unregister_port (struct parport *p)
                 release_region(p->base_hi, 3);
 #if defined(CONFIG_PARPORT_PC_FIFO) && defined(HAS_DMA)
         if (priv->dma_buf)
-                pci_free_consistent(priv->dev, PAGE_SIZE,
+                dma_free_coherent(p->physport->dev, PAGE_SIZE,
                                     priv->dma_buf,
                                     priv->dma_handle);
 #endif
@@ -2489,7 +2506,7 @@ static int __devinit sio_ite_8872_probe (struct pci_dev *pdev, int autoirq,
          */
         release_resource(base_res);
         if (parport_pc_probe_port (ite8872_lpt, ite8872_lpthi,
-                                   irq, PARPORT_DMA_NONE, NULL)) {
+                                   irq, PARPORT_DMA_NONE, &pdev->dev)) {
                 printk (KERN_INFO
                         "parport_pc: ITE 8872 parallel port: io=0x%X",
                         ite8872_lpt);
@@ -2672,7 +2689,7 @@ static int __devinit sio_via_probe (struct pci_dev *pdev, int autoirq,
         }
 
         /* finally, do the probe with values obtained */
-        if (parport_pc_probe_port (port1, port2, irq, dma, NULL)) {
+        if (parport_pc_probe_port (port1, port2, irq, dma, &pdev->dev)) {
                 printk (KERN_INFO
                         "parport_pc: VIA parallel port: io=0x%X", port1);
                 if (irq != PARPORT_IRQ_NONE)
@@ -2970,7 +2987,7 @@ static int parport_pc_pci_probe (struct pci_dev *dev,
                         parport_pc_pci_tbl[i + last_sio].device, io_lo, io_hi);
                 data->ports[count] =
                         parport_pc_probe_port (io_lo, io_hi, PARPORT_IRQ_NONE,
-                                               PARPORT_DMA_NONE, dev);
+                                               PARPORT_DMA_NONE, &dev->dev);
                 if (data->ports[count])
                         count++;
         }
@@ -3077,8 +3094,8 @@ static int parport_pc_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id
         } else
                 dma = PARPORT_DMA_NONE;
 
-        printk(KERN_INFO "parport: PnPBIOS parport detected.\n");
-        if (!(pdata = parport_pc_probe_port (io_lo, io_hi, irq, dma, NULL)))
+        dev_info(&dev->dev, "reported by %s\n", dev->protocol->name);
+        if (!(pdata = parport_pc_probe_port (io_lo, io_hi, irq, dma, &dev->dev)))
                 return -ENODEV;
 
         pnp_set_drvdata(dev,pdata);
@@ -3103,6 +3120,21 @@ static struct pnp_driver parport_pc_pnp_driver = {
 };
 
 
+static int __devinit parport_pc_platform_probe(struct platform_device *pdev)
+{
+        /* Always succeed, the actual probing is done in
+         * parport_pc_probe_port(). */
+        return 0;
+}
+
+static struct platform_driver parport_pc_platform_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "parport_pc",
+        },
+        .probe          = parport_pc_platform_probe,
+};
+
 /* This is called by parport_pc_find_nonpci_ports (in asm/parport.h) */
 static int __devinit __attribute__((unused))
 parport_pc_find_isa_ports (int autoirq, int autodma)
@@ -3378,9 +3410,15 @@ __setup("parport_init_mode=",parport_init_mode_setup);
 
 static int __init parport_pc_init(void)
 {
+        int err;
+
         if (parse_parport_params())
                 return -EINVAL;
 
+        err = platform_driver_register(&parport_pc_platform_driver);
+        if (err)
+                return err;
+
         if (io[0]) {
                 int i;
                 /* Only probe the ports we were given. */
@@ -3405,6 +3443,7 @@ static void __exit parport_pc_exit(void)
                 pci_unregister_driver (&parport_pc_pci_driver);
         if (pnp_registered_parport)
                 pnp_unregister_driver (&parport_pc_pnp_driver);
+        platform_driver_unregister(&parport_pc_platform_driver);
 
         spin_lock(&ports_lock);
         while (!list_empty(&ports_list)) {
@@ -3413,6 +3452,9 @@ static void __exit parport_pc_exit(void)
                 priv = list_entry(ports_list.next,
                                   struct parport_pc_private, list);
                 port = priv->port;
+                if (port->dev && port->dev->bus == &platform_bus_type)
+                        platform_device_unregister(
+                                to_platform_device(port->dev));
                 spin_unlock(&ports_lock);
                 parport_pc_unregister_port(port);
                 spin_lock(&ports_lock);
diff --git a/drivers/parport/parport_serial.c b/drivers/parport/parport_serial.c
index 78c0a269a2ba..90ea3b8b99b0 100644
--- a/drivers/parport/parport_serial.c
+++ b/drivers/parport/parport_serial.c
@@ -305,7 +305,7 @@ static int __devinit parport_register (struct pci_dev *dev,
                 dev_dbg(&dev->dev, "PCI parallel port detected: I/O at "
                         "%#lx(%#lx)\n", io_lo, io_hi);
                 port = parport_pc_probe_port (io_lo, io_hi, PARPORT_IRQ_NONE,
-                                              PARPORT_DMA_NONE, dev);
+                                              PARPORT_DMA_NONE, &dev->dev);
                 if (port) {
                         priv->port[priv->num_par++] = port;
                         success = 1;
@@ -392,6 +392,7 @@ static int parport_serial_pci_suspend(struct pci_dev *dev, pm_message_t state)
 static int parport_serial_pci_resume(struct pci_dev *dev)
 {
         struct parport_serial_private *priv = pci_get_drvdata(dev);
+        int err;
 
         pci_set_power_state(dev, PCI_D0);
         pci_restore_state(dev);
@@ -399,7 +400,12 @@ static int parport_serial_pci_resume(struct pci_dev *dev)
         /*
          * The device may have been disabled.  Re-enable it.
          */
-        pci_enable_device(dev);
+        err = pci_enable_device(dev);
+        if (err) {
+                printk(KERN_ERR "parport_serial: %s: error enabling "
+                        "device for resume (%d)\n", pci_name(dev), err);
+                return err;
+        }
 
         if (priv->serial)
                 pciserial_resume_ports(priv->serial);
diff --git a/drivers/parport/parport_sunbpp.c b/drivers/parport/parport_sunbpp.c
index 400bb90084cf..d27019c2f860 100644
--- a/drivers/parport/parport_sunbpp.c
+++ b/drivers/parport/parport_sunbpp.c
@@ -322,6 +322,7 @@ static int __devinit init_one_port(struct sbus_dev *sdev)
                 goto out_free_ops;
 
         p->size = size;
+        p->dev = &sdev->ofdev.dev;
 
         if ((err = request_irq(p->irq, parport_sunbpp_interrupt,
                                IRQF_SHARED, p->name, p)) != 0) {
diff --git a/drivers/parport/share.c b/drivers/parport/share.c
index fd9129e424f9..cd66442acfee 100644
--- a/drivers/parport/share.c
+++ b/drivers/parport/share.c
@@ -365,6 +365,11 @@ void parport_announce_port (struct parport *port)
         parport_daisy_init(port);
 #endif
 
+        if (!port->dev)
+                printk(KERN_WARNING "%s: fix this legacy "
+                                "no-device port driver!\n",
+                                port->name);
+
         parport_proc_register(port);
         mutex_lock(&registration_lock);
         spin_lock_irq(&parportlist_lock);
diff --git a/drivers/pci/hotplug/acpiphp_core.c b/drivers/pci/hotplug/acpiphp_core.c
index 40c79b03c7ef..fa5c0197d571 100644
--- a/drivers/pci/hotplug/acpiphp_core.c
+++ b/drivers/pci/hotplug/acpiphp_core.c
@@ -40,7 +40,6 @@
 #include <linux/pci_hotplug.h>
 #include <linux/slab.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include "acpiphp.h"
 
 #define MY_NAME "acpiphp"
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index fca978fb158e..9ef4e989afc4 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -46,7 +46,6 @@
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/pci_hotplug.h>
-#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 
 #include "../pci.h"
diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index 59392946c2bd..0316eeaaeb29 100644
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -34,7 +34,6 @@
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/wait.h>
-#include <linux/smp_lock.h>
 #include "../pci.h"
 #include "../../../arch/i386/pci/pci.h" /* for struct irq_routing_table */
 #include "ibmphp.h"
diff --git a/drivers/pci/hotplug/ibmphp_hpc.c b/drivers/pci/hotplug/ibmphp_hpc.c
index f55ac3885cb3..46abaa8c41f1 100644
--- a/drivers/pci/hotplug/ibmphp_hpc.c
+++ b/drivers/pci/hotplug/ibmphp_hpc.c
@@ -32,7 +32,6 @@
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/pci.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/pci/hotplug/pci_hotplug_core.c b/drivers/pci/hotplug/pci_hotplug_core.c
index 63f3bd1eecc4..bd433ef6bfc6 100644
--- a/drivers/pci/hotplug/pci_hotplug_core.c
+++ b/drivers/pci/hotplug/pci_hotplug_core.c
@@ -34,7 +34,6 @@
 #include <linux/sysfs.h>
 #include <linux/pagemap.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/mount.h>
 #include <linux/namei.h>
diff --git a/drivers/pci/hotplug/rpaphp_core.c b/drivers/pci/hotplug/rpaphp_core.c
index 899eed002748..458c08ef2654 100644
--- a/drivers/pci/hotplug/rpaphp_core.c
+++ b/drivers/pci/hotplug/rpaphp_core.c
@@ -29,7 +29,6 @@
 #include <linux/pci_hotplug.h>
 #include <linux/slab.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <asm/eeh.h>       /* for eeh_add_device() */
 #include <asm/rtas.h>           /* rtas_call */
diff --git a/drivers/pci/hotplug/shpchp_ctrl.c b/drivers/pci/hotplug/shpchp_ctrl.c
index 2c94d44279a3..d2fc35598cdd 100644
--- a/drivers/pci/hotplug/shpchp_ctrl.c
+++ b/drivers/pci/hotplug/shpchp_ctrl.c
@@ -30,7 +30,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
-#include <linux/smp_lock.h>
 #include <linux/pci.h>
 #include <linux/workqueue.h>
 #include "../pci.h"
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 9e1321d0d5e6..e6740d1a0824 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -12,7 +12,6 @@
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
-#include <linux/smp_lock.h>
 #include <linux/pci.h>
 #include <linux/proc_fs.h>
 #include <linux/msi.h>
diff --git a/drivers/pci/proc.c b/drivers/pci/proc.c
index ed87aa59f0b1..0425a7b7350d 100644
--- a/drivers/pci/proc.c
+++ b/drivers/pci/proc.c
@@ -11,7 +11,6 @@
 #include <linux/module.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
-#include <linux/smp_lock.h>
 
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
diff --git a/drivers/pcmcia/pxa2xx_mainstone.c b/drivers/pcmcia/pxa2xx_mainstone.c
index fda06941e730..383107ba4bd3 100644
--- a/drivers/pcmcia/pxa2xx_mainstone.c
+++ b/drivers/pcmcia/pxa2xx_mainstone.c
@@ -175,6 +175,7 @@ static int __init mst_pcmcia_init(void)
         if (!mst_pcmcia_device)
                 return -ENOMEM;
 
+        mst_pcmcia_device->dev.uevent_suppress = 0;
         mst_pcmcia_device->dev.platform_data = &mst_pcmcia_ops;
 
         ret = platform_device_add(mst_pcmcia_device);
diff --git a/drivers/pcmcia/pxa2xx_sharpsl.c b/drivers/pcmcia/pxa2xx_sharpsl.c
index b7b9e149c5b9..a2daa3f531b2 100644
--- a/drivers/pcmcia/pxa2xx_sharpsl.c
+++ b/drivers/pcmcia/pxa2xx_sharpsl.c
@@ -261,6 +261,7 @@ static int __init sharpsl_pcmcia_init(void)
         if (!sharpsl_pcmcia_device)
                 return -ENOMEM;
 
+        sharpsl_pcmcia_device->dev.uevent_suppress = 0;
         sharpsl_pcmcia_device->dev.platform_data = &sharpsl_pcmcia_ops;
         sharpsl_pcmcia_device->dev.parent = platform_scoop_config->devs[0].dev;
 
diff --git a/drivers/pnp/core.c b/drivers/pnp/core.c
index aec83ec5ea23..3e20b1cc7778 100644
--- a/drivers/pnp/core.c
+++ b/drivers/pnp/core.c
@@ -14,6 +14,7 @@
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
+#include <linux/dma-mapping.h>
 
 #include "base.h"
 
@@ -22,6 +23,14 @@ static LIST_HEAD(pnp_protocols);
 LIST_HEAD(pnp_global);
 DEFINE_SPINLOCK(pnp_lock);
 
+/*
+ * ACPI or PNPBIOS should tell us about all platform devices, so we can
+ * skip some blind probes.  ISAPNP typically enumerates only plug-in ISA
+ * devices, not built-in things like COM ports.
+ */
+int pnp_platform_devices;
+EXPORT_SYMBOL(pnp_platform_devices);
+
 void *pnp_alloc(long size)
 {
         void *result;
@@ -114,6 +123,8 @@ int __pnp_add_device(struct pnp_dev *dev)
         int ret;
         pnp_fixup_device(dev);
         dev->dev.bus = &pnp_bus_type;
+        dev->dev.dma_mask = &dev->dma_mask;
+        dev->dma_mask = dev->dev.coherent_dma_mask = DMA_24BIT_MASK;
         dev->dev.release = &pnp_release_device;
         dev->status = PNP_READY;
         spin_lock(&pnp_lock);
diff --git a/drivers/pnp/pnpacpi/core.c b/drivers/pnp/pnpacpi/core.c
index 62eda5d59024..a00548799e98 100644
--- a/drivers/pnp/pnpacpi/core.c
+++ b/drivers/pnp/pnpacpi/core.c
@@ -3,7 +3,7 @@
  *
  * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr>
  * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com>
- * 
+ *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
  * Free Software Foundation; either version 2, or (at your option) any
@@ -18,7 +18,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
- 
+
 #include <linux/acpi.h>
 #include <linux/pnp.h>
 #include <acpi/acpi_bus.h>
@@ -82,7 +82,7 @@ static void __init pnpidacpi_to_pnpid(char *id, char *str)
 static int pnpacpi_get_resources(struct pnp_dev * dev, struct pnp_resource_table * res)
 {
         acpi_status status;
-        status = pnpacpi_parse_allocated_resource((acpi_handle)dev->data, 
+        status = pnpacpi_parse_allocated_resource((acpi_handle)dev->data,
                 &dev->res);
         return ACPI_FAILURE(status) ? -ENODEV : 0;
 }
@@ -112,9 +112,9 @@ static int pnpacpi_set_resources(struct pnp_dev * dev, struct pnp_resource_table
 static int pnpacpi_disable_resources(struct pnp_dev *dev)
 {
         acpi_status status;
-        
+
         /* acpi_unregister_gsi(pnp_irq(dev, 0)); */
-        status = acpi_evaluate_object((acpi_handle)dev->data, 
+        status = acpi_evaluate_object((acpi_handle)dev->data,
                 "_DIS", NULL, NULL);
         return ACPI_FAILURE(status) ? -ENODEV : 0;
 }
@@ -167,7 +167,7 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
                 strncpy(dev->name, acpi_device_bid(device), sizeof(dev->name));
 
         dev->number = num;
-        
+
         /* set the initial values for the PnP device */
         dev_id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
         if (!dev_id)
@@ -185,14 +185,14 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
         }
 
         if(dev->capabilities & PNP_CONFIGURABLE) {
-                status = pnpacpi_parse_resource_option_data(device->handle, 
+                status = pnpacpi_parse_resource_option_data(device->handle,
                         dev);
                 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
                         pnp_err("PnPACPI: METHOD_NAME__PRS failure for %s", dev_id->id);
                         goto err1;
                 }
         }
-        
+
         /* parse compatible ids */
         if (device->flags.compatible_ids) {
                 struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
@@ -236,6 +236,42 @@ static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle,
         return AE_OK;
 }
 
+static int __init acpi_pnp_match(struct device *dev, void *_pnp)
+{
+        struct acpi_device      *acpi = to_acpi_device(dev);
+        struct pnp_dev          *pnp = _pnp;
+
+        /* true means it matched */
+        return acpi->flags.hardware_id
+                && !acpi_get_physical_device(acpi->handle)
+                && compare_pnp_id(pnp->id, acpi->pnp.hardware_id);
+}
+
+static int __init acpi_pnp_find_device(struct device *dev, acpi_handle *handle)
+{
+        struct device           *adev;
+        struct acpi_device      *acpi;
+
+        adev = bus_find_device(&acpi_bus_type, NULL,
+                        to_pnp_dev(dev),
+                        acpi_pnp_match);
+        if (!adev)
+                return -ENODEV;
+
+        acpi = to_acpi_device(adev);
+        *handle = acpi->handle;
+        put_device(adev);
+        return 0;
+}
+
+/* complete initialization of a PNPACPI device includes having
+ * pnpdev->dev.archdata.acpi_handle point to its ACPI sibling.
+ */
+static struct acpi_bus_type __initdata acpi_pnp_bus = {
+        .bus = &pnp_bus_type,
+        .find_device = acpi_pnp_find_device,
+};
+
 int pnpacpi_disabled __initdata;
 static int __init pnpacpi_init(void)
 {
@@ -245,8 +281,11 @@ static int __init pnpacpi_init(void)
         }
         pnp_info("PnP ACPI init");
         pnp_register_protocol(&pnpacpi_protocol);
+        register_acpi_bus_type(&acpi_pnp_bus);
         acpi_get_devices(NULL, pnpacpi_add_device_handler, NULL, NULL);
         pnp_info("PnP ACPI: found %d devices", num);
+        unregister_acpi_bus_type(&acpi_pnp_bus);
+        pnp_platform_devices = 1;
         return 0;
 }
 subsys_initcall(pnpacpi_init);
diff --git a/drivers/pnp/pnpbios/core.c b/drivers/pnp/pnpbios/core.c
index 95738dbd5d45..3a201b77b963 100644
--- a/drivers/pnp/pnpbios/core.c
+++ b/drivers/pnp/pnpbios/core.c
@@ -62,6 +62,7 @@
 #include <linux/delay.h>
 #include <linux/acpi.h>
 #include <linux/freezer.h>
+#include <linux/kthread.h>
 
 #include <asm/page.h>
 #include <asm/desc.h>
@@ -159,9 +160,7 @@ static int pnp_dock_thread(void * unused)
 {
         static struct pnp_docking_station_info now;
         int docked = -1, d = 0;
-        daemonize("kpnpbiosd");
-        allow_signal(SIGKILL);
-        while(!unloading && !signal_pending(current))
+        while (!unloading)
         {
                 int status;
                 
@@ -170,11 +169,8 @@ static int pnp_dock_thread(void * unused)
                  */
                 msleep_interruptible(2000);
 
-                if(signal_pending(current)) {
-                        if (try_to_freeze())
-                                continue;
-                        break;
-                }
+                if (try_to_freeze())
+                        continue;
 
                 status = pnp_bios_dock_station_info(&now);
 
@@ -574,6 +570,7 @@ static int __init pnpbios_init(void)
         /* scan for pnpbios devices */
         build_devlist();
 
+        pnp_platform_devices = 1;
         return 0;
 }
 
@@ -581,6 +578,7 @@ subsys_initcall(pnpbios_init);
 
 static int __init pnpbios_thread_init(void)
 {
+        struct task_struct *task;
 #if defined(CONFIG_PPC_MERGE)
         if (check_legacy_ioport(PNPBIOS_BASE))
                 return 0;
@@ -589,7 +587,8 @@ static int __init pnpbios_thread_init(void)
                 return 0;
 #ifdef CONFIG_HOTPLUG
         init_completion(&unload_sem);
-        if (kernel_thread(pnp_dock_thread, NULL, CLONE_KERNEL) > 0)
+        task = kthread_run(pnp_dock_thread, NULL, "kpnpbiosd");
+        if (!IS_ERR(task))
                 unloading = 0;
 #endif
         return 0;
diff --git a/drivers/pnp/quirks.c b/drivers/pnp/quirks.c
index e97ecefe8584..277df50c89ae 100644
--- a/drivers/pnp/quirks.c
+++ b/drivers/pnp/quirks.c
@@ -16,6 +16,7 @@
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/pnp.h>
+#include <linux/io.h>
 #include "base.h"
 
 
@@ -106,6 +107,34 @@ static void quirk_sb16audio_resources(struct pnp_dev *dev)
         return;
 }
 
+static void quirk_smc_enable(struct pnp_dev *dev)
+{
+        unsigned int firbase;
+
+        if (!dev->active || !pnp_port_valid(dev, 1))
+                return;
+
+        /*
+         * On the HP/Compaq nw8240 (and probably other similar machines),
+         * there is an SMCF010 device with two I/O port regions:
+         *
+         *      0x3e8-0x3ef SIR
+         *      0x100-0x10f FIR
+         *
+         * _STA reports the device is enabled, but in fact, the BIOS
+         * neglects to enable the FIR range.  Fortunately, it does fully
+         * enable the device if we call _SRS.
+         */
+        firbase = pnp_port_start(dev, 1);
+        if (inb(firbase + 0x7 /* IRCC_MASTER */) == 0xff) {
+                pnp_err("%s (%s) enabled but not responding, disabling and "
+                        "re-enabling", dev->dev.bus_id, pnp_dev_name(dev));
+                pnp_disable_dev(dev);
+                pnp_activate_dev(dev);
+        }
+}
+
+
 /*
  *  PnP Quirks
  *  Cards or devices that need some tweaking due to incomplete resource info
@@ -126,6 +155,7 @@ static struct pnp_fixup pnp_fixups[] = {
         { "CTL0043", quirk_sb16audio_resources },
         { "CTL0044", quirk_sb16audio_resources },
         { "CTL0045", quirk_sb16audio_resources },
+        { "SMCf010", quirk_smc_enable },
         { "" }
 };
 
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index ef1eae98ba44..5e439836db2d 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -21,21 +21,31 @@ config RTC_CLASS
           will be called rtc-class.
 
 config RTC_HCTOSYS
-        bool "Set system time from RTC on startup"
+        bool "Set system time from RTC on startup and resume"
         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 fsck runs.
+          If you say yes here, the system time (wall clock) will be set using
+          the value read from a specified RTC device. This is useful to avoid
+          unnecessary fsck runs at boot time, and to network better.
 
 config RTC_HCTOSYS_DEVICE
-        string "The RTC to read the time from"
+        string "RTC used to set the system time"
         depends on RTC_HCTOSYS = y
         default "rtc0"
         help
-          The RTC device that will be used as the source for
-          the system time, usually rtc0.
+          The RTC device that will be used to (re)initialize the system
+          clock, usually rtc0.  Initialization is done when the system
+          starts up, and when it resumes from a low power state.
+
+          This clock should be battery-backed, so that it reads the correct
+          time when the system boots from a power-off state.  Otherwise, your
+          system will need an external clock source (like an NTP server).
+
+          If the clock you specify here is not battery backed, it may still
+          be useful to reinitialize system time when resuming from system
+          sleep states.  Do not specify an RTC here unless it stays powered
+          during all this system's supported sleep states.
 
 config RTC_DEBUG
         bool "RTC debug support"
@@ -48,7 +58,7 @@ comment "RTC interfaces"
         depends on RTC_CLASS
 
 config RTC_INTF_SYSFS
-        tristate "sysfs"
+        boolean "sysfs"
         depends on RTC_CLASS && SYSFS
         default RTC_CLASS
         help
@@ -59,7 +69,7 @@ config RTC_INTF_SYSFS
           will be called rtc-sysfs.
 
 config RTC_INTF_PROC
-        tristate "proc"
+        boolean "proc"
         depends on RTC_CLASS && PROC_FS
         default RTC_CLASS
         help
@@ -71,7 +81,7 @@ config RTC_INTF_PROC
           will be called rtc-proc.
 
 config RTC_INTF_DEV
-        tristate "dev"
+        boolean "dev"
         depends on RTC_CLASS
         default RTC_CLASS
         help
@@ -92,44 +102,26 @@ config RTC_INTF_DEV_UIE_EMUL
           driver does not expose RTC_UIE ioctls.  Those requests generate
           once-per-second update interrupts, used for synchronization.
 
-comment "RTC drivers"
+config RTC_DRV_TEST
+        tristate "Test driver/device"
         depends on RTC_CLASS
-
-# this 'CMOS' RTC driver is arch dependent because <asm-generic/rtc.h>
-# requires <asm/mc146818rtc.h> defining CMOS_READ/CMOS_WRITE, and a
-# global rtc_lock ... it's not yet just another platform_device.
-
-config RTC_DRV_CMOS
-        tristate "PC-style 'CMOS' real time clock"
-        depends on RTC_CLASS && (X86 || ALPHA || ARM26 || ARM \
-                || M32R || ATARI || POWERPC)
-        help
-          Say "yes" here to get direct support for the real time clock
-          found in every PC or ACPI-based system, and some other boards.
-          Specifically the original MC146818, compatibles like those in
-          PC south bridges, the DS12887 or M48T86, some multifunction
-          or LPC bus chips, and so on.
-
-          Your system will need to define the platform device used by
-          this driver, otherwise it won't be accessible.  This means
-          you can safely enable this driver if you don't know whether
-          or not your board has this kind of hardware.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-cmos.
-
-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.
+          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-x1205.
+          will be called rtc-test.
+
+comment "I2C RTC drivers"
+        depends on RTC_CLASS
 
 config RTC_DRV_DS1307
-        tristate "Dallas/Maxim DS1307 and similar I2C RTC chips"
+        tristate "Dallas/Maxim DS1307/37/38/39/40, ST M41T00"
         depends on RTC_CLASS && I2C
         help
           If you say yes here you get support for various compatible RTC
@@ -146,53 +138,55 @@ config RTC_DRV_DS1307
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1307.
 
-config RTC_DRV_DS1553
-        tristate "Dallas DS1553"
-        depends on RTC_CLASS
+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 DS1553 timekeeping chip.
+          Dallas/Maxim DS1672 timekeeping chip.
 
           This driver can also be built as a module. If so, the module
-          will be called rtc-ds1553.
+          will be called rtc-ds1672.
 
-config RTC_DRV_ISL1208
-        tristate "Intersil 1208"
+config RTC_DRV_MAX6900
+        tristate "Maxim 6900"
         depends on RTC_CLASS && I2C
         help
-          If you say yes here you get support for the
-          Intersil 1208 RTC chip.
+          If you say yes here you will get support for the
+          Maxim MAX6900 I2C RTC chip.
 
           This driver can also be built as a module. If so, the module
-          will be called rtc-isl1208.
+          will be called rtc-max6900.
 
-config RTC_DRV_DS1672
-        tristate "Dallas/Maxim DS1672"
+config RTC_DRV_RS5C372
+        tristate "Ricoh RS5C372A/B"
         depends on RTC_CLASS && I2C
         help
           If you say yes here you get support for the
-          Dallas/Maxim DS1672 timekeeping chip.
+          Ricoh RS5C372A and RS5C372B RTC chips.
 
           This driver can also be built as a module. If so, the module
-          will be called rtc-ds1672.
+          will be called rtc-rs5c372.
 
-config RTC_DRV_DS1742
-        tristate "Dallas DS1742/1743"
-        depends on RTC_CLASS
+config RTC_DRV_ISL1208
+        tristate "Intersil 1208"
+        depends on RTC_CLASS && I2C
         help
           If you say yes here you get support for the
-          Dallas DS1742/1743 timekeeping chip.
+          Intersil 1208 RTC chip.
 
           This driver can also be built as a module. If so, the module
-          will be called rtc-ds1742.
+          will be called rtc-isl1208.
 
-config RTC_DRV_OMAP
-        tristate "TI OMAP1"
-        depends on RTC_CLASS && ( \
-                ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730 )
+config RTC_DRV_X1205
+        tristate "Xicor/Intersil X1205"
+        depends on RTC_CLASS && I2C
         help
-          Say "yes" here to support the real time clock on TI OMAP1 chips.
-          This driver can also be built as a module called rtc-omap.
+          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_PCF8563
         tristate "Philips PCF8563/Epson RTC8564"
@@ -207,16 +201,20 @@ config RTC_DRV_PCF8563
 
 config RTC_DRV_PCF8583
         tristate "Philips PCF8583"
-        depends on RTC_CLASS && I2C && ARCH_RPC
+        depends on RTC_CLASS && I2C
         help
           If you say yes here you get support for the Philips PCF8583
-          RTC chip found on Acorn RiscPCs.  This driver supports the
+          RTC chip found on Acorn RiscPCs. This driver supports the
           platform specific method of retrieving the current year from
-          the RTC's SRAM.
+          the RTC's SRAM. It will work on other platforms with the same
+          chip, but the year will probably have to be tweaked.
 
           This driver can also be built as a module. If so, the module
           will be called rtc-pcf8583.
 
+comment "SPI RTC drivers"
+        depends on RTC_CLASS
+
 config RTC_DRV_RS5C348
         tristate "Ricoh RS5C348A/B"
         depends on RTC_CLASS && SPI
@@ -227,15 +225,92 @@ config RTC_DRV_RS5C348
           This driver can also be built as a module. If so, the module
           will be called rtc-rs5c348.
 
-config RTC_DRV_RS5C372
-        tristate "Ricoh RS5C372A/B"
-        depends on RTC_CLASS && I2C
+config RTC_DRV_MAX6902
+        tristate "Maxim 6902"
+        depends on RTC_CLASS && SPI
+        help
+          If you say yes here you will get support for the
+          Maxim MAX6902 SPI RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-max6902.
+
+comment "Platform RTC drivers"
+        depends on RTC_CLASS
+
+# this 'CMOS' RTC driver is arch dependent because <asm-generic/rtc.h>
+# requires <asm/mc146818rtc.h> defining CMOS_READ/CMOS_WRITE, and a
+# global rtc_lock ... it's not yet just another platform_device.
+
+config RTC_DRV_CMOS
+        tristate "PC-style 'CMOS'"
+        depends on RTC_CLASS && (X86 || ALPHA || ARM26 || ARM \
+                || M32R || ATARI || POWERPC)
+        help
+          Say "yes" here to get direct support for the real time clock
+          found in every PC or ACPI-based system, and some other boards.
+          Specifically the original MC146818, compatibles like those in
+          PC south bridges, the DS12887 or M48T86, some multifunction
+          or LPC bus chips, and so on.
+
+          Your system will need to define the platform device used by
+          this driver, otherwise it won't be accessible.  This means
+          you can safely enable this driver if you don't know whether
+          or not your board has this kind of hardware.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-cmos.
+
+config RTC_DRV_DS1553
+        tristate "Dallas DS1553"
+        depends on RTC_CLASS
         help
           If you say yes here you get support for the
-          Ricoh RS5C372A and RS5C372B RTC chips.
+          Dallas DS1553 timekeeping chip.
 
           This driver can also be built as a module. If so, the module
-          will be called rtc-rs5c372.
+          will be called rtc-ds1553.
+
+config RTC_DRV_DS1742
+        tristate "Dallas DS1742/1743"
+        depends on RTC_CLASS
+        help
+          If you say yes here you get support for the
+          Dallas DS1742/1743 timekeeping chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds1742.
+
+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_V3020
+        tristate "EM Microelectronic V3020"
+        depends on RTC_CLASS
+        help
+          If you say yes here you will get support for the
+          EM Microelectronic v3020 RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-v3020.
+
+comment "on-CPU RTC drivers"
+        depends on RTC_CLASS
+
+config RTC_DRV_OMAP
+        tristate "TI OMAP1"
+        depends on RTC_CLASS && ( \
+                ARCH_OMAP15XX || ARCH_OMAP16XX || ARCH_OMAP730 )
+        help
+          Say "yes" here to support the real time clock on TI OMAP1 chips.
+          This driver can also be built as a module called rtc-omap.
 
 config RTC_DRV_S3C
         tristate "Samsung S3C series SoC RTC"
@@ -253,16 +328,6 @@ config RTC_DRV_S3C
           This driver can also be build as a module. If so, the module
           will be called rtc-s3c.
 
-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
@@ -308,7 +373,7 @@ config RTC_DRV_PL031
         depends on RTC_CLASS && ARM_AMBA
         help
           If you say Y here you will get access to ARM AMBA
-          PrimeCell PL031 UART found on certain ARM SOCs.
+          PrimeCell PL031 RTC found on certain ARM SOCs.
 
           To compile this driver as a module, choose M here: the
           module will be called rtc-pl031.
@@ -319,41 +384,6 @@ config RTC_DRV_AT91RM9200
         help
           Driver for the Atmel AT91RM9200's internal RTC (Realtime Clock).
 
-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.
-
-config RTC_DRV_MAX6902
-        tristate "Maxim 6902"
-        depends on RTC_CLASS && SPI
-        help
-          If you say yes here you will get support for the
-          Maxim MAX6902 spi RTC chip.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-max6902.
-
-config RTC_DRV_V3020
-        tristate "EM Microelectronic V3020"
-        depends on RTC_CLASS
-        help
-          If you say yes here you will get support for the
-          EM Microelectronic v3020 RTC chip.
-
-          This driver can also be built as a module. If so, the module
-          will be called rtc-v3020.
-
 config RTC_DRV_BFIN
         tristate "Blackfin On-Chip RTC"
         depends on RTC_CLASS && BFIN
@@ -364,4 +394,10 @@ config RTC_DRV_BFIN
           This driver can also be built as a module. If so, the module
           will be called rtc-bfin.
 
+config RTC_DRV_RS5C313
+        tristate "Ricoh RS5C313"
+        depends on RTC_CLASS && BROKEN
+        help
+          If you say yes here you get support for the Ricoh RS5C313 RTC chips.
+
 endmenu
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 9218cf28d6ed..a1afbc236073 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -11,9 +11,9 @@ 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
+rtc-core-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o
+rtc-core-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o
+rtc-core-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
 
 obj-$(CONFIG_RTC_DRV_CMOS)      += rtc-cmos.o
 obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
@@ -30,10 +30,12 @@ obj-$(CONFIG_RTC_DRV_S3C)	+= rtc-s3c.o
 obj-$(CONFIG_RTC_DRV_RS5C348)   += rtc-rs5c348.o
 obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
 obj-$(CONFIG_RTC_DRV_DS1553)    += rtc-ds1553.o
+obj-$(CONFIG_RTC_DRV_RS5C313)   += rtc-rs5c313.o
 obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
 obj-$(CONFIG_RTC_DRV_SA1100)    += rtc-sa1100.o
 obj-$(CONFIG_RTC_DRV_VR41XX)    += rtc-vr41xx.o
 obj-$(CONFIG_RTC_DRV_PL031)     += rtc-pl031.o
+obj-$(CONFIG_RTC_DRV_MAX6900)   += rtc-max6900.o
 obj-$(CONFIG_RTC_DRV_MAX6902)   += rtc-max6902.o
 obj-$(CONFIG_RTC_DRV_V3020)     += rtc-v3020.o
 obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 04aaa6347234..8b3cd31d6a61 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -16,19 +16,94 @@
 #include <linux/kdev_t.h>
 #include <linux/idr.h>
 
+#include "rtc-core.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)
+static void rtc_device_release(struct device *dev)
 {
-        struct rtc_device *rtc = to_rtc_device(class_dev);
+        struct rtc_device *rtc = to_rtc_device(dev);
         mutex_lock(&idr_lock);
         idr_remove(&rtc_idr, rtc->id);
         mutex_unlock(&idr_lock);
         kfree(rtc);
 }
 
+#if defined(CONFIG_PM) && defined(CONFIG_RTC_HCTOSYS_DEVICE)
+
+/*
+ * On suspend(), measure the delta between one RTC and the
+ * system's wall clock; restore it on resume().
+ */
+
+static struct timespec  delta;
+static time_t           oldtime;
+
+static int rtc_suspend(struct device *dev, pm_message_t mesg)
+{
+        struct rtc_device       *rtc = to_rtc_device(dev);
+        struct rtc_time         tm;
+
+        if (strncmp(rtc->dev.bus_id,
+                                CONFIG_RTC_HCTOSYS_DEVICE,
+                                BUS_ID_SIZE) != 0)
+                return 0;
+
+        rtc_read_time(rtc, &tm);
+        rtc_tm_to_time(&tm, &oldtime);
+
+        /* RTC precision is 1 second; adjust delta for avg 1/2 sec err */
+        set_normalized_timespec(&delta,
+                                xtime.tv_sec - oldtime,
+                                xtime.tv_nsec - (NSEC_PER_SEC >> 1));
+
+        return 0;
+}
+
+static int rtc_resume(struct device *dev)
+{
+        struct rtc_device       *rtc = to_rtc_device(dev);
+        struct rtc_time         tm;
+        time_t                  newtime;
+        struct timespec         time;
+
+        if (strncmp(rtc->dev.bus_id,
+                                CONFIG_RTC_HCTOSYS_DEVICE,
+                                BUS_ID_SIZE) != 0)
+                return 0;
+
+        rtc_read_time(rtc, &tm);
+        if (rtc_valid_tm(&tm) != 0) {
+                pr_debug("%s:  bogus resume time\n", rtc->dev.bus_id);
+                return 0;
+        }
+        rtc_tm_to_time(&tm, &newtime);
+        if (newtime <= oldtime) {
+                if (newtime < oldtime)
+                        pr_debug("%s:  time travel!\n", rtc->dev.bus_id);
+                return 0;
+        }
+
+        /* restore wall clock using delta against this RTC;
+         * adjust again for avg 1/2 second RTC sampling error
+         */
+        set_normalized_timespec(&time,
+                                newtime + delta.tv_sec,
+                                (NSEC_PER_SEC >> 1) + delta.tv_nsec);
+        do_settimeofday(&time);
+
+        return 0;
+}
+
+#else
+#define rtc_suspend     NULL
+#define rtc_resume      NULL
+#endif
+
+
 /**
  * rtc_device_register - register w/ RTC class
  * @dev: the device to register
@@ -70,23 +145,29 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,
         rtc->ops = ops;
         rtc->owner = owner;
         rtc->max_user_freq = 64;
-        rtc->class_dev.dev = dev;
-        rtc->class_dev.class = rtc_class;
-        rtc->class_dev.release = rtc_device_release;
+        rtc->dev.parent = dev;
+        rtc->dev.class = rtc_class;
+        rtc->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);
+        snprintf(rtc->dev.bus_id, BUS_ID_SIZE, "rtc%d", id);
 
-        err = class_device_register(&rtc->class_dev);
+        rtc_dev_prepare(rtc);
+
+        err = device_register(&rtc->dev);
         if (err)
                 goto exit_kfree;
 
+        rtc_dev_add_device(rtc);
+        rtc_sysfs_add_device(rtc);
+        rtc_proc_add_device(rtc);
+
         dev_info(dev, "rtc core: registered %s as %s\n",
-                        rtc->name, rtc->class_dev.class_id);
+                        rtc->name, rtc->dev.bus_id);
 
         return rtc;
 
@@ -113,26 +194,22 @@ EXPORT_SYMBOL_GPL(rtc_device_register);
  */
 void rtc_device_unregister(struct rtc_device *rtc)
 {
-        if (class_device_get(&rtc->class_dev) != NULL) {
+        if (get_device(&rtc->dev) != NULL) {
                 mutex_lock(&rtc->ops_lock);
                 /* remove innards of this RTC, then disable it, before
                  * letting any rtc_class_open() users access it again
                  */
-                class_device_unregister(&rtc->class_dev);
+                rtc_sysfs_del_device(rtc);
+                rtc_dev_del_device(rtc);
+                rtc_proc_del_device(rtc);
+                device_unregister(&rtc->dev);
                 rtc->ops = NULL;
                 mutex_unlock(&rtc->ops_lock);
-                class_device_put(&rtc->class_dev);
+                put_device(&rtc->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");
@@ -140,11 +217,16 @@ static int __init rtc_init(void)
                 printk(KERN_ERR "%s: couldn't create class\n", __FILE__);
                 return PTR_ERR(rtc_class);
         }
+        rtc_class->suspend = rtc_suspend;
+        rtc_class->resume = rtc_resume;
+        rtc_dev_init();
+        rtc_sysfs_init(rtc_class);
         return 0;
 }
 
 static void __exit rtc_exit(void)
 {
+        rtc_dev_exit();
         class_destroy(rtc_class);
 }
 
diff --git a/drivers/rtc/hctosys.c b/drivers/rtc/hctosys.c
index d02fe9a0001f..178527252c6a 100644
--- a/drivers/rtc/hctosys.c
+++ b/drivers/rtc/hctosys.c
@@ -26,15 +26,15 @@ static int __init rtc_hctosys(void)
 {
         int err;
         struct rtc_time tm;
-        struct class_device *class_dev = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
+        struct rtc_device *rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
 
-        if (class_dev == NULL) {
+        if (rtc == NULL) {
                 printk("%s: unable to open rtc device (%s)\n",
                         __FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
                 return -ENODEV;
         }
 
-        err = rtc_read_time(class_dev, &tm);
+        err = rtc_read_time(rtc, &tm);
         if (err == 0) {
                 err = rtc_valid_tm(&tm);
                 if (err == 0) {
@@ -46,7 +46,7 @@ static int __init rtc_hctosys(void)
 
                         do_settimeofday(&tv);
 
-                        dev_info(class_dev->dev,
+                        dev_info(rtc->dev.parent,
                                 "setting the system clock to "
                                 "%d-%02d-%02d %02d:%02d:%02d (%u)\n",
                                 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
@@ -54,14 +54,14 @@ static int __init rtc_hctosys(void)
                                 (unsigned int) tv.tv_sec);
                 }
                 else
-                        dev_err(class_dev->dev,
+                        dev_err(rtc->dev.parent,
                                 "hctosys: invalid date/time\n");
         }
         else
-                dev_err(class_dev->dev,
+                dev_err(rtc->dev.parent,
                         "hctosys: unable to read the hardware clock\n");
 
-        rtc_class_close(class_dev);
+        rtc_class_close(rtc);
 
         return 0;
 }
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index ef40df0f169d..ad66c6ecf365 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -13,10 +13,9 @@
 
 #include <linux/rtc.h>
 
-int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm)
+int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
 {
         int err;
-        struct rtc_device *rtc = to_rtc_device(class_dev);
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
@@ -28,7 +27,7 @@ int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm)
                 err = -EINVAL;
         else {
                 memset(tm, 0, sizeof(struct rtc_time));
-                err = rtc->ops->read_time(class_dev->dev, tm);
+                err = rtc->ops->read_time(rtc->dev.parent, tm);
         }
 
         mutex_unlock(&rtc->ops_lock);
@@ -36,10 +35,9 @@ int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm)
 }
 EXPORT_SYMBOL_GPL(rtc_read_time);
 
-int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm)
+int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
 {
         int err;
-        struct rtc_device *rtc = to_rtc_device(class_dev);
 
         err = rtc_valid_tm(tm);
         if (err != 0)
@@ -54,17 +52,16 @@ int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm)
         else if (!rtc->ops->set_time)
                 err = -EINVAL;
         else
-                err = rtc->ops->set_time(class_dev->dev, tm);
+                err = rtc->ops->set_time(rtc->dev.parent, 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 rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
 {
         int err;
-        struct rtc_device *rtc = to_rtc_device(class_dev);
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
@@ -73,11 +70,11 @@ int rtc_set_mmss(struct class_device *class_dev, unsigned long secs)
         if (!rtc->ops)
                 err = -ENODEV;
         else if (rtc->ops->set_mmss)
-                err = rtc->ops->set_mmss(class_dev->dev, secs);
+                err = rtc->ops->set_mmss(rtc->dev.parent, 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);
+                err = rtc->ops->read_time(rtc->dev.parent, &old);
                 if (err == 0) {
                         rtc_time_to_tm(secs, &new);
 
@@ -89,7 +86,8 @@ int rtc_set_mmss(struct class_device *class_dev, unsigned long secs)
                          */
                         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);
+                                err = rtc->ops->set_time(rtc->dev.parent,
+                                                &new);
                 }
         }
         else
@@ -101,10 +99,9 @@ int rtc_set_mmss(struct class_device *class_dev, unsigned long secs)
 }
 EXPORT_SYMBOL_GPL(rtc_set_mmss);
 
-int rtc_read_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
+int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 {
         int err;
-        struct rtc_device *rtc = to_rtc_device(class_dev);
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
@@ -116,7 +113,7 @@ int rtc_read_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
                 err = -EINVAL;
         else {
                 memset(alarm, 0, sizeof(struct rtc_wkalrm));
-                err = rtc->ops->read_alarm(class_dev->dev, alarm);
+                err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
         }
 
         mutex_unlock(&rtc->ops_lock);
@@ -124,10 +121,13 @@ int rtc_read_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
 }
 EXPORT_SYMBOL_GPL(rtc_read_alarm);
 
-int rtc_set_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
+int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 {
         int err;
-        struct rtc_device *rtc = to_rtc_device(class_dev);
+
+        err = rtc_valid_tm(&alarm->time);
+        if (err != 0)
+                return err;
 
         err = mutex_lock_interruptible(&rtc->ops_lock);
         if (err)
@@ -138,7 +138,7 @@ int rtc_set_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
         else if (!rtc->ops->set_alarm)
                 err = -EINVAL;
         else
-                err = rtc->ops->set_alarm(class_dev->dev, alarm);
+                err = rtc->ops->set_alarm(rtc->dev.parent, alarm);
 
         mutex_unlock(&rtc->ops_lock);
         return err;
@@ -147,16 +147,14 @@ EXPORT_SYMBOL_GPL(rtc_set_alarm);
 
 /**
  * rtc_update_irq - report RTC periodic, alarm, and/or update irqs
- * @class_dev: the rtc's class device
+ * @rtc: the rtc device
  * @num: how many irqs are being reported (usually one)
  * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
  * Context: in_interrupt(), irqs blocked
  */
-void rtc_update_irq(struct class_device *class_dev,
+void rtc_update_irq(struct rtc_device *rtc,
                 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);
@@ -171,40 +169,43 @@ void rtc_update_irq(struct class_device *class_dev,
 }
 EXPORT_SYMBOL_GPL(rtc_update_irq);
 
-struct class_device *rtc_class_open(char *name)
+struct rtc_device *rtc_class_open(char *name)
 {
-        struct class_device *class_dev = NULL,
-                                *class_dev_tmp;
+        struct device *dev;
+        struct rtc_device *rtc = NULL;
 
         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_device_get(class_dev_tmp);
+        list_for_each_entry(dev, &rtc_class->devices, node) {
+                if (strncmp(dev->bus_id, name, BUS_ID_SIZE) == 0) {
+                        dev = get_device(dev);
+                        if (dev)
+                                rtc = to_rtc_device(dev);
                         break;
                 }
         }
 
-        if (class_dev) {
-                if (!try_module_get(to_rtc_device(class_dev)->owner))
-                        class_dev = NULL;
+        if (rtc) {
+                if (!try_module_get(rtc->owner)) {
+                        put_device(dev);
+                        rtc = NULL;
+                }
         }
         up(&rtc_class->sem);
 
-        return class_dev;
+        return rtc;
 }
 EXPORT_SYMBOL_GPL(rtc_class_open);
 
-void rtc_class_close(struct class_device *class_dev)
+void rtc_class_close(struct rtc_device *rtc)
 {
-        module_put(to_rtc_device(class_dev)->owner);
-        class_device_put(class_dev);
+        module_put(rtc->owner);
+        put_device(&rtc->dev);
 }
 EXPORT_SYMBOL_GPL(rtc_class_close);
 
-int rtc_irq_register(struct class_device *class_dev, struct rtc_task *task)
+int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
 {
         int retval = -EBUSY;
-        struct rtc_device *rtc = to_rtc_device(class_dev);
 
         if (task == NULL || task->func == NULL)
                 return -EINVAL;
@@ -220,9 +221,8 @@ int rtc_irq_register(struct class_device *class_dev, struct rtc_task *task)
 }
 EXPORT_SYMBOL_GPL(rtc_irq_register);
 
-void rtc_irq_unregister(struct class_device *class_dev, struct rtc_task *task)
+void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
 {
-        struct rtc_device *rtc = to_rtc_device(class_dev);
 
         spin_lock_irq(&rtc->irq_task_lock);
         if (rtc->irq_task == task)
@@ -231,11 +231,10 @@ void rtc_irq_unregister(struct class_device *class_dev, struct rtc_task *task)
 }
 EXPORT_SYMBOL_GPL(rtc_irq_unregister);
 
-int rtc_irq_set_state(struct class_device *class_dev, struct rtc_task *task, int enabled)
+int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
 {
         int err = 0;
         unsigned long flags;
-        struct rtc_device *rtc = to_rtc_device(class_dev);
 
         if (rtc->ops->irq_set_state == NULL)
                 return -ENXIO;
@@ -246,17 +245,16 @@ int rtc_irq_set_state(struct class_device *class_dev, struct rtc_task *task, int
         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
 
         if (err == 0)
-                err = rtc->ops->irq_set_state(class_dev->dev, enabled);
+                err = rtc->ops->irq_set_state(rtc->dev.parent, 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 rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
 {
         int err = 0;
         unsigned long flags;
-        struct rtc_device *rtc = to_rtc_device(class_dev);
 
         if (rtc->ops->irq_set_freq == NULL)
                 return -ENXIO;
@@ -267,7 +265,7 @@ int rtc_irq_set_freq(struct class_device *class_dev, struct rtc_task *task, int
         spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
 
         if (err == 0) {
-                err = rtc->ops->irq_set_freq(class_dev->dev, freq);
+                err = rtc->ops->irq_set_freq(rtc->dev.parent, freq);
                 if (err == 0)
                         rtc->irq_freq = freq;
         }
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index ac0e68e2f025..33795e5a5595 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -263,7 +263,7 @@ static irqreturn_t at91_rtc_interrupt(int irq, void *dev_id)
 
                 at91_sys_write(AT91_RTC_SCCR, rtsr);    /* clear status reg */
 
-                rtc_update_irq(&rtc->class_dev, 1, events);
+                rtc_update_irq(rtc, 1, events);
 
                 pr_debug("%s(): num=%ld, events=0x%02lx\n", __FUNCTION__,
                         events >> 8, events & 0x000000FF);
@@ -348,21 +348,10 @@ static int __exit at91_rtc_remove(struct platform_device *pdev)
 
 /* AT91RM9200 RTC Power management control */
 
-static struct timespec at91_rtc_delta;
 static u32 at91_rtc_imr;
 
 static int at91_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 {
-        struct rtc_time tm;
-        struct timespec time;
-
-        time.tv_nsec = 0;
-
-        /* calculate time delta for suspend */
-        at91_rtc_readtime(&pdev->dev, &tm);
-        rtc_tm_to_time(&tm, &time.tv_sec);
-        save_time_delta(&at91_rtc_delta, &time);
-
         /* this IRQ is shared with DBGU and other hardware which isn't
          * necessarily doing PM like we are...
          */
@@ -374,36 +363,17 @@ static int at91_rtc_suspend(struct platform_device *pdev, pm_message_t state)
                 else
                         at91_sys_write(AT91_RTC_IDR, at91_rtc_imr);
         }
-
-        pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
-                1900 + tm.tm_year, tm.tm_mon, tm.tm_mday,
-                tm.tm_hour, tm.tm_min, tm.tm_sec);
-
         return 0;
 }
 
 static int at91_rtc_resume(struct platform_device *pdev)
 {
-        struct rtc_time tm;
-        struct timespec time;
-
-        time.tv_nsec = 0;
-
-        at91_rtc_readtime(&pdev->dev, &tm);
-        rtc_tm_to_time(&tm, &time.tv_sec);
-        restore_time_delta(&at91_rtc_delta, &time);
-
         if (at91_rtc_imr) {
                 if (device_may_wakeup(&pdev->dev))
                         disable_irq_wake(AT91_ID_SYS);
                 else
                         at91_sys_write(AT91_RTC_IER, at91_rtc_imr);
         }
-
-        pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
-                1900 + tm.tm_year, tm.tm_mon, tm.tm_mday,
-                tm.tm_hour, tm.tm_min, tm.tm_sec);
-
         return 0;
 }
 #else
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 7c0d60910077..6085261aa2c1 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -46,6 +46,10 @@ struct cmos_rtc {
         int                     irq;
         struct resource         *iomem;
 
+        void                    (*wake_on)(struct device *);
+        void                    (*wake_off)(struct device *);
+
+        u8                      enabled_wake;
         u8                      suspend_ctrl;
 
         /* newer hardware extends the original register set */
@@ -203,7 +207,7 @@ static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
         rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
         rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
         if (is_intr(rtc_intr))
-                rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr);
+                rtc_update_irq(cmos->rtc, 1, rtc_intr);
 
         /* update alarm */
         CMOS_WRITE(hrs, RTC_HOURS_ALARM);
@@ -223,7 +227,7 @@ static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
                 rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
                 rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
                 if (is_intr(rtc_intr))
-                        rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr);
+                        rtc_update_irq(cmos->rtc, 1, rtc_intr);
         }
 
         spin_unlock_irq(&rtc_lock);
@@ -304,7 +308,7 @@ cmos_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
         rtc_intr &= (rtc_control & RTC_IRQMASK) | RTC_IRQF;
         if (is_intr(rtc_intr))
-                rtc_update_irq(&cmos->rtc->class_dev, 1, rtc_intr);
+                rtc_update_irq(cmos->rtc, 1, rtc_intr);
         spin_unlock_irqrestore(&rtc_lock, flags);
         return 0;
 }
@@ -379,12 +383,12 @@ static irqreturn_t cmos_interrupt(int irq, void *p)
                 return IRQ_NONE;
 }
 
-#ifdef  CONFIG_PNPACPI
-#define is_pnpacpi()    1
+#ifdef  CONFIG_PNP
+#define is_pnp()        1
 #define INITSECTION
 
 #else
-#define is_pnpacpi()    0
+#define is_pnp()        0
 #define INITSECTION     __init
 #endif
 
@@ -405,13 +409,20 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
         cmos_rtc.irq = rtc_irq;
         cmos_rtc.iomem = ports;
 
-        /* For ACPI systems the info comes from the FADT.  On others,
-         * board specific setup provides it as appropriate.
+        /* For ACPI systems extension info comes from the FADT.  On others,
+         * board specific setup provides it as appropriate.  Systems where
+         * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and
+         * some almost-clones) can provide hooks to make that behave.
          */
         if (info) {
                 cmos_rtc.day_alrm = info->rtc_day_alarm;
                 cmos_rtc.mon_alrm = info->rtc_mon_alarm;
                 cmos_rtc.century = info->rtc_century;
+
+                if (info->wake_on && info->wake_off) {
+                        cmos_rtc.wake_on = info->wake_on;
+                        cmos_rtc.wake_off = info->wake_off;
+                }
         }
 
         cmos_rtc.rtc = rtc_device_register(driver_name, dev,
@@ -427,14 +438,14 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
          * REVISIT for non-x86 systems we may need to handle io memory
          * resources: ioremap them, and request_mem_region().
          */
-        if (is_pnpacpi()) {
+        if (is_pnp()) {
                 retval = request_resource(&ioport_resource, ports);
                 if (retval < 0) {
                         dev_dbg(dev, "i/o registers already in use\n");
                         goto cleanup0;
                 }
         }
-        rename_region(ports, cmos_rtc.rtc->class_dev.class_id);
+        rename_region(ports, cmos_rtc.rtc->dev.bus_id);
 
         spin_lock_irq(&rtc_lock);
 
@@ -470,8 +481,8 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
 
         if (is_valid_irq(rtc_irq))
                 retval = request_irq(rtc_irq, cmos_interrupt, IRQF_DISABLED,
-                                cmos_rtc.rtc->class_dev.class_id,
-                                &cmos_rtc.rtc->class_dev);
+                                cmos_rtc.rtc->dev.bus_id,
+                                cmos_rtc.rtc);
         if (retval < 0) {
                 dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq);
                 goto cleanup1;
@@ -483,7 +494,7 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
          */
 
         pr_info("%s: alarms up to one %s%s\n",
-                        cmos_rtc.rtc->class_dev.class_id,
+                        cmos_rtc.rtc->dev.bus_id,
                         is_valid_irq(rtc_irq)
                                 ?  (cmos_rtc.mon_alrm
                                         ? "year"
@@ -520,12 +531,12 @@ static void __exit cmos_do_remove(struct device *dev)
 
         cmos_do_shutdown();
 
-        if (is_pnpacpi())
+        if (is_pnp())
                 release_resource(cmos->iomem);
         rename_region(cmos->iomem, NULL);
 
         if (is_valid_irq(cmos->irq))
-                free_irq(cmos->irq, &cmos_rtc.rtc->class_dev);
+                free_irq(cmos->irq, cmos_rtc.rtc);
 
         rtc_device_unregister(cmos_rtc.rtc);
 
@@ -555,16 +566,20 @@ static int cmos_suspend(struct device *dev, pm_message_t mesg)
                 irqstat = CMOS_READ(RTC_INTR_FLAGS);
                 irqstat &= (tmp & RTC_IRQMASK) | RTC_IRQF;
                 if (is_intr(irqstat))
-                        rtc_update_irq(&cmos->rtc->class_dev, 1, irqstat);
+                        rtc_update_irq(cmos->rtc, 1, irqstat);
         }
         spin_unlock_irq(&rtc_lock);
 
-        /* ACPI HOOK:  enable ACPI_EVENT_RTC when (tmp & RTC_AIE)
-         * ... it'd be best if we could do that under rtc_lock.
-         */
+        if (tmp & RTC_AIE) {
+                cmos->enabled_wake = 1;
+                if (cmos->wake_on)
+                        cmos->wake_on(dev);
+                else
+                        enable_irq_wake(cmos->irq);
+        }
 
         pr_debug("%s: suspend%s, ctrl %02x\n",
-                        cmos_rtc.rtc->class_dev.class_id,
+                        cmos_rtc.rtc->dev.bus_id,
                         (tmp & RTC_AIE) ? ", alarm may wake" : "",
                         tmp);
 
@@ -576,26 +591,28 @@ static int cmos_resume(struct device *dev)
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
         unsigned char   tmp = cmos->suspend_ctrl;
 
-        /* REVISIT:  a mechanism to resync the system clock (jiffies)
-         * on resume should be portable between platforms ...
-         */
-
         /* re-enable any irqs previously active */
         if (tmp & (RTC_PIE|RTC_AIE|RTC_UIE)) {
 
-                /* ACPI HOOK:  disable ACPI_EVENT_RTC when (tmp & RTC_AIE) */
+                if (cmos->enabled_wake) {
+                        if (cmos->wake_off)
+                                cmos->wake_off(dev);
+                        else
+                                disable_irq_wake(cmos->irq);
+                        cmos->enabled_wake = 0;
+                }
 
                 spin_lock_irq(&rtc_lock);
                 CMOS_WRITE(tmp, RTC_CONTROL);
                 tmp = CMOS_READ(RTC_INTR_FLAGS);
                 tmp &= (cmos->suspend_ctrl & RTC_IRQMASK) | RTC_IRQF;
                 if (is_intr(tmp))
-                        rtc_update_irq(&cmos->rtc->class_dev, 1, tmp);
+                        rtc_update_irq(cmos->rtc, 1, tmp);
                 spin_unlock_irq(&rtc_lock);
         }
 
         pr_debug("%s: resume, ctrl %02x\n",
-                        cmos_rtc.rtc->class_dev.class_id,
+                        cmos_rtc.rtc->dev.bus_id,
                         cmos->suspend_ctrl);
 
 
@@ -613,7 +630,7 @@ static int cmos_resume(struct device *dev)
  * the device node will always be created as a PNPACPI device.
  */
 
-#ifdef  CONFIG_PNPACPI
+#ifdef  CONFIG_PNP
 
 #include <linux/pnp.h>
 
@@ -684,11 +701,11 @@ static void __exit cmos_exit(void)
 }
 module_exit(cmos_exit);
 
-#else   /* no PNPACPI */
+#else   /* no PNP */
 
 /*----------------------------------------------------------------*/
 
-/* Platform setup should have set up an RTC device, when PNPACPI is
+/* Platform setup should have set up an RTC device, when PNP is
  * unavailable ... this could happen even on (older) PCs.
  */
 
@@ -734,7 +751,7 @@ static void __exit cmos_exit(void)
 module_exit(cmos_exit);
 
 
-#endif  /* !PNPACPI */
+#endif  /* !PNP */
 
 MODULE_AUTHOR("David Brownell");
 MODULE_DESCRIPTION("Driver for PC-style 'CMOS' RTCs");
diff --git a/drivers/rtc/rtc-core.h b/drivers/rtc/rtc-core.h
new file mode 100644
index 000000000000..5f9df7430a22
--- /dev/null
+++ b/drivers/rtc/rtc-core.h
@@ -0,0 +1,70 @@
+#ifdef CONFIG_RTC_INTF_DEV
+
+extern void __init rtc_dev_init(void);
+extern void __exit rtc_dev_exit(void);
+extern void rtc_dev_prepare(struct rtc_device *rtc);
+extern void rtc_dev_add_device(struct rtc_device *rtc);
+extern void rtc_dev_del_device(struct rtc_device *rtc);
+
+#else
+
+static inline void rtc_dev_init(void)
+{
+}
+
+static inline void rtc_dev_exit(void)
+{
+}
+
+static inline void rtc_dev_prepare(struct rtc_device *rtc)
+{
+}
+
+static inline void rtc_dev_add_device(struct rtc_device *rtc)
+{
+}
+
+static inline void rtc_dev_del_device(struct rtc_device *rtc)
+{
+}
+
+#endif
+
+#ifdef CONFIG_RTC_INTF_PROC
+
+extern void rtc_proc_add_device(struct rtc_device *rtc);
+extern void rtc_proc_del_device(struct rtc_device *rtc);
+
+#else
+
+static inline void rtc_proc_add_device(struct rtc_device *rtc)
+{
+}
+
+static inline void rtc_proc_del_device(struct rtc_device *rtc)
+{
+}
+
+#endif
+
+#ifdef CONFIG_RTC_INTF_SYSFS
+
+extern void __init rtc_sysfs_init(struct class *);
+extern void rtc_sysfs_add_device(struct rtc_device *rtc);
+extern void rtc_sysfs_del_device(struct rtc_device *rtc);
+
+#else
+
+static inline void rtc_sysfs_init(struct class *rtc)
+{
+}
+
+static inline void rtc_sysfs_add_device(struct rtc_device *rtc)
+{
+}
+
+static inline void rtc_sysfs_del_device(struct rtc_device *rtc)
+{
+}
+
+#endif
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 137330b8636b..f4e5f0040ff7 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -13,8 +13,8 @@
 
 #include <linux/module.h>
 #include <linux/rtc.h>
+#include "rtc-core.h"
 
-static struct class *rtc_dev_class;
 static dev_t rtc_devt;
 
 #define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */
@@ -32,9 +32,9 @@ static int rtc_dev_open(struct inode *inode, struct file *file)
         if (!(mutex_trylock(&rtc->char_lock)))
                 return -EBUSY;
 
-        file->private_data = &rtc->class_dev;
+        file->private_data = rtc;
 
-        err = ops->open ? ops->open(rtc->class_dev.dev) : 0;
+        err = ops->open ? ops->open(rtc->dev.parent) : 0;
         if (err == 0) {
                 spin_lock_irq(&rtc->irq_lock);
                 rtc->irq_data = 0;
@@ -61,7 +61,7 @@ static void rtc_uie_task(struct work_struct *work)
         int num = 0;
         int err;
 
-        err = rtc_read_time(&rtc->class_dev, &tm);
+        err = rtc_read_time(rtc, &tm);
 
         local_irq_disable();
         spin_lock(&rtc->irq_lock);
@@ -79,7 +79,7 @@ static void rtc_uie_task(struct work_struct *work)
         }
         spin_unlock(&rtc->irq_lock);
         if (num)
-                rtc_update_irq(&rtc->class_dev, num, RTC_UF | RTC_IRQF);
+                rtc_update_irq(rtc, num, RTC_UF | RTC_IRQF);
         local_irq_enable();
 }
 static void rtc_uie_timer(unsigned long data)
@@ -121,7 +121,7 @@ static int set_uie(struct rtc_device *rtc)
         struct rtc_time tm;
         int err;
 
-        err = rtc_read_time(&rtc->class_dev, &tm);
+        err = rtc_read_time(rtc, &tm);
         if (err)
                 return err;
         spin_lock_irq(&rtc->irq_lock);
@@ -180,7 +180,7 @@ rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
         if (ret == 0) {
                 /* Check for any data updates */
                 if (rtc->ops->read_callback)
-                        data = rtc->ops->read_callback(rtc->class_dev.dev,
+                        data = rtc->ops->read_callback(rtc->dev.parent,
                                                        data);
 
                 if (sizeof(int) != sizeof(long) &&
@@ -210,8 +210,7 @@ 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_device *rtc = file->private_data;
         const struct rtc_class_ops *ops = rtc->ops;
         struct rtc_time tm;
         struct rtc_wkalrm alarm;
@@ -252,7 +251,7 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
 
         /* try the driver's ioctl interface */
         if (ops->ioctl) {
-                err = ops->ioctl(class_dev->dev, cmd, arg);
+                err = ops->ioctl(rtc->dev.parent, cmd, arg);
                 if (err != -ENOIOCTLCMD)
                         return err;
         }
@@ -264,7 +263,7 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
 
         switch (cmd) {
         case RTC_ALM_READ:
-                err = rtc_read_alarm(class_dev, &alarm);
+                err = rtc_read_alarm(rtc, &alarm);
                 if (err < 0)
                         return err;
 
@@ -278,17 +277,53 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
 
                 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);
+
+                /* RTC_ALM_SET alarms may be up to 24 hours in the future.
+                 * Rather than expecting every RTC to implement "don't care"
+                 * for day/month/year fields, just force the alarm to have
+                 * the right values for those fields.
+                 *
+                 * RTC_WKALM_SET should be used instead.  Not only does it
+                 * eliminate the need for a separate RTC_AIE_ON call, it
+                 * doesn't have the "alarm 23:59:59 in the future" race.
+                 *
+                 * NOTE:  some legacy code may have used invalid fields as
+                 * wildcards, exposing hardware "periodic alarm" capabilities.
+                 * Not supported here.
+                 */
+                {
+                        unsigned long now, then;
+
+                        err = rtc_read_time(rtc, &tm);
+                        if (err < 0)
+                                return err;
+                        rtc_tm_to_time(&tm, &now);
+
+                        alarm.time.tm_mday = tm.tm_mday;
+                        alarm.time.tm_mon = tm.tm_mon;
+                        alarm.time.tm_year = tm.tm_year;
+                        err  = rtc_valid_tm(&alarm.time);
+                        if (err < 0)
+                                return err;
+                        rtc_tm_to_time(&alarm.time, &then);
+
+                        /* alarm may need to wrap into tomorrow */
+                        if (then < now) {
+                                rtc_time_to_tm(now + 24 * 60 * 60, &tm);
+                                alarm.time.tm_mday = tm.tm_mday;
+                                alarm.time.tm_mon = tm.tm_mon;
+                                alarm.time.tm_year = tm.tm_year;
+                        }
+                }
+
+                err = rtc_set_alarm(rtc, &alarm);
                 break;
 
         case RTC_RD_TIME:
-                err = rtc_read_time(class_dev, &tm);
+                err = rtc_read_time(rtc, &tm);
                 if (err < 0)
                         return err;
 
@@ -300,7 +335,7 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
                 if (copy_from_user(&tm, uarg, sizeof(tm)))
                         return -EFAULT;
 
-                err = rtc_set_time(class_dev, &tm);
+                err = rtc_set_time(rtc, &tm);
                 break;
 
         case RTC_IRQP_READ:
@@ -310,7 +345,7 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
 
         case RTC_IRQP_SET:
                 if (ops->irq_set_freq)
-                        err = rtc_irq_set_freq(class_dev, rtc->irq_task, arg);
+                        err = rtc_irq_set_freq(rtc, rtc->irq_task, arg);
                 break;
 
 #if 0
@@ -336,11 +371,11 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
                 if (copy_from_user(&alarm, uarg, sizeof(alarm)))
                         return -EFAULT;
 
-                err = rtc_set_alarm(class_dev, &alarm);
+                err = rtc_set_alarm(rtc, &alarm);
                 break;
 
         case RTC_WKALM_RD:
-                err = rtc_read_alarm(class_dev, &alarm);
+                err = rtc_read_alarm(rtc, &alarm);
                 if (err < 0)
                         return err;
 
@@ -372,7 +407,7 @@ static int rtc_dev_release(struct inode *inode, struct file *file)
         clear_uie(rtc);
 #endif
         if (rtc->ops->release)
-                rtc->ops->release(rtc->class_dev.dev);
+                rtc->ops->release(rtc->dev.parent);
 
         mutex_unlock(&rtc->char_lock);
         return 0;
@@ -397,17 +432,18 @@ static const struct file_operations rtc_dev_fops = {
 
 /* insertion/removal hooks */
 
-static int rtc_dev_add_device(struct class_device *class_dev,
-                                struct class_interface *class_intf)
+void rtc_dev_prepare(struct rtc_device *rtc)
 {
-        int err = 0;
-        struct rtc_device *rtc = to_rtc_device(class_dev);
+        if (!rtc_devt)
+                return;
 
         if (rtc->id >= RTC_DEV_MAX) {
-                dev_err(class_dev->dev, "too many RTCs\n");
-                return -EINVAL;
+                pr_debug("%s: too many RTC devices\n", rtc->name);
+                return;
         }
 
+        rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);
+
         mutex_init(&rtc->char_lock);
         spin_lock_init(&rtc->irq_lock);
         init_waitqueue_head(&rtc->irq_queue);
@@ -418,100 +454,36 @@ static int rtc_dev_add_device(struct class_device *class_dev,
 
         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)) {
-                dev_err(class_dev->dev,
-                        "failed to add char device %d:%d\n",
+void rtc_dev_add_device(struct rtc_device *rtc)
+{
+        if (cdev_add(&rtc->char_dev, rtc->dev.devt, 1))
+                printk(KERN_WARNING "%s: failed to add char device %d:%d\n",
+                        rtc->name, MAJOR(rtc_devt), rtc->id);
+        else
+                pr_debug("%s: dev (%d:%d)\n", rtc->name,
                         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_dbg(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)
+void rtc_dev_del_device(struct rtc_device *rtc)
 {
-        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);
+        if (rtc->dev.devt)
                 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)
+void __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) {
+        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)
+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);
+        if (rtc_devt)
+                unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
 }
-
-subsys_initcall(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-ds1553.c b/drivers/rtc/rtc-ds1553.c
index e27176c0e18f..afa64c7fa2e2 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -203,7 +203,7 @@ static irqreturn_t ds1553_rtc_interrupt(int irq, void *dev_id)
                 events |= RTC_UF;
         else
                 events |= RTC_AF;
-        rtc_update_irq(&pdata->rtc->class_dev, 1, events);
+        rtc_update_irq(pdata->rtc, 1, events);
         return IRQ_HANDLED;
 }
 
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
index 7bbc26a34bd2..ba795a4db1e9 100644
--- a/drivers/rtc/rtc-lib.c
+++ b/drivers/rtc/rtc-lib.c
@@ -117,85 +117,4 @@ int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
 }
 EXPORT_SYMBOL(rtc_tm_to_time);
 
-
-/* Merge the valid (i.e. non-negative) fields of alarm into the current
- * time.  If the valid alarm fields are earlier than the equivalent
- * fields in the time, carry one into the least significant invalid
- * field, so that the alarm expiry is in the future.  It assumes that the
- * least significant invalid field is more significant than the most
- * significant valid field, and that the seconds field is valid.
- *
- * This is used by alarms that take relative (rather than absolute)
- * times, and/or have a simple binary second counter instead of
- * day/hour/minute/sec registers.
- */
-void rtc_merge_alarm(struct rtc_time *now, struct rtc_time *alarm)
-{
-        int *alarmp = &alarm->tm_sec;
-        int *timep = &now->tm_sec;
-        int carry_into, i;
-
-        /* Ignore everything past the 6th element (tm_year). */
-        for (i = 5; i > 0; i--) {
-                if (alarmp[i] < 0)
-                        alarmp[i] = timep[i];
-                else
-                        break;
-        }
-
-        /* No carry needed if all fields are valid. */
-        if (i == 5)
-                return;
-
-        for (carry_into = i + 1; i >= 0; i--) {
-                if (alarmp[i] < timep[i])
-                        break;
-
-                if (alarmp[i] > timep[i])
-                        return;
-        }
-
-        switch (carry_into) {
-                case 1:
-                        alarm->tm_min++;
-
-                        if (alarm->tm_min < 60)
-                                return;
-
-                        alarm->tm_min = 0;
-                        /* fall-through */
-
-                case 2:
-                        alarm->tm_hour++;
-
-                        if (alarm->tm_hour < 60)
-                                return;
-
-                        alarm->tm_hour = 0;
-                        /* fall-through */
-
-                case 3:
-                        alarm->tm_mday++;
-
-                        if (alarm->tm_mday <= rtc_days_in_month[alarm->tm_mon])
-                                return;
-
-                        alarm->tm_mday = 1;
-                        /* fall-through */
-
-                case 4:
-                        alarm->tm_mon++;
-
-                        if (alarm->tm_mon <= 12)
-                                return;
-
-                        alarm->tm_mon = 1;
-                        /* fall-through */
-
-                case 5:
-                        alarm->tm_year++;
-        }
-}
-EXPORT_SYMBOL(rtc_merge_alarm);
-
 MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
new file mode 100644
index 000000000000..eee4ee5bb75a
--- /dev/null
+++ b/drivers/rtc/rtc-max6900.c
@@ -0,0 +1,311 @@
+/*
+ * rtc class driver for the Maxim MAX6900 chip
+ *
+ * Author: Dale Farnsworth <dale@farnsworth.org>
+ *
+ * based on previously existing rtc class drivers
+ *
+ * 2007 (c) MontaVista, Software, Inc.  This file is licensed under
+ * the terms of the GNU General Public License version 2.  This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+#include <linux/delay.h>
+
+#define DRV_NAME "max6900"
+#define DRV_VERSION "0.1"
+
+/*
+ * register indices
+ */
+#define MAX6900_REG_SC                  0       /* seconds      00-59 */
+#define MAX6900_REG_MN                  1       /* minutes      00-59 */
+#define MAX6900_REG_HR                  2       /* hours        00-23 */
+#define MAX6900_REG_DT                  3       /* day of month 00-31 */
+#define MAX6900_REG_MO                  4       /* month        01-12 */
+#define MAX6900_REG_DW                  5       /* day of week   1-7  */
+#define MAX6900_REG_YR                  6       /* year         00-99 */
+#define MAX6900_REG_CT                  7       /* control */
+#define MAX6900_REG_LEN                 8
+
+#define MAX6900_REG_CT_WP               (1 << 7)        /* Write Protect */
+
+/*
+ * register read/write commands
+ */
+#define MAX6900_REG_CONTROL_WRITE       0x8e
+#define MAX6900_REG_BURST_READ          0xbf
+#define MAX6900_REG_BURST_WRITE         0xbe
+#define MAX6900_REG_RESERVED_READ       0x96
+
+#define MAX6900_IDLE_TIME_AFTER_WRITE   3       /* specification says 2.5 mS */
+
+#define MAX6900_I2C_ADDR                0xa0
+
+static unsigned short normal_i2c[] = {
+        MAX6900_I2C_ADDR >> 1,
+        I2C_CLIENT_END
+};
+
+I2C_CLIENT_INSMOD;                      /* defines addr_data */
+
+static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind);
+
+static int max6900_i2c_read_regs(struct i2c_client *client, u8 *buf)
+{
+        u8 reg_addr[1] = { MAX6900_REG_BURST_READ };
+        struct i2c_msg msgs[2] = {
+                {
+                        .addr   = client->addr,
+                        .flags  = 0, /* write */
+                        .len    = sizeof(reg_addr),
+                        .buf    = reg_addr
+                },
+                {
+                        .addr   = client->addr,
+                        .flags  = I2C_M_RD,
+                        .len    = MAX6900_REG_LEN,
+                        .buf    = buf
+                }
+        };
+        int rc;
+
+        rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+        if (rc != ARRAY_SIZE(msgs)) {
+                dev_err(&client->dev, "%s: register read failed\n",
+                        __FUNCTION__);
+                return -EIO;
+        }
+        return 0;
+}
+
+static int max6900_i2c_write_regs(struct i2c_client *client, u8 const *buf)
+{
+        u8 i2c_buf[MAX6900_REG_LEN + 1] = { MAX6900_REG_BURST_WRITE };
+        struct i2c_msg msgs[1] = {
+                {
+                        .addr   = client->addr,
+                        .flags  = 0, /* write */
+                        .len    = MAX6900_REG_LEN + 1,
+                        .buf    = i2c_buf
+                }
+        };
+        int rc;
+
+        memcpy(&i2c_buf[1], buf, MAX6900_REG_LEN);
+
+        rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+        if (rc != ARRAY_SIZE(msgs)) {
+                dev_err(&client->dev, "%s: register write failed\n",
+                        __FUNCTION__);
+                return -EIO;
+        }
+        msleep(MAX6900_IDLE_TIME_AFTER_WRITE);
+        return 0;
+}
+
+static int max6900_i2c_validate_client(struct i2c_client *client)
+{
+        u8 regs[MAX6900_REG_LEN];
+        u8 zero_mask[MAX6900_REG_LEN] = {
+                0x80,   /* seconds */
+                0x80,   /* minutes */
+                0x40,   /* hours */
+                0xc0,   /* day of month */
+                0xe0,   /* month */
+                0xf8,   /* day of week */
+                0x00,   /* year */
+                0x7f,   /* control */
+        };
+        int i;
+        int rc;
+        int reserved;
+
+        reserved = i2c_smbus_read_byte_data(client, MAX6900_REG_RESERVED_READ);
+        if (reserved != 0x07)
+                return -ENODEV;
+
+        rc = max6900_i2c_read_regs(client, regs);
+        if (rc < 0)
+                return rc;
+
+        for (i = 0; i < MAX6900_REG_LEN; ++i) {
+                if (regs[i] & zero_mask[i])
+                        return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
+{
+        int rc;
+        u8 regs[MAX6900_REG_LEN];
+
+        rc = max6900_i2c_read_regs(client, regs);
+        if (rc < 0)
+                return rc;
+
+        tm->tm_sec = BCD2BIN(regs[MAX6900_REG_SC]);
+        tm->tm_min = BCD2BIN(regs[MAX6900_REG_MN]);
+        tm->tm_hour = BCD2BIN(regs[MAX6900_REG_HR] & 0x3f);
+        tm->tm_mday = BCD2BIN(regs[MAX6900_REG_DT]);
+        tm->tm_mon = BCD2BIN(regs[MAX6900_REG_MO]) - 1;
+        tm->tm_year = BCD2BIN(regs[MAX6900_REG_YR]) + 100;
+        tm->tm_wday = BCD2BIN(regs[MAX6900_REG_DW]);
+
+        return 0;
+}
+
+static int max6900_i2c_clear_write_protect(struct i2c_client *client)
+{
+        int rc;
+        rc = i2c_smbus_write_byte_data (client, MAX6900_REG_CONTROL_WRITE, 0);
+        if (rc < 0) {
+                dev_err(&client->dev, "%s: control register write failed\n",
+                        __FUNCTION__);
+                return -EIO;
+        }
+        return 0;
+}
+
+static int max6900_i2c_set_time(struct i2c_client *client,
+                                struct rtc_time const *tm)
+{
+        u8 regs[MAX6900_REG_LEN];
+        int rc;
+
+        rc = max6900_i2c_clear_write_protect(client);
+        if (rc < 0)
+                return rc;
+
+        regs[MAX6900_REG_SC] = BIN2BCD(tm->tm_sec);
+        regs[MAX6900_REG_MN] = BIN2BCD(tm->tm_min);
+        regs[MAX6900_REG_HR] = BIN2BCD(tm->tm_hour);
+        regs[MAX6900_REG_DT] = BIN2BCD(tm->tm_mday);
+        regs[MAX6900_REG_MO] = BIN2BCD(tm->tm_mon + 1);
+        regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year - 100);
+        regs[MAX6900_REG_DW] = BIN2BCD(tm->tm_wday);
+        regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;       /* set write protect */
+
+        rc = max6900_i2c_write_regs(client, regs);
+        if (rc < 0)
+                return rc;
+
+        return 0;
+}
+
+static int max6900_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return max6900_i2c_read_time(to_i2c_client(dev), tm);
+}
+
+static int max6900_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return max6900_i2c_set_time(to_i2c_client(dev), tm);
+}
+
+static int max6900_attach_adapter(struct i2c_adapter *adapter)
+{
+        return i2c_probe(adapter, &addr_data, max6900_probe);
+}
+
+static int max6900_detach_client(struct i2c_client *client)
+{
+        struct rtc_device *const rtc = i2c_get_clientdata(client);
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        return i2c_detach_client(client);
+}
+
+static struct i2c_driver max6900_driver = {
+        .driver         = {
+                .name   = DRV_NAME,
+        },
+        .id             = I2C_DRIVERID_MAX6900,
+        .attach_adapter = max6900_attach_adapter,
+        .detach_client  = max6900_detach_client,
+};
+
+static const struct rtc_class_ops max6900_rtc_ops = {
+        .read_time      = max6900_rtc_read_time,
+        .set_time       = max6900_rtc_set_time,
+};
+
+static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind)
+{
+        int rc = 0;
+        struct i2c_client *client = NULL;
+        struct rtc_device *rtc = NULL;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+                rc = -ENODEV;
+                goto failout;
+        }
+
+        client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
+        if (client == NULL) {
+                rc = -ENOMEM;
+                goto failout;
+        }
+
+        client->addr = addr;
+        client->adapter = adapter;
+        client->driver = &max6900_driver;
+        strlcpy(client->name, DRV_NAME, I2C_NAME_SIZE);
+
+        if (kind < 0) {
+                rc = max6900_i2c_validate_client(client);
+                if (rc < 0)
+                        goto failout;
+        }
+
+        rc = i2c_attach_client(client);
+        if (rc < 0)
+                goto failout;
+
+        dev_info(&client->dev,
+                 "chip found, driver version " DRV_VERSION "\n");
+
+        rtc = rtc_device_register(max6900_driver.driver.name,
+                                  &client->dev,
+                                  &max6900_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                rc = PTR_ERR(rtc);
+                goto failout_detach;
+        }
+
+        i2c_set_clientdata(client, rtc);
+
+        return 0;
+
+failout_detach:
+        i2c_detach_client(client);
+failout:
+        kfree(client);
+        return rc;
+}
+
+static int __init max6900_init(void)
+{
+        return i2c_add_driver(&max6900_driver);
+}
+
+static void __exit max6900_exit(void)
+{
+        i2c_del_driver(&max6900_driver);
+}
+
+MODULE_DESCRIPTION("Maxim MAX6900 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+
+module_init(max6900_init);
+module_exit(max6900_exit);
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 9de8d67f4f8d..60a8a4bb8bd2 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -124,7 +124,7 @@ static void rtc_wait_not_busy(void)
         /* now we have ~15 usec to read/write various registers */
 }
 
-static irqreturn_t rtc_irq(int irq, void *class_dev)
+static irqreturn_t rtc_irq(int irq, void *rtc)
 {
         unsigned long           events = 0;
         u8                      irq_data;
@@ -141,7 +141,7 @@ static irqreturn_t rtc_irq(int irq, void *class_dev)
         if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
                 events |= RTC_IRQF | RTC_UF;
 
-        rtc_update_irq(class_dev, 1, events);
+        rtc_update_irq(rtc, 1, events);
 
         return IRQ_HANDLED;
 }
@@ -289,34 +289,6 @@ static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
         u8 reg;
 
-        /* Much userspace code uses RTC_ALM_SET, thus "don't care" for
-         * day/month/year specifies alarms up to 24 hours in the future.
-         * So we need to handle that ... but let's ignore the "don't care"
-         * values for hours/minutes/seconds.
-         */
-        if (alm->time.tm_mday <= 0
-                        && alm->time.tm_mon < 0
-                        && alm->time.tm_year < 0) {
-                struct rtc_time tm;
-                unsigned long now, then;
-
-                omap_rtc_read_time(dev, &tm);
-                rtc_tm_to_time(&tm, &now);
-
-                alm->time.tm_mday = tm.tm_mday;
-                alm->time.tm_mon = tm.tm_mon;
-                alm->time.tm_year = tm.tm_year;
-                rtc_tm_to_time(&alm->time, &then);
-
-                /* sometimes the alarm wraps into tomorrow */
-                if (then < now) {
-                        rtc_time_to_tm(now + 24 * 60 * 60, &tm);
-                        alm->time.tm_mday = tm.tm_mday;
-                        alm->time.tm_mon = tm.tm_mon;
-                        alm->time.tm_year = tm.tm_year;
-                }
-        }
-
         if (tm2bcd(&alm->time) < 0)
                 return -EINVAL;
 
@@ -399,7 +371,7 @@ static int __devinit omap_rtc_probe(struct platform_device *pdev)
                 goto fail;
         }
         platform_set_drvdata(pdev, rtc);
-        class_set_devdata(&rtc->class_dev, mem);
+        dev_set_devdata(&rtc->dev, mem);
 
         /* clear pending irqs, and set 1/second periodic,
          * which we'll use instead of update irqs
@@ -418,13 +390,13 @@ static int __devinit omap_rtc_probe(struct platform_device *pdev)
 
         /* handle periodic and alarm irqs */
         if (request_irq(omap_rtc_timer, rtc_irq, IRQF_DISABLED,
-                        rtc->class_dev.class_id, &rtc->class_dev)) {
+                        rtc->dev.bus_id, rtc)) {
                 pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
                         pdev->name, omap_rtc_timer);
                 goto fail0;
         }
         if (request_irq(omap_rtc_alarm, rtc_irq, IRQF_DISABLED,
-                        rtc->class_dev.class_id, &rtc->class_dev)) {
+                        rtc->dev.bus_id, rtc)) {
                 pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
                         pdev->name, omap_rtc_alarm);
                 goto fail1;
@@ -481,26 +453,17 @@ static int __devexit omap_rtc_remove(struct platform_device *pdev)
         free_irq(omap_rtc_timer, rtc);
         free_irq(omap_rtc_alarm, rtc);
 
-        release_resource(class_get_devdata(&rtc->class_dev));
+        release_resource(dev_get_devdata(&rtc->dev));
         rtc_device_unregister(rtc);
         return 0;
 }
 
 #ifdef CONFIG_PM
 
-static struct timespec rtc_delta;
 static u8 irqstat;
 
 static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 {
-        struct rtc_time rtc_tm;
-        struct timespec time;
-
-        time.tv_nsec = 0;
-        omap_rtc_read_time(NULL, &rtc_tm);
-        rtc_tm_to_time(&rtc_tm, &time.tv_sec);
-
-        save_time_delta(&rtc_delta, &time);
         irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
 
         /* FIXME the RTC alarm is not currently acting as a wakeup event
@@ -517,14 +480,6 @@ static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 
 static int omap_rtc_resume(struct platform_device *pdev)
 {
-        struct rtc_time rtc_tm;
-        struct timespec time;
-
-        time.tv_nsec = 0;
-        omap_rtc_read_time(NULL, &rtc_tm);
-        rtc_tm_to_time(&rtc_tm, &time.tv_sec);
-
-        restore_time_delta(&rtc_delta, &time);
         if (device_may_wakeup(&pdev->dev))
                 disable_irq_wake(omap_rtc_alarm);
         else
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
index f13daa9fecaa..e4bf68ca96f7 100644
--- a/drivers/rtc/rtc-pl031.c
+++ b/drivers/rtc/rtc-pl031.c
@@ -51,7 +51,7 @@ static irqreturn_t pl031_interrupt(int irq, void *dev_id)
 {
         struct rtc_device *rtc = dev_id;
 
-        rtc_update_irq(&rtc->class_dev, 1, RTC_AF);
+        rtc_update_irq(rtc, 1, RTC_AF);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/rtc/rtc-proc.c b/drivers/rtc/rtc-proc.c
index 1bd624fc685c..8d300e6d0d9e 100644
--- a/drivers/rtc/rtc-proc.c
+++ b/drivers/rtc/rtc-proc.c
@@ -16,18 +16,18 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 
-static struct class_device *rtc_dev = NULL;
-static DEFINE_MUTEX(rtc_lock);
+#include "rtc-core.h"
+
 
 static int rtc_proc_show(struct seq_file *seq, void *offset)
 {
         int err;
-        struct class_device *class_dev = seq->private;
-        const struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops;
+        struct rtc_device *rtc = seq->private;
+        const struct rtc_class_ops *ops = rtc->ops;
         struct rtc_wkalrm alrm;
         struct rtc_time tm;
 
-        err = rtc_read_time(class_dev, &tm);
+        err = rtc_read_time(rtc, &tm);
         if (err == 0) {
                 seq_printf(seq,
                         "rtc_time\t: %02d:%02d:%02d\n"
@@ -36,7 +36,7 @@ static int rtc_proc_show(struct seq_file *seq, void *offset)
                         tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
         }
 
-        err = rtc_read_alarm(class_dev, &alrm);
+        err = rtc_read_alarm(rtc, &alrm);
         if (err == 0) {
                 seq_printf(seq, "alrm_time\t: ");
                 if ((unsigned int)alrm.time.tm_hour <= 24)
@@ -74,19 +74,19 @@ static int rtc_proc_show(struct seq_file *seq, void *offset)
         seq_printf(seq, "24hr\t\t: yes\n");
 
         if (ops->proc)
-                ops->proc(class_dev->dev, seq);
+                ops->proc(rtc->dev.parent, seq);
 
         return 0;
 }
 
 static int rtc_proc_open(struct inode *inode, struct file *file)
 {
-        struct class_device *class_dev = PDE(inode)->data;
+        struct rtc_device *rtc = PDE(inode)->data;
 
         if (!try_module_get(THIS_MODULE))
                 return -ENODEV;
 
-        return single_open(file, rtc_proc_show, class_dev);
+        return single_open(file, rtc_proc_show, rtc);
 }
 
 static int rtc_proc_release(struct inode *inode, struct file *file)
@@ -103,62 +103,22 @@ static const struct file_operations rtc_proc_fops = {
         .release        = rtc_proc_release,
 };
 
-static int rtc_proc_add_device(struct class_device *class_dev,
-                                        struct class_interface *class_intf)
+void rtc_proc_add_device(struct rtc_device *rtc)
 {
-        mutex_lock(&rtc_lock);
-        if (rtc_dev == NULL) {
+        if (rtc->id == 0) {
                 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_dbg(class_dev->dev, "rtc intf: proc\n");
+                        ent->data = rtc;
                 }
-                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)
+void rtc_proc_del_device(struct rtc_device *rtc)
 {
-        mutex_lock(&rtc_lock);
-        if (rtc_dev == class_dev) {
+        if (rtc->id == 0)
                 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);
-}
-
-subsys_initcall(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-rs5c313.c b/drivers/rtc/rtc-rs5c313.c
new file mode 100644
index 000000000000..9d6de371495b
--- /dev/null
+++ b/drivers/rtc/rtc-rs5c313.c
@@ -0,0 +1,405 @@
+/*
+ * Ricoh RS5C313 RTC device/driver
+ *  Copyright (C) 2007 Nobuhiro Iwamatsu
+ *
+ *  2005-09-19 modifed by kogiidena
+ *
+ * Based on the old drivers/char/rs5c313_rtc.c  by:
+ *  Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org>
+ *  Copyright (C) 1999 Tetsuya Okada & Niibe Yutaka
+ *
+ * Based on code written by Paul Gortmaker.
+ *  Copyright (C) 1996 Paul Gortmaker
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Based on other minimal char device drivers, like Alan's
+ * watchdog, Ted's random, etc. etc.
+ *
+ *      1.07    Paul Gortmaker.
+ *      1.08    Miquel van Smoorenburg: disallow certain things on the
+ *              DEC Alpha as the CMOS clock is also used for other things.
+ *      1.09    Nikita Schmidt: epoch support and some Alpha cleanup.
+ *      1.09a   Pete Zaitcev: Sun SPARC
+ *      1.09b   Jeff Garzik: Modularize, init cleanup
+ *      1.09c   Jeff Garzik: SMP cleanup
+ *      1.10    Paul Barton-Davis: add support for async I/O
+ *      1.10a   Andrea Arcangeli: Alpha updates
+ *      1.10b   Andrew Morton: SMP lock fix
+ *      1.10c   Cesar Barros: SMP locking fixes and cleanup
+ *      1.10d   Paul Gortmaker: delete paranoia check in rtc_exit
+ *      1.10e   Maciej W. Rozycki: Handle DECstation's year weirdness.
+ *      1.11    Takashi Iwai: Kernel access functions
+ *                            rtc_register/rtc_unregister/rtc_control
+ *      1.11a   Daniele Bellucci: Audit create_proc_read_entry in rtc_init
+ *      1.12    Venkatesh Pallipadi: Hooks for emulating rtc on HPET base-timer
+ *              CONFIG_HPET_EMULATE_RTC
+ *      1.13    Nobuhiro Iwamatsu: Updata driver.
+ */
+
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/bcd.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+
+#define DRV_NAME        "rs5c313"
+#define DRV_VERSION     "1.13"
+
+#ifdef CONFIG_SH_LANDISK
+/*****************************************************/
+/* LANDISK dependence part of RS5C313                */
+/*****************************************************/
+
+#define SCSMR1          0xFFE00000
+#define SCSCR1          0xFFE00008
+#define SCSMR1_CA       0x80
+#define SCSCR1_CKE      0x03
+#define SCSPTR1         0xFFE0001C
+#define SCSPTR1_EIO     0x80
+#define SCSPTR1_SPB1IO  0x08
+#define SCSPTR1_SPB1DT  0x04
+#define SCSPTR1_SPB0IO  0x02
+#define SCSPTR1_SPB0DT  0x01
+
+#define SDA_OEN         SCSPTR1_SPB1IO
+#define SDA             SCSPTR1_SPB1DT
+#define SCL_OEN         SCSPTR1_SPB0IO
+#define SCL             SCSPTR1_SPB0DT
+
+/* RICOH RS5C313 CE port */
+#define RS5C313_CE      0xB0000003
+
+/* RICOH RS5C313 CE port bit */
+#define RS5C313_CE_RTCCE        0x02
+
+/* SCSPTR1 data */
+unsigned char scsptr1_data;
+
+#define RS5C313_CEENABLE    ctrl_outb(RS5C313_CE_RTCCE, RS5C313_CE);
+#define RS5C313_CEDISABLE   ctrl_outb(0x00, RS5C313_CE)
+#define RS5C313_MISCOP      ctrl_outb(0x02, 0xB0000008)
+
+static void rs5c313_init_port(void)
+{
+        /* Set SCK as I/O port and Initialize SCSPTR1 data & I/O port. */
+        ctrl_outb(ctrl_inb(SCSMR1) & ~SCSMR1_CA, SCSMR1);
+        ctrl_outb(ctrl_inb(SCSCR1) & ~SCSCR1_CKE, SCSCR1);
+
+        /* And Initialize SCL for RS5C313 clock */
+        scsptr1_data = ctrl_inb(SCSPTR1) | SCL; /* SCL:H */
+        ctrl_outb(scsptr1_data, SCSPTR1);
+        scsptr1_data = ctrl_inb(SCSPTR1) | SCL_OEN;     /* SCL output enable */
+        ctrl_outb(scsptr1_data, SCSPTR1);
+        RS5C313_CEDISABLE;      /* CE:L */
+}
+
+static void rs5c313_write_data(unsigned char data)
+{
+        int i;
+
+        for (i = 0; i < 8; i++) {
+                /* SDA:Write Data */
+                scsptr1_data = (scsptr1_data & ~SDA) |
+                                ((((0x80 >> i) & data) >> (7 - i)) << 2);
+                ctrl_outb(scsptr1_data, SCSPTR1);
+                if (i == 0) {
+                        scsptr1_data |= SDA_OEN;        /* SDA:output enable */
+                        ctrl_outb(scsptr1_data, SCSPTR1);
+                }
+                ndelay(700);
+                scsptr1_data &= ~SCL;   /* SCL:L */
+                ctrl_outb(scsptr1_data, SCSPTR1);
+                ndelay(700);
+                scsptr1_data |= SCL;    /* SCL:H */
+                ctrl_outb(scsptr1_data, SCSPTR1);
+        }
+
+        scsptr1_data &= ~SDA_OEN;       /* SDA:output disable */
+        ctrl_outb(scsptr1_data, SCSPTR1);
+}
+
+static unsigned char rs5c313_read_data(void)
+{
+        int i;
+        unsigned char data;
+
+        for (i = 0; i < 8; i++) {
+                ndelay(700);
+                /* SDA:Read Data */
+                data |= ((ctrl_inb(SCSPTR1) & SDA) >> 2) << (7 - i);
+                scsptr1_data &= ~SCL;   /* SCL:L */
+                ctrl_outb(scsptr1_data, SCSPTR1);
+                ndelay(700);
+                scsptr1_data |= SCL;    /* SCL:H */
+                ctrl_outb(scsptr1_data, SCSPTR1);
+        }
+        return data & 0x0F;
+}
+
+#endif /* CONFIG_SH_LANDISK */
+
+/*****************************************************/
+/* machine independence part of RS5C313              */
+/*****************************************************/
+
+/* RICOH RS5C313 address */
+#define RS5C313_ADDR_SEC        0x00
+#define RS5C313_ADDR_SEC10      0x01
+#define RS5C313_ADDR_MIN        0x02
+#define RS5C313_ADDR_MIN10      0x03
+#define RS5C313_ADDR_HOUR       0x04
+#define RS5C313_ADDR_HOUR10     0x05
+#define RS5C313_ADDR_WEEK       0x06
+#define RS5C313_ADDR_INTINTVREG 0x07
+#define RS5C313_ADDR_DAY        0x08
+#define RS5C313_ADDR_DAY10      0x09
+#define RS5C313_ADDR_MON        0x0A
+#define RS5C313_ADDR_MON10      0x0B
+#define RS5C313_ADDR_YEAR       0x0C
+#define RS5C313_ADDR_YEAR10     0x0D
+#define RS5C313_ADDR_CNTREG     0x0E
+#define RS5C313_ADDR_TESTREG    0x0F
+
+/* RICOH RS5C313 control register */
+#define RS5C313_CNTREG_ADJ_BSY  0x01
+#define RS5C313_CNTREG_WTEN_XSTP        0x02
+#define RS5C313_CNTREG_12_24    0x04
+#define RS5C313_CNTREG_CTFG     0x08
+
+/* RICOH RS5C313 test register */
+#define RS5C313_TESTREG_TEST    0x01
+
+/* RICOH RS5C313 control bit */
+#define RS5C313_CNTBIT_READ     0x40
+#define RS5C313_CNTBIT_AD       0x20
+#define RS5C313_CNTBIT_DT       0x10
+
+static unsigned char rs5c313_read_reg(unsigned char addr)
+{
+
+        rs5c313_write_data(addr | RS5C313_CNTBIT_READ | RS5C313_CNTBIT_AD);
+        return rs5c313_read_data();
+}
+
+static void rs5c313_write_reg(unsigned char addr, unsigned char data)
+{
+        data &= 0x0f;
+        rs5c313_write_data(addr | RS5C313_CNTBIT_AD);
+        rs5c313_write_data(data | RS5C313_CNTBIT_DT);
+        return;
+}
+
+static inline unsigned char rs5c313_read_cntreg(unsigned char addr)
+{
+        return rs5c313_read_reg(RS5C313_ADDR_CNTREG);
+}
+
+static inline void rs5c313_write_cntreg(unsigned char data)
+{
+        rs5c313_write_reg(RS5C313_ADDR_CNTREG, data);
+}
+
+static inline void rs5c313_write_intintvreg(unsigned char data)
+{
+        rs5c313_write_reg(RS5C313_ADDR_INTINTVREG, data);
+}
+
+static int rs5c313_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        int data;
+
+        while (1) {
+                RS5C313_CEENABLE;       /* CE:H */
+
+                /* Initialize control reg. 24 hour */
+                rs5c313_write_cntreg(0x04);
+
+                if (!(rs5c313_read_cntreg() & RS5C313_CNTREG_ADJ_BSY))
+                        break;
+
+                RS5C313_CEDISABLE;
+                ndelay(700);    /* CE:L */
+
+        }
+
+        data = rs5c313_read_reg(RS5C313_ADDR_SEC);
+        data |= (rs5c313_read_reg(RS5C313_ADDR_SEC10) << 4);
+        tm->tm_sec = BCD2BIN(data);
+
+        data = rs5c313_read_reg(RS5C313_ADDR_MIN);
+        data |= (rs5c313_read_reg(RS5C313_ADDR_MIN10) << 4);
+        tm->tm_min = BCD2BIN(data);
+
+        data = rs5c313_read_reg(RS5C313_ADDR_HOUR);
+        data |= (rs5c313_read_reg(RS5C313_ADDR_HOUR10) << 4);
+        tm->tm_hour = BCD2BIN(data);
+
+        data = rs5c313_read_reg(RS5C313_ADDR_DAY);
+        data |= (rs5c313_read_reg(RS5C313_ADDR_DAY10) << 4);
+        tm->tm_mday = BCD2BIN(data);
+
+        data = rs5c313_read_reg(RS5C313_ADDR_MON);
+        data |= (rs5c313_read_reg(RS5C313_ADDR_MON10) << 4);
+        tm->tm_mon = BCD2BIN(data) - 1;
+
+        data = rs5c313_read_reg(RS5C313_ADDR_YEAR);
+        data |= (rs5c313_read_reg(RS5C313_ADDR_YEAR10) << 4);
+        tm->tm_year = BCD2BIN(data);
+
+        if (tm->tm_year < 70)
+                tm->tm_year += 100;
+
+        data = rs5c313_read_reg(RS5C313_ADDR_WEEK);
+        tm->tm_wday = BCD2BIN(data);
+
+        RS5C313_CEDISABLE;
+        ndelay(700);            /* CE:L */
+
+        return 0;
+}
+
+static int rs5c313_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        int data;
+
+        /* busy check. */
+        while (1) {
+                RS5C313_CEENABLE;       /* CE:H */
+
+                /* Initiatlize control reg. 24 hour */
+                rs5c313_write_cntreg(0x04);
+
+                if (!(rs5c313_read_cntreg() & RS5C313_CNTREG_ADJ_BSY))
+                        break;
+                RS5C313_MISCOP;
+                RS5C313_CEDISABLE;
+                ndelay(700);    /* CE:L */
+        }
+
+        data = BIN2BCD(tm->tm_sec);
+        rs5c313_write_reg(RS5C313_ADDR_SEC, data);
+        rs5c313_write_reg(RS5C313_ADDR_SEC10, (data >> 4));
+
+        data = BIN2BCD(tm->tm_min);
+        rs5c313_write_reg(RS5C313_ADDR_MIN, data );
+        rs5c313_write_reg(RS5C313_ADDR_MIN10, (data >> 4));
+
+        data = BIN2BCD(tm->tm_hour);
+        rs5c313_write_reg(RS5C313_ADDR_HOUR, data);
+        rs5c313_write_reg(RS5C313_ADDR_HOUR10, (data >> 4));
+
+        data = BIN2BCD(tm->tm_mday);
+        rs5c313_write_reg(RS5C313_ADDR_DAY, data);
+        rs5c313_write_reg(RS5C313_ADDR_DAY10, (data>> 4));
+
+        data = BIN2BCD(tm->tm_mon + 1);
+        rs5c313_write_reg(RS5C313_ADDR_MON, data);
+        rs5c313_write_reg(RS5C313_ADDR_MON10, (data >> 4));
+
+        data = BIN2BCD(tm->tm_year % 100);
+        rs5c313_write_reg(RS5C313_ADDR_YEAR, data);
+        rs5c313_write_reg(RS5C313_ADDR_YEAR10, (data >> 4));
+
+        data = BIN2BCD(tm->tm_wday);
+        rs5c313_write_reg(RS5C313_ADDR_WEEK, data);
+
+        RS5C313_CEDISABLE;      /* CE:H */
+        ndelay(700);
+
+        return 0;
+}
+
+static void rs5c313_check_xstp_bit(void)
+{
+        struct rtc_time tm;
+
+        RS5C313_CEENABLE;       /* CE:H */
+        if (rs5c313_read_cntreg() & RS5C313_CNTREG_WTEN_XSTP) {
+                /* INT interval reg. OFF */
+                rs5c313_write_intintvreg(0x00);
+                /* Initialize control reg. 24 hour & adjust */
+                rs5c313_write_cntreg(0x07);
+
+                /* busy check. */
+                while (rs5c313_read_cntreg() & RS5C313_CNTREG_ADJ_BSY)
+                        RS5C313_MISCOP;
+
+                memset(&tm, 0, sizeof(struct rtc_time));
+                tm.tm_mday      = 1;
+                tm.tm_mon       = 1;
+
+                rs5c313_rtc_set_time(NULL, &tm);
+                printk(KERN_ERR "RICHO RS5C313: invalid value, resetting to "
+                                "1 Jan 2000\n");
+        }
+        RS5C313_CEDISABLE;
+        ndelay(700);            /* CE:L */
+}
+
+static const struct rtc_class_ops rs5c313_rtc_ops = {
+        .read_time = rs5c313_rtc_read_time,
+        .set_time = rs5c313_rtc_set_time,
+};
+
+static int rs5c313_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = rtc_device_register("rs5c313", &pdev->dev,
+                                &rs5c313_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+
+        platform_set_drvdata(pdev, rtc);
+
+        return err;
+}
+
+static int __devexit rs5c313_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata( pdev );
+
+        rtc_device_unregister(rtc);
+
+        return 0;
+}
+
+static struct platform_driver rs5c313_rtc_platform_driver = {
+        .driver         = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+        .probe  = rs5c313_rtc_probe,
+        .remove = __devexit_p( rs5c313_rtc_remove ),
+};
+
+static int __init rs5c313_rtc_init(void)
+{
+        int err;
+
+        err = platform_driver_register(&rs5c313_rtc_platform_driver);
+        if (err)
+                return err;
+
+        rs5c313_init_port();
+        rs5c313_check_xstp_bit();
+
+        return 0;
+}
+
+static void __exit rs5c313_rtc_exit(void)
+{
+        platform_driver_unregister( &rs5c313_rtc_platform_driver );
+}
+
+module_init(rs5c313_rtc_init);
+module_exit(rs5c313_rtc_exit);
+
+MODULE_VERSION(DRV_VERSION);
+MODULE_AUTHOR("kogiidena , Nobuhiro Iwamatsu <iwamatsu@nigauri.org>");
+MODULE_DESCRIPTION("Ricoh RS5C313 RTC device driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index 9a79a24a7487..54b613053468 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -50,7 +50,7 @@ static irqreturn_t s3c_rtc_alarmirq(int irq, void *id)
 {
         struct rtc_device *rdev = id;
 
-        rtc_update_irq(&rdev->class_dev, 1, RTC_AF | RTC_IRQF);
+        rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF);
         return IRQ_HANDLED;
 }
 
@@ -58,7 +58,7 @@ static irqreturn_t s3c_rtc_tickirq(int irq, void *id)
 {
         struct rtc_device *rdev = id;
 
-        rtc_update_irq(&rdev->class_dev, tick_count++, RTC_PF | RTC_IRQF);
+        rtc_update_irq(rdev, tick_count++, RTC_PF | RTC_IRQF);
         return IRQ_HANDLED;
 }
 
@@ -548,37 +548,15 @@ static int ticnt_save;
 
 static int s3c_rtc_suspend(struct platform_device *pdev, pm_message_t state)
 {
-        struct rtc_time tm;
-        struct timespec time;
-
-        time.tv_nsec = 0;
-
         /* save TICNT for anyone using periodic interrupts */
-
         ticnt_save = readb(s3c_rtc_base + S3C2410_TICNT);
-
-        /* calculate time delta for suspend */
-
-        s3c_rtc_gettime(&pdev->dev, &tm);
-        rtc_tm_to_time(&tm, &time.tv_sec);
-        save_time_delta(&s3c_rtc_delta, &time);
         s3c_rtc_enable(pdev, 0);
-
         return 0;
 }
 
 static int s3c_rtc_resume(struct platform_device *pdev)
 {
-        struct rtc_time tm;
-        struct timespec time;
-
-        time.tv_nsec = 0;
-
         s3c_rtc_enable(pdev, 1);
-        s3c_rtc_gettime(&pdev->dev, &tm);
-        rtc_tm_to_time(&tm, &time.tv_sec);
-        restore_time_delta(&s3c_rtc_delta, &time);
-
         writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT);
         return 0;
 }
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index 677bae820dc3..0918b787c4dd 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -93,7 +93,7 @@ static irqreturn_t sa1100_rtc_interrupt(int irq, void *dev_id)
         if (rtsr & RTSR_HZ)
                 events |= RTC_UF | RTC_IRQF;
 
-        rtc_update_irq(&rtc->class_dev, 1, events);
+        rtc_update_irq(rtc, 1, events);
 
         if (rtsr & RTSR_AL && rtc_periodic_alarm(&rtc_alarm))
                 rtc_update_alarm(&rtc_alarm);
@@ -119,7 +119,7 @@ static irqreturn_t timer1_interrupt(int irq, void *dev_id)
          */
         OSSR = OSSR_M1; /* clear match on timer1 */
 
-        rtc_update_irq(&rtc->class_dev, rtc_timer1_count, RTC_PF | RTC_IRQF);
+        rtc_update_irq(rtc, rtc_timer1_count, RTC_PF | RTC_IRQF);
 
         if (rtc_timer1_count == 1)
                 rtc_timer1_count = (rtc_freq * ((1<<30)/(TIMER_FREQ>>2)));
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index 198b9f22fbff..6abf4811958c 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -104,7 +104,7 @@ static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
 
         writeb(tmp, rtc->regbase + RCR1);
 
-        rtc_update_irq(&rtc->rtc_dev->class_dev, 1, events);
+        rtc_update_irq(&rtc->rtc_dev, 1, events);
 
         spin_unlock(&rtc->lock);
 
@@ -139,7 +139,7 @@ static irqreturn_t sh_rtc_alarm(int irq, void *dev_id)
 
                 rtc->rearm_aie = 1;
 
-                rtc_update_irq(&rtc->rtc_dev->class_dev, 1, events);
+                rtc_update_irq(&rtc->rtc_dev, 1, events);
         }
 
         spin_unlock(&rtc->lock);
@@ -153,7 +153,7 @@ static irqreturn_t sh_rtc_periodic(int irq, void *dev_id)
 
         spin_lock(&rtc->lock);
 
-        rtc_update_irq(&rtc->rtc_dev->class_dev, 1, RTC_PF | RTC_IRQF);
+        rtc_update_irq(&rtc->rtc_dev, 1, RTC_PF | RTC_IRQF);
 
         spin_unlock(&rtc->lock);
 
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
index 899ab8c514fa..69df94b44841 100644
--- a/drivers/rtc/rtc-sysfs.c
+++ b/drivers/rtc/rtc-sysfs.c
@@ -12,20 +12,26 @@
 #include <linux/module.h>
 #include <linux/rtc.h>
 
+#include "rtc-core.h"
+
+
 /* device attributes */
 
-static ssize_t rtc_sysfs_show_name(struct class_device *dev, char *buf)
+static ssize_t
+rtc_sysfs_show_name(struct device *dev, struct device_attribute *attr,
+                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)
+static ssize_t
+rtc_sysfs_show_date(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
         ssize_t retval;
         struct rtc_time tm;
 
-        retval = rtc_read_time(dev, &tm);
+        retval = rtc_read_time(to_rtc_device(dev), &tm);
         if (retval == 0) {
                 retval = sprintf(buf, "%04d-%02d-%02d\n",
                         tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
@@ -33,14 +39,15 @@ static ssize_t rtc_sysfs_show_date(struct class_device *dev, char *buf)
 
         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)
+static ssize_t
+rtc_sysfs_show_time(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
         ssize_t retval;
         struct rtc_time tm;
 
-        retval = rtc_read_time(dev, &tm);
+        retval = rtc_read_time(to_rtc_device(dev), &tm);
         if (retval == 0) {
                 retval = sprintf(buf, "%02d:%02d:%02d\n",
                         tm.tm_hour, tm.tm_min, tm.tm_sec);
@@ -48,14 +55,15 @@ static ssize_t rtc_sysfs_show_time(struct class_device *dev, char *buf)
 
         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)
+static ssize_t
+rtc_sysfs_show_since_epoch(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
         ssize_t retval;
         struct rtc_time tm;
 
-        retval = rtc_read_time(dev, &tm);
+        retval = rtc_read_time(to_rtc_device(dev), &tm);
         if (retval == 0) {
                 unsigned long time;
                 rtc_tm_to_time(&tm, &time);
@@ -64,23 +72,18 @@ static ssize_t rtc_sysfs_show_since_epoch(struct class_device *dev, char *buf)
 
         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 struct device_attribute rtc_attrs[] = {
+        __ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL),
+        __ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL),
+        __ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL),
+        __ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL),
+        { },
 };
 
-
 static ssize_t
-rtc_sysfs_show_wakealarm(struct class_device *dev, char *buf)
+rtc_sysfs_show_wakealarm(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
         ssize_t retval;
         unsigned long alarm;
@@ -94,7 +97,7 @@ rtc_sysfs_show_wakealarm(struct class_device *dev, char *buf)
          * REVISIT maybe we should require RTC implementations to
          * disable the RTC alarm after it triggers, for uniformity.
          */
-        retval = rtc_read_alarm(dev, &alm);
+        retval = rtc_read_alarm(to_rtc_device(dev), &alm);
         if (retval == 0 && alm.enabled) {
                 rtc_tm_to_time(&alm.time, &alarm);
                 retval = sprintf(buf, "%lu\n", alarm);
@@ -104,16 +107,18 @@ rtc_sysfs_show_wakealarm(struct class_device *dev, char *buf)
 }
 
 static ssize_t
-rtc_sysfs_set_wakealarm(struct class_device *dev, const char *buf, size_t n)
+rtc_sysfs_set_wakealarm(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t n)
 {
         ssize_t retval;
         unsigned long now, alarm;
         struct rtc_wkalrm alm;
+        struct rtc_device *rtc = to_rtc_device(dev);
 
         /* Only request alarms that trigger in the future.  Disable them
          * by writing another time, e.g. 0 meaning Jan 1 1970 UTC.
          */
-        retval = rtc_read_time(dev, &alm.time);
+        retval = rtc_read_time(rtc, &alm.time);
         if (retval < 0)
                 return retval;
         rtc_tm_to_time(&alm.time, &now);
@@ -124,7 +129,7 @@ rtc_sysfs_set_wakealarm(struct class_device *dev, const char *buf, size_t n)
                  * entirely prevent that here, without even the minimal
                  * locking from the /dev/rtcN api.
                  */
-                retval = rtc_read_alarm(dev, &alm);
+                retval = rtc_read_alarm(rtc, &alm);
                 if (retval < 0)
                         return retval;
                 if (alm.enabled)
@@ -141,10 +146,10 @@ rtc_sysfs_set_wakealarm(struct class_device *dev, const char *buf, size_t n)
         }
         rtc_time_to_tm(alarm, &alm.time);
 
-        retval = rtc_set_alarm(dev, &alm);
+        retval = rtc_set_alarm(rtc, &alm);
         return (retval < 0) ? retval : n;
 }
-static const CLASS_DEVICE_ATTR(wakealarm, S_IRUGO | S_IWUSR,
+static DEVICE_ATTR(wakealarm, S_IRUGO | S_IWUSR,
                 rtc_sysfs_show_wakealarm, rtc_sysfs_set_wakealarm);
 
 
@@ -153,71 +158,37 @@ static const CLASS_DEVICE_ATTR(wakealarm, S_IRUGO | S_IWUSR,
  * suspend-to-disk.  So: no attribute unless that side effect is possible.
  * (Userspace may disable that mechanism later.)
  */
-static inline int rtc_does_wakealarm(struct class_device *class_dev)
+static inline int rtc_does_wakealarm(struct rtc_device *rtc)
 {
-        struct rtc_device *rtc;
-
-        if (!device_can_wakeup(class_dev->dev))
+        if (!device_can_wakeup(rtc->dev.parent))
                 return 0;
-        rtc = to_rtc_device(class_dev);
         return rtc->ops->set_alarm != NULL;
 }
 
 
-static int rtc_sysfs_add_device(struct class_device *class_dev,
-                                        struct class_interface *class_intf)
+void rtc_sysfs_add_device(struct rtc_device *rtc)
 {
         int err;
 
-        dev_dbg(class_dev->dev, "rtc intf: sysfs\n");
+        /* not all RTCs support both alarms and wakeup */
+        if (!rtc_does_wakealarm(rtc))
+                return;
 
-        err = sysfs_create_group(&class_dev->kobj, &rtc_attr_group);
+        err = device_create_file(&rtc->dev, &dev_attr_wakealarm);
         if (err)
-                dev_err(class_dev->dev, "failed to create %s\n",
-                                "sysfs attributes");
-        else if (rtc_does_wakealarm(class_dev)) {
-                /* not all RTCs support both alarms and wakeup */
-                err = class_device_create_file(class_dev,
-                                        &class_device_attr_wakealarm);
-                if (err) {
-                        dev_err(class_dev->dev, "failed to create %s\n",
-                                        "alarm attribute");
-                        sysfs_remove_group(&class_dev->kobj, &rtc_attr_group);
-                }
-        }
-
-        return err;
+                dev_err(rtc->dev.parent, "failed to create "
+                                "alarm attribute, %d",
+                                err);
 }
 
-static void rtc_sysfs_remove_device(struct class_device *class_dev,
-                                struct class_interface *class_intf)
+void rtc_sysfs_del_device(struct rtc_device *rtc)
 {
-        if (rtc_does_wakealarm(class_dev))
-                class_device_remove_file(class_dev,
-                                &class_device_attr_wakealarm);
-        sysfs_remove_group(&class_dev->kobj, &rtc_attr_group);
+        /* REVISIT did we add it successfully? */
+        if (rtc_does_wakealarm(rtc))
+                device_remove_file(&rtc->dev, &dev_attr_wakealarm);
 }
 
-/* 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)
+void __init rtc_sysfs_init(struct class *rtc_class)
 {
-        return rtc_interface_register(&rtc_sysfs_interface);
+        rtc_class->dev_attrs = rtc_attrs;
 }
-
-static void __exit rtc_sysfs_exit(void)
-{
-        class_interface_unregister(&rtc_sysfs_interface);
-}
-
-subsys_initcall(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
index f50a1b8e1607..254c9fce27da 100644
--- a/drivers/rtc/rtc-test.c
+++ b/drivers/rtc/rtc-test.c
@@ -101,11 +101,11 @@ static ssize_t test_irq_store(struct device *dev,
         retval = count;
         local_irq_disable();
         if (strncmp(buf, "tick", 4) == 0)
-                rtc_update_irq(&rtc->class_dev, 1, RTC_PF | RTC_IRQF);
+                rtc_update_irq(rtc, 1, RTC_PF | RTC_IRQF);
         else if (strncmp(buf, "alarm", 5) == 0)
-                rtc_update_irq(&rtc->class_dev, 1, RTC_AF | RTC_IRQF);
+                rtc_update_irq(rtc, 1, RTC_AF | RTC_IRQF);
         else if (strncmp(buf, "update", 6) == 0)
-                rtc_update_irq(&rtc->class_dev, 1, RTC_UF | RTC_IRQF);
+                rtc_update_irq(rtc, 1, RTC_UF | RTC_IRQF);
         else
                 retval = -EINVAL;
         local_irq_enable();
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index e40322b71938..af7596ef29e2 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -97,6 +97,7 @@ static DEFINE_SPINLOCK(rtc_lock);
 static char rtc_name[] = "RTC";
 static unsigned long periodic_frequency;
 static unsigned long periodic_count;
+static unsigned int alarm_enabled;
 
 struct resource rtc_resource[2] = {
         {       .name   = rtc_name,
@@ -188,6 +189,7 @@ static int vr41xx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
         low = rtc1_read(ECMPLREG);
         mid = rtc1_read(ECMPMREG);
         high = rtc1_read(ECMPHREG);
+        wkalrm->enabled = alarm_enabled;
 
         spin_unlock_irq(&rtc_lock);
 
@@ -206,10 +208,18 @@ static int vr41xx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
 
         spin_lock_irq(&rtc_lock);
 
+        if (alarm_enabled)
+                disable_irq(ELAPSEDTIME_IRQ);
+
         rtc1_write(ECMPLREG, (uint16_t)(alarm_sec << 15));
         rtc1_write(ECMPMREG, (uint16_t)(alarm_sec >> 1));
         rtc1_write(ECMPHREG, (uint16_t)(alarm_sec >> 17));
 
+        if (wkalrm->enabled)
+                enable_irq(ELAPSEDTIME_IRQ);
+
+        alarm_enabled = wkalrm->enabled;
+
         spin_unlock_irq(&rtc_lock);
 
         return 0;
@@ -221,10 +231,24 @@ static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long
 
         switch (cmd) {
         case RTC_AIE_ON:
-                enable_irq(ELAPSEDTIME_IRQ);
+                spin_lock_irq(&rtc_lock);
+
+                if (!alarm_enabled) {
+                        enable_irq(ELAPSEDTIME_IRQ);
+                        alarm_enabled = 1;
+                }
+
+                spin_unlock_irq(&rtc_lock);
                 break;
         case RTC_AIE_OFF:
-                disable_irq(ELAPSEDTIME_IRQ);
+                spin_lock_irq(&rtc_lock);
+
+                if (alarm_enabled) {
+                        disable_irq(ELAPSEDTIME_IRQ);
+                        alarm_enabled = 0;
+                }
+
+                spin_unlock_irq(&rtc_lock);
                 break;
         case RTC_PIE_ON:
                 enable_irq(RTCLONG1_IRQ);
@@ -275,7 +299,7 @@ static irqreturn_t elapsedtime_interrupt(int irq, void *dev_id)
 
         rtc2_write(RTCINTREG, ELAPSEDTIME_INT);
 
-        rtc_update_irq(&rtc->class_dev, 1, RTC_AF);
+        rtc_update_irq(rtc, 1, RTC_AF);
 
         return IRQ_HANDLED;
 }
@@ -291,7 +315,7 @@ static irqreturn_t rtclong1_interrupt(int irq, void *dev_id)
         rtc1_write(RTCL1LREG, count);
         rtc1_write(RTCL1HREG, count >> 16);
 
-        rtc_update_irq(&rtc->class_dev, 1, RTC_PF);
+        rtc_update_irq(rtc, 1, RTC_PF);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/sbus/char/bpp.c b/drivers/sbus/char/bpp.c
index a39ee80c9715..74b999d77bbf 100644
--- a/drivers/sbus/char/bpp.c
+++ b/drivers/sbus/char/bpp.c
@@ -15,7 +15,6 @@
 #include <linux/fs.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
-#include <linux/smp_lock.h>
 #include <linux/spinlock.h>
 #include <linux/timer.h>
 #include <linux/ioport.h>
diff --git a/drivers/sbus/char/rtc.c b/drivers/sbus/char/rtc.c
index 94d185829119..18d18f1a114e 100644
--- a/drivers/sbus/char/rtc.c
+++ b/drivers/sbus/char/rtc.c
@@ -19,7 +19,6 @@
 #include <linux/fcntl.h>
 #include <linux/poll.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <asm/io.h>
 #include <asm/mostek.h>
 #include <asm/system.h>
diff --git a/drivers/sbus/char/vfc_dev.c b/drivers/sbus/char/vfc_dev.c
index c3135e2fbd5a..6afc7e5df0d4 100644
--- a/drivers/sbus/char/vfc_dev.c
+++ b/drivers/sbus/char/vfc_dev.c
@@ -20,7 +20,6 @@
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/delay.h>
 #include <linux/spinlock.h>
 #include <linux/mm.h>
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.h b/drivers/scsi/aic7xxx/aic79xx_osm.h
index 9218f29314fa..ad9761b237dc 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.h
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.h
@@ -47,7 +47,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/pci.h>
-#include <linux/smp_lock.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/slab.h>
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.h b/drivers/scsi/aic7xxx/aic7xxx_osm.h
index 85ae5d836fa4..8fee7edc6eb3 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.h
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.h
@@ -64,7 +64,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/pci.h>
-#include <linux/smp_lock.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/slab.h>
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index f7b9dbd64a96..fb6433a56989 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -55,7 +55,6 @@ MODULE_DESCRIPTION("Adaptec I2O RAID Driver");
 #include <linux/sched.h>
 #include <linux/reboot.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/dma-mapping.h>
 
 #include <linux/timer.h>
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 3e2930b7ee23..06229f225ee9 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -36,7 +36,6 @@
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/proc_fs.h>
-#include <linux/smp_lock.h>
 #include <linux/vmalloc.h>
 #include <linux/moduleparam.h>
 
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 570977cf9efb..0c691a60a756 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -41,7 +41,6 @@ static int sg_version_num = 30534;	/* 2 digits for each component */
 #include <linux/fcntl.h>
 #include <linux/init.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 #include <linux/moduleparam.h>
 #include <linux/cdev.h>
 #include <linux/seq_file.h>
diff --git a/drivers/scsi/sni_53c710.c b/drivers/scsi/sni_53c710.c
index 6bc505115841..a7dfb65fb842 100644
--- a/drivers/scsi/sni_53c710.c
+++ b/drivers/scsi/sni_53c710.c
@@ -98,7 +98,7 @@ static int __init snirm710_probe(struct platform_device *dev)
         host->this_id = 7;
         host->base = base;
         host->irq = platform_get_irq(dev, 0);
-        if(request_irq(host->irq, NCR_700_intr, SA_SHIRQ, "snirm710", host)) {
+        if(request_irq(host->irq, NCR_700_intr, IRQF_SHARED, "snirm710", host)) {
                 printk(KERN_ERR "snirm710: request_irq failed!\n");
                 goto out_put_host;
         }
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index c9832d963f1e..48e259a0167d 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -994,7 +994,6 @@ static void autoconfig(struct uart_8250_port *up, unsigned int probeflags)
          * be frobbing the chips IRQ enable register to see if it exists.
          */
         spin_lock_irqsave(&up->port.lock, flags);
-//      save_flags(flags); cli();
 
         up->capabilities = 0;
         up->bugs = 0;
@@ -1151,7 +1150,6 @@ static void autoconfig(struct uart_8250_port *up, unsigned int probeflags)
 
  out:
         spin_unlock_irqrestore(&up->port.lock, flags);
-//      restore_flags(flags);
         DEBUG_AUTOCONF("type=%s\n", uart_config[up->port.type].name);
 }
 
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 924e9bd757f0..e8efe938c4e7 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -73,17 +73,21 @@ config SERIAL_8250_PCI
         depends on SERIAL_8250 && PCI
         default SERIAL_8250
         help
-          This builds standard PCI serial support. You may be able to
-          disable this feature if you only need legacy serial support.
-          Saves about 9K.
+          Say Y here if you have PCI serial ports.
+
+          To compile this driver as a module, choose M here: the module
+          will be called 8250_pci.
 
 config SERIAL_8250_PNP
         tristate "8250/16550 PNP device support" if EMBEDDED
         depends on SERIAL_8250 && PNP
         default SERIAL_8250
         help
-          This builds standard PNP serial support. You may be able to
-          disable this feature if you only need legacy serial support.
+          Say Y here if you have serial ports described by PNPBIOS or ACPI.
+          These are typically ports built into the system board.
+
+          To compile this driver as a module, choose M here: the module
+          will be called 8250_pnp.
 
 config SERIAL_8250_HP300
         tristate
diff --git a/drivers/serial/cpm_uart/cpm_uart_core.c b/drivers/serial/cpm_uart/cpm_uart_core.c
index 7a3b97fdf8d1..f23972bc00c0 100644
--- a/drivers/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/serial/cpm_uart/cpm_uart_core.c
@@ -934,7 +934,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                         .irq            = SMC1_IRQ,
                         .ops            = &cpm_uart_pops,
                         .iotype         = UPIO_MEM,
-                        .lock           = SPIN_LOCK_UNLOCKED,
+                        .lock           = __SPIN_LOCK_UNLOCKED(cpm_uart_ports[UART_SMC1].port.lock),
                 },
                 .flags = FLAG_SMC,
                 .tx_nrfifos = TX_NUM_FIFO,
@@ -948,7 +948,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                         .irq            = SMC2_IRQ,
                         .ops            = &cpm_uart_pops,
                         .iotype         = UPIO_MEM,
-                        .lock           = SPIN_LOCK_UNLOCKED,
+                        .lock           = __SPIN_LOCK_UNLOCKED(cpm_uart_ports[UART_SMC2].port.lock),
                 },
                 .flags = FLAG_SMC,
                 .tx_nrfifos = TX_NUM_FIFO,
@@ -965,7 +965,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                         .irq            = SCC1_IRQ,
                         .ops            = &cpm_uart_pops,
                         .iotype         = UPIO_MEM,
-                        .lock           = SPIN_LOCK_UNLOCKED,
+                        .lock           = __SPIN_LOCK_UNLOCKED(cpm_uart_ports[UART_SCC1].port.lock),
                 },
                 .tx_nrfifos = TX_NUM_FIFO,
                 .tx_fifosize = TX_BUF_SIZE,
@@ -979,7 +979,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                         .irq            = SCC2_IRQ,
                         .ops            = &cpm_uart_pops,
                         .iotype         = UPIO_MEM,
-                        .lock           = SPIN_LOCK_UNLOCKED,
+                        .lock           = __SPIN_LOCK_UNLOCKED(cpm_uart_ports[UART_SCC2].port.lock),
                 },
                 .tx_nrfifos = TX_NUM_FIFO,
                 .tx_fifosize = TX_BUF_SIZE,
@@ -993,7 +993,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                         .irq            = SCC3_IRQ,
                         .ops            = &cpm_uart_pops,
                         .iotype         = UPIO_MEM,
-                        .lock           = SPIN_LOCK_UNLOCKED,
+                        .lock           = __SPIN_LOCK_UNLOCKED(cpm_uart_ports[UART_SCC3].port.lock),
                 },
                 .tx_nrfifos = TX_NUM_FIFO,
                 .tx_fifosize = TX_BUF_SIZE,
@@ -1007,7 +1007,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                         .irq            = SCC4_IRQ,
                         .ops            = &cpm_uart_pops,
                         .iotype         = UPIO_MEM,
-                        .lock           = SPIN_LOCK_UNLOCKED,
+                        .lock           = __SPIN_LOCK_UNLOCKED(cpm_uart_ports[UART_SCC4].port.lock),
                 },
                 .tx_nrfifos = TX_NUM_FIFO,
                 .tx_fifosize = TX_BUF_SIZE,
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index 246c5572667b..6202995e8211 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -47,7 +47,6 @@
 #include <linux/pci.h>
 #include <linux/vmalloc.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/spinlock.h>
 #include <linux/kobject.h>
 #include <linux/firmware.h>
diff --git a/drivers/serial/jsm/jsm_neo.c b/drivers/serial/jsm/jsm_neo.c
index 8be8da37f629..b2d6f5b1a7c2 100644
--- a/drivers/serial/jsm/jsm_neo.c
+++ b/drivers/serial/jsm/jsm_neo.c
@@ -581,8 +581,13 @@ static void neo_parse_modem(struct jsm_channel *ch, u8 signals)
                 return;
 
         /* Scrub off lower bits. They signify delta's, which I don't care about */
-        msignals &= 0xf0;
+        /* Keep DDCD and DDSR though */
+        msignals &= 0xf8;
 
+        if (msignals & UART_MSR_DDCD)
+                uart_handle_dcd_change(&ch->uart_port, msignals & UART_MSR_DCD);
+        if (msignals & UART_MSR_DDSR)
+                uart_handle_cts_change(&ch->uart_port, msignals & UART_MSR_CTS);
         if (msignals & UART_MSR_DCD)
                 ch->ch_mistat |= UART_MSR_DCD;
         else
diff --git a/drivers/serial/jsm/jsm_tty.c b/drivers/serial/jsm/jsm_tty.c
index be22bbdbc8e5..281f23a371b2 100644
--- a/drivers/serial/jsm/jsm_tty.c
+++ b/drivers/serial/jsm/jsm_tty.c
@@ -448,6 +448,7 @@ int jsm_uart_port_init(struct jsm_board *brd)
                         continue;
 
                 brd->channels[i]->uart_port.irq = brd->irq;
+                brd->channels[i]->uart_port.uartclk = 14745600;
                 brd->channels[i]->uart_port.type = PORT_JSM;
                 brd->channels[i]->uart_port.iotype = UPIO_MEM;
                 brd->channels[i]->uart_port.membase = brd->re_map_membase;
diff --git a/drivers/serial/s3c2410.c b/drivers/serial/s3c2410.c
index 3ba9208ebd0c..10bc0209cd66 100644
--- a/drivers/serial/s3c2410.c
+++ b/drivers/serial/s3c2410.c
@@ -957,7 +957,7 @@ static struct uart_driver s3c24xx_uart_drv = {
 static struct s3c24xx_uart_port s3c24xx_serial_ports[NR_PORTS] = {
         [0] = {
                 .port = {
-                        .lock           = SPIN_LOCK_UNLOCKED,
+                        .lock           = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[0].port.lock),
                         .iotype         = UPIO_MEM,
                         .irq            = IRQ_S3CUART_RX0,
                         .uartclk        = 0,
@@ -969,7 +969,7 @@ static struct s3c24xx_uart_port s3c24xx_serial_ports[NR_PORTS] = {
         },
         [1] = {
                 .port = {
-                        .lock           = SPIN_LOCK_UNLOCKED,
+                        .lock           = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[1].port.lock),
                         .iotype         = UPIO_MEM,
                         .irq            = IRQ_S3CUART_RX1,
                         .uartclk        = 0,
@@ -983,7 +983,7 @@ static struct s3c24xx_uart_port s3c24xx_serial_ports[NR_PORTS] = {
 
         [2] = {
                 .port = {
-                        .lock           = SPIN_LOCK_UNLOCKED,
+                        .lock           = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[2].port.lock),
                         .iotype         = UPIO_MEM,
                         .irq            = IRQ_S3CUART_RX2,
                         .uartclk        = 0,
diff --git a/drivers/serial/serial_txx9.c b/drivers/serial/serial_txx9.c
index 509ace7e6881..1deb5764326d 100644
--- a/drivers/serial/serial_txx9.c
+++ b/drivers/serial/serial_txx9.c
@@ -15,31 +15,6 @@
  * published by the Free Software Foundation.
  *
  *  Serial driver for TX3927/TX4927/TX4925/TX4938 internal SIO controller
- *
- *  Revision History:
- *      0.30    Initial revision. (Renamed from serial_txx927.c)
- *      0.31    Use save_flags instead of local_irq_save.
- *      0.32    Support SCLK.
- *      0.33    Switch TXX9_TTY_NAME by CONFIG_SERIAL_TXX9_STDSERIAL.
- *              Support TIOCSERGETLSR.
- *      0.34    Support slow baudrate.
- *      0.40    Merge codes from mainstream kernel (2.4.22).
- *      0.41    Fix console checking in rs_shutdown_port().
- *              Disable flow-control in serial_console_write().
- *      0.42    Fix minor compiler warning.
- *      1.00    Kernel 2.6.  Converted to new serial core (based on 8250.c).
- *      1.01    Set fifosize to make tx_empry called properly.
- *              Use standard uart_get_divisor.
- *      1.02    Cleanup. (import 8250.c changes)
- *      1.03    Fix low-latency mode. (import 8250.c changes)
- *      1.04    Remove usage of deprecated functions, cleanup.
- *      1.05    More strict check in verify_port.  Cleanup.
- *      1.06    Do not insert a char caused previous overrun.
- *              Fix some spin_locks.
- *              Do not call uart_add_one_port for absent ports.
- *      1.07    Use CONFIG_SERIAL_TXX9_NR_UARTS.  Cleanup.
- *      1.08    Use platform_device.
- *              Fix and cleanup suspend/resume/initialization codes.
  */
 
 #if defined(CONFIG_SERIAL_TXX9_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
@@ -62,7 +37,7 @@
 
 #include <asm/io.h>
 
-static char *serial_version = "1.08";
+static char *serial_version = "1.09";
 static char *serial_name = "TX39/49 Serial driver";
 
 #define PASS_LIMIT      256
@@ -70,13 +45,14 @@ static char *serial_name = "TX39/49 Serial driver";
 #if !defined(CONFIG_SERIAL_TXX9_STDSERIAL)
 /* "ttyS" is used for standard serial driver */
 #define TXX9_TTY_NAME "ttyTX"
-#define TXX9_TTY_MINOR_START    (64 + 64)       /* ttyTX0(128), ttyTX1(129) */
+#define TXX9_TTY_MINOR_START    196
+#define TXX9_TTY_MAJOR  204
 #else
 /* acts like standard serial driver */
 #define TXX9_TTY_NAME "ttyS"
 #define TXX9_TTY_MINOR_START    64
-#endif
 #define TXX9_TTY_MAJOR  TTY_MAJOR
+#endif
 
 /* flag aliases */
 #define UPF_TXX9_HAVE_CTS_LINE  UPF_BUGGY_UART
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index 4a012d9acbff..07c587ec71be 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -64,6 +64,17 @@ config SPI_BFIN
         help
           This is the SPI controller master driver for Blackfin 5xx processor.
 
+config SPI_AU1550
+        tristate "Au1550/Au12x0 SPI Controller"
+        depends on SPI_MASTER && (SOC_AU1550 || SOC_AU1200) && EXPERIMENTAL
+        select SPI_BITBANG
+        help
+          If you say yes to this option, support will be included for the
+          Au1550 SPI controller (may also work with Au1200,Au1210,Au1250).
+
+          This driver can also be built as a module.  If so, the module
+          will be called au1550_spi.
+
 config SPI_BITBANG
         tristate "Bitbanging SPI master"
         depends on SPI_MASTER && EXPERIMENTAL
@@ -159,6 +170,15 @@ config SPI_AT25
           This driver can also be built as a module.  If so, the module
           will be called at25.
 
+config SPI_SPIDEV
+        tristate "User mode SPI device driver support"
+        depends on SPI_MASTER && EXPERIMENTAL
+        help
+          This supports user mode SPI protocol drivers.
+
+          Note that this application programming interface is EXPERIMENTAL
+          and hence SUBJECT TO CHANGE WITHOUT NOTICE while it stabilizes.
+
 #
 # Add new SPI protocol masters in alphabetical order above this line
 #
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index a95ade857a2f..624b6363f490 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_SPI_MASTER)		+= spi.o
 obj-$(CONFIG_SPI_ATMEL)                 += atmel_spi.o
 obj-$(CONFIG_SPI_BFIN)                  += spi_bfin5xx.o
 obj-$(CONFIG_SPI_BITBANG)               += spi_bitbang.o
+obj-$(CONFIG_SPI_AU1550)                += au1550_spi.o
 obj-$(CONFIG_SPI_BUTTERFLY)             += spi_butterfly.o
 obj-$(CONFIG_SPI_IMX)                   += spi_imx.o
 obj-$(CONFIG_SPI_PXA2XX)                += pxa2xx_spi.o
@@ -25,6 +26,7 @@ obj-$(CONFIG_SPI_S3C24XX)		+= spi_s3c24xx.o
 
 # SPI protocol drivers (device/link on bus)
 obj-$(CONFIG_SPI_AT25)          += at25.o
+obj-$(CONFIG_SPI_SPIDEV)        += spidev.o
 #       ... add above this line ...
 
 # SPI slave controller drivers (upstream link)
diff --git a/drivers/spi/au1550_spi.c b/drivers/spi/au1550_spi.c
new file mode 100644
index 000000000000..ae2b1af0dba4
--- /dev/null
+++ b/drivers/spi/au1550_spi.c
@@ -0,0 +1,974 @@
+/*
+ * au1550_spi.c - au1550 psc spi controller driver
+ * may work also with au1200, au1210, au1250
+ * will not work on au1000, au1100 and au1500 (no full spi controller there)
+ *
+ * Copyright (c) 2006 ATRON electronic GmbH
+ * Author: Jan Nikitenko <jan.nikitenko@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/errno.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/spi_bitbang.h>
+#include <linux/dma-mapping.h>
+#include <linux/completion.h>
+#include <asm/mach-au1x00/au1000.h>
+#include <asm/mach-au1x00/au1xxx_psc.h>
+#include <asm/mach-au1x00/au1xxx_dbdma.h>
+
+#include <asm/mach-au1x00/au1550_spi.h>
+
+static unsigned usedma = 1;
+module_param(usedma, uint, 0644);
+
+/*
+#define AU1550_SPI_DEBUG_LOOPBACK
+*/
+
+
+#define AU1550_SPI_DBDMA_DESCRIPTORS 1
+#define AU1550_SPI_DMA_RXTMP_MINSIZE 2048U
+
+struct au1550_spi {
+        struct spi_bitbang bitbang;
+
+        volatile psc_spi_t __iomem *regs;
+        int irq;
+        unsigned freq_max;
+        unsigned freq_min;
+
+        unsigned len;
+        unsigned tx_count;
+        unsigned rx_count;
+        const u8 *tx;
+        u8 *rx;
+
+        void (*rx_word)(struct au1550_spi *hw);
+        void (*tx_word)(struct au1550_spi *hw);
+        int (*txrx_bufs)(struct spi_device *spi, struct spi_transfer *t);
+        irqreturn_t (*irq_callback)(struct au1550_spi *hw);
+
+        struct completion master_done;
+
+        unsigned usedma;
+        u32 dma_tx_id;
+        u32 dma_rx_id;
+        u32 dma_tx_ch;
+        u32 dma_rx_ch;
+
+        u8 *dma_rx_tmpbuf;
+        unsigned dma_rx_tmpbuf_size;
+        u32 dma_rx_tmpbuf_addr;
+
+        struct spi_master *master;
+        struct device *dev;
+        struct au1550_spi_info *pdata;
+};
+
+
+/* we use an 8-bit memory device for dma transfers to/from spi fifo */
+static dbdev_tab_t au1550_spi_mem_dbdev =
+{
+        .dev_id                 = DBDMA_MEM_CHAN,
+        .dev_flags              = DEV_FLAGS_ANYUSE|DEV_FLAGS_SYNC,
+        .dev_tsize              = 0,
+        .dev_devwidth           = 8,
+        .dev_physaddr           = 0x00000000,
+        .dev_intlevel           = 0,
+        .dev_intpolarity        = 0
+};
+
+static void au1550_spi_bits_handlers_set(struct au1550_spi *hw, int bpw);
+
+
+/**
+ *  compute BRG and DIV bits to setup spi clock based on main input clock rate
+ *  that was specified in platform data structure
+ *  according to au1550 datasheet:
+ *    psc_tempclk = psc_mainclk / (2 << DIV)
+ *    spiclk = psc_tempclk / (2 * (BRG + 1))
+ *    BRG valid range is 4..63
+ *    DIV valid range is 0..3
+ */
+static u32 au1550_spi_baudcfg(struct au1550_spi *hw, unsigned speed_hz)
+{
+        u32 mainclk_hz = hw->pdata->mainclk_hz;
+        u32 div, brg;
+
+        for (div = 0; div < 4; div++) {
+                brg = mainclk_hz / speed_hz / (4 << div);
+                /* now we have BRG+1 in brg, so count with that */
+                if (brg < (4 + 1)) {
+                        brg = (4 + 1);  /* speed_hz too big */
+                        break;          /* set lowest brg (div is == 0) */
+                }
+                if (brg <= (63 + 1))
+                        break;          /* we have valid brg and div */
+        }
+        if (div == 4) {
+                div = 3;                /* speed_hz too small */
+                brg = (63 + 1);         /* set highest brg and div */
+        }
+        brg--;
+        return PSC_SPICFG_SET_BAUD(brg) | PSC_SPICFG_SET_DIV(div);
+}
+
+static inline void au1550_spi_mask_ack_all(struct au1550_spi *hw)
+{
+        hw->regs->psc_spimsk =
+                  PSC_SPIMSK_MM | PSC_SPIMSK_RR | PSC_SPIMSK_RO
+                | PSC_SPIMSK_RU | PSC_SPIMSK_TR | PSC_SPIMSK_TO
+                | PSC_SPIMSK_TU | PSC_SPIMSK_SD | PSC_SPIMSK_MD;
+        au_sync();
+
+        hw->regs->psc_spievent =
+                  PSC_SPIEVNT_MM | PSC_SPIEVNT_RR | PSC_SPIEVNT_RO
+                | PSC_SPIEVNT_RU | PSC_SPIEVNT_TR | PSC_SPIEVNT_TO
+                | PSC_SPIEVNT_TU | PSC_SPIEVNT_SD | PSC_SPIEVNT_MD;
+        au_sync();
+}
+
+static void au1550_spi_reset_fifos(struct au1550_spi *hw)
+{
+        u32 pcr;
+
+        hw->regs->psc_spipcr = PSC_SPIPCR_RC | PSC_SPIPCR_TC;
+        au_sync();
+        do {
+                pcr = hw->regs->psc_spipcr;
+                au_sync();
+        } while (pcr != 0);
+}
+
+/*
+ * dma transfers are used for the most common spi word size of 8-bits
+ * we cannot easily change already set up dma channels' width, so if we wanted
+ * dma support for more than 8-bit words (up to 24 bits), we would need to
+ * setup dma channels from scratch on each spi transfer, based on bits_per_word
+ * instead we have pre set up 8 bit dma channels supporting spi 4 to 8 bits
+ * transfers, and 9 to 24 bits spi transfers will be done in pio irq based mode
+ * callbacks to handle dma or pio are set up in au1550_spi_bits_handlers_set()
+ */
+static void au1550_spi_chipsel(struct spi_device *spi, int value)
+{
+        struct au1550_spi *hw = spi_master_get_devdata(spi->master);
+        unsigned cspol = spi->mode & SPI_CS_HIGH ? 1 : 0;
+        u32 cfg, stat;
+
+        switch (value) {
+        case BITBANG_CS_INACTIVE:
+                if (hw->pdata->deactivate_cs)
+                        hw->pdata->deactivate_cs(hw->pdata, spi->chip_select,
+                                        cspol);
+                break;
+
+        case BITBANG_CS_ACTIVE:
+                au1550_spi_bits_handlers_set(hw, spi->bits_per_word);
+
+                cfg = hw->regs->psc_spicfg;
+                au_sync();
+                hw->regs->psc_spicfg = cfg & ~PSC_SPICFG_DE_ENABLE;
+                au_sync();
+
+                if (spi->mode & SPI_CPOL)
+                        cfg |= PSC_SPICFG_BI;
+                else
+                        cfg &= ~PSC_SPICFG_BI;
+                if (spi->mode & SPI_CPHA)
+                        cfg &= ~PSC_SPICFG_CDE;
+                else
+                        cfg |= PSC_SPICFG_CDE;
+
+                if (spi->mode & SPI_LSB_FIRST)
+                        cfg |= PSC_SPICFG_MLF;
+                else
+                        cfg &= ~PSC_SPICFG_MLF;
+
+                if (hw->usedma && spi->bits_per_word <= 8)
+                        cfg &= ~PSC_SPICFG_DD_DISABLE;
+                else
+                        cfg |= PSC_SPICFG_DD_DISABLE;
+                cfg = PSC_SPICFG_CLR_LEN(cfg);
+                cfg |= PSC_SPICFG_SET_LEN(spi->bits_per_word);
+
+                cfg = PSC_SPICFG_CLR_BAUD(cfg);
+                cfg &= ~PSC_SPICFG_SET_DIV(3);
+                cfg |= au1550_spi_baudcfg(hw, spi->max_speed_hz);
+
+                hw->regs->psc_spicfg = cfg | PSC_SPICFG_DE_ENABLE;
+                au_sync();
+                do {
+                        stat = hw->regs->psc_spistat;
+                        au_sync();
+                } while ((stat & PSC_SPISTAT_DR) == 0);
+
+                if (hw->pdata->activate_cs)
+                        hw->pdata->activate_cs(hw->pdata, spi->chip_select,
+                                        cspol);
+                break;
+        }
+}
+
+static int au1550_spi_setupxfer(struct spi_device *spi, struct spi_transfer *t)
+{
+        struct au1550_spi *hw = spi_master_get_devdata(spi->master);
+        unsigned bpw, hz;
+        u32 cfg, stat;
+
+        bpw = t ? t->bits_per_word : spi->bits_per_word;
+        hz = t ? t->speed_hz : spi->max_speed_hz;
+
+        if (bpw < 4 || bpw > 24) {
+                dev_err(&spi->dev, "setupxfer: invalid bits_per_word=%d\n",
+                        bpw);
+                return -EINVAL;
+        }
+        if (hz > spi->max_speed_hz || hz > hw->freq_max || hz < hw->freq_min) {
+                dev_err(&spi->dev, "setupxfer: clock rate=%d out of range\n",
+                        hz);
+                return -EINVAL;
+        }
+
+        au1550_spi_bits_handlers_set(hw, spi->bits_per_word);
+
+        cfg = hw->regs->psc_spicfg;
+        au_sync();
+        hw->regs->psc_spicfg = cfg & ~PSC_SPICFG_DE_ENABLE;
+        au_sync();
+
+        if (hw->usedma && bpw <= 8)
+                cfg &= ~PSC_SPICFG_DD_DISABLE;
+        else
+                cfg |= PSC_SPICFG_DD_DISABLE;
+        cfg = PSC_SPICFG_CLR_LEN(cfg);
+        cfg |= PSC_SPICFG_SET_LEN(bpw);
+
+        cfg = PSC_SPICFG_CLR_BAUD(cfg);
+        cfg &= ~PSC_SPICFG_SET_DIV(3);
+        cfg |= au1550_spi_baudcfg(hw, hz);
+
+        hw->regs->psc_spicfg = cfg;
+        au_sync();
+
+        if (cfg & PSC_SPICFG_DE_ENABLE) {
+                do {
+                        stat = hw->regs->psc_spistat;
+                        au_sync();
+                } while ((stat & PSC_SPISTAT_DR) == 0);
+        }
+
+        au1550_spi_reset_fifos(hw);
+        au1550_spi_mask_ack_all(hw);
+        return 0;
+}
+
+static int au1550_spi_setup(struct spi_device *spi)
+{
+        struct au1550_spi *hw = spi_master_get_devdata(spi->master);
+
+        if (spi->bits_per_word == 0)
+                spi->bits_per_word = 8;
+        if (spi->bits_per_word < 4 || spi->bits_per_word > 24) {
+                dev_err(&spi->dev, "setup: invalid bits_per_word=%d\n",
+                        spi->bits_per_word);
+                return -EINVAL;
+        }
+
+        if (spi->max_speed_hz == 0)
+                spi->max_speed_hz = hw->freq_max;
+        if (spi->max_speed_hz > hw->freq_max
+                        || spi->max_speed_hz < hw->freq_min)
+                return -EINVAL;
+        /*
+         * NOTE: cannot change speed and other hw settings immediately,
+         *       otherwise sharing of spi bus is not possible,
+         *       so do not call setupxfer(spi, NULL) here
+         */
+        return 0;
+}
+
+/*
+ * for dma spi transfers, we have to setup rx channel, otherwise there is
+ * no reliable way how to recognize that spi transfer is done
+ * dma complete callbacks are called before real spi transfer is finished
+ * and if only tx dma channel is set up (and rx fifo overflow event masked)
+ * spi master done event irq is not generated unless rx fifo is empty (emptied)
+ * so we need rx tmp buffer to use for rx dma if user does not provide one
+ */
+static int au1550_spi_dma_rxtmp_alloc(struct au1550_spi *hw, unsigned size)
+{
+        hw->dma_rx_tmpbuf = kmalloc(size, GFP_KERNEL);
+        if (!hw->dma_rx_tmpbuf)
+                return -ENOMEM;
+        hw->dma_rx_tmpbuf_size = size;
+        hw->dma_rx_tmpbuf_addr = dma_map_single(hw->dev, hw->dma_rx_tmpbuf,
+                        size, DMA_FROM_DEVICE);
+        if (dma_mapping_error(hw->dma_rx_tmpbuf_addr)) {
+                kfree(hw->dma_rx_tmpbuf);
+                hw->dma_rx_tmpbuf = 0;
+                hw->dma_rx_tmpbuf_size = 0;
+                return -EFAULT;
+        }
+        return 0;
+}
+
+static void au1550_spi_dma_rxtmp_free(struct au1550_spi *hw)
+{
+        dma_unmap_single(hw->dev, hw->dma_rx_tmpbuf_addr,
+                        hw->dma_rx_tmpbuf_size, DMA_FROM_DEVICE);
+        kfree(hw->dma_rx_tmpbuf);
+        hw->dma_rx_tmpbuf = 0;
+        hw->dma_rx_tmpbuf_size = 0;
+}
+
+static int au1550_spi_dma_txrxb(struct spi_device *spi, struct spi_transfer *t)
+{
+        struct au1550_spi *hw = spi_master_get_devdata(spi->master);
+        dma_addr_t dma_tx_addr;
+        dma_addr_t dma_rx_addr;
+        u32 res;
+
+        hw->len = t->len;
+        hw->tx_count = 0;
+        hw->rx_count = 0;
+
+        hw->tx = t->tx_buf;
+        hw->rx = t->rx_buf;
+        dma_tx_addr = t->tx_dma;
+        dma_rx_addr = t->rx_dma;
+
+        /*
+         * check if buffers are already dma mapped, map them otherwise
+         * use rx buffer in place of tx if tx buffer was not provided
+         * use temp rx buffer (preallocated or realloc to fit) for rx dma
+         */
+        if (t->rx_buf) {
+                if (t->rx_dma == 0) {   /* if DMA_ADDR_INVALID, map it */
+                        dma_rx_addr = dma_map_single(hw->dev,
+                                        (void *)t->rx_buf,
+                                        t->len, DMA_FROM_DEVICE);
+                        if (dma_mapping_error(dma_rx_addr))
+                                dev_err(hw->dev, "rx dma map error\n");
+                }
+        } else {
+                if (t->len > hw->dma_rx_tmpbuf_size) {
+                        int ret;
+
+                        au1550_spi_dma_rxtmp_free(hw);
+                        ret = au1550_spi_dma_rxtmp_alloc(hw, max(t->len,
+                                        AU1550_SPI_DMA_RXTMP_MINSIZE));
+                        if (ret < 0)
+                                return ret;
+                }
+                hw->rx = hw->dma_rx_tmpbuf;
+                dma_rx_addr = hw->dma_rx_tmpbuf_addr;
+                dma_sync_single_for_device(hw->dev, dma_rx_addr,
+                        t->len, DMA_FROM_DEVICE);
+        }
+        if (t->tx_buf) {
+                if (t->tx_dma == 0) {   /* if DMA_ADDR_INVALID, map it */
+                        dma_tx_addr = dma_map_single(hw->dev,
+                                        (void *)t->tx_buf,
+                                        t->len, DMA_TO_DEVICE);
+                        if (dma_mapping_error(dma_tx_addr))
+                                dev_err(hw->dev, "tx dma map error\n");
+                }
+        } else {
+                dma_sync_single_for_device(hw->dev, dma_rx_addr,
+                                t->len, DMA_BIDIRECTIONAL);
+                hw->tx = hw->rx;
+        }
+
+        /* put buffers on the ring */
+        res = au1xxx_dbdma_put_dest(hw->dma_rx_ch, hw->rx, t->len);
+        if (!res)
+                dev_err(hw->dev, "rx dma put dest error\n");
+
+        res = au1xxx_dbdma_put_source(hw->dma_tx_ch, (void *)hw->tx, t->len);
+        if (!res)
+                dev_err(hw->dev, "tx dma put source error\n");
+
+        au1xxx_dbdma_start(hw->dma_rx_ch);
+        au1xxx_dbdma_start(hw->dma_tx_ch);
+
+        /* by default enable nearly all events interrupt */
+        hw->regs->psc_spimsk = PSC_SPIMSK_SD;
+        au_sync();
+
+        /* start the transfer */
+        hw->regs->psc_spipcr = PSC_SPIPCR_MS;
+        au_sync();
+
+        wait_for_completion(&hw->master_done);
+
+        au1xxx_dbdma_stop(hw->dma_tx_ch);
+        au1xxx_dbdma_stop(hw->dma_rx_ch);
+
+        if (!t->rx_buf) {
+                /* using the temporal preallocated and premapped buffer */
+                dma_sync_single_for_cpu(hw->dev, dma_rx_addr, t->len,
+                        DMA_FROM_DEVICE);
+        }
+        /* unmap buffers if mapped above */
+        if (t->rx_buf && t->rx_dma == 0 )
+                dma_unmap_single(hw->dev, dma_rx_addr, t->len,
+                        DMA_FROM_DEVICE);
+        if (t->tx_buf && t->tx_dma == 0 )
+                dma_unmap_single(hw->dev, dma_tx_addr, t->len,
+                        DMA_TO_DEVICE);
+
+        return hw->rx_count < hw->tx_count ? hw->rx_count : hw->tx_count;
+}
+
+static irqreturn_t au1550_spi_dma_irq_callback(struct au1550_spi *hw)
+{
+        u32 stat, evnt;
+
+        stat = hw->regs->psc_spistat;
+        evnt = hw->regs->psc_spievent;
+        au_sync();
+        if ((stat & PSC_SPISTAT_DI) == 0) {
+                dev_err(hw->dev, "Unexpected IRQ!\n");
+                return IRQ_NONE;
+        }
+
+        if ((evnt & (PSC_SPIEVNT_MM | PSC_SPIEVNT_RO
+                                | PSC_SPIEVNT_RU | PSC_SPIEVNT_TO
+                                | PSC_SPIEVNT_TU | PSC_SPIEVNT_SD))
+                        != 0) {
+                /*
+                 * due to an spi error we consider transfer as done,
+                 * so mask all events until before next transfer start
+                 * and stop the possibly running dma immediatelly
+                 */
+                au1550_spi_mask_ack_all(hw);
+                au1xxx_dbdma_stop(hw->dma_rx_ch);
+                au1xxx_dbdma_stop(hw->dma_tx_ch);
+
+                /* get number of transfered bytes */
+                hw->rx_count = hw->len - au1xxx_get_dma_residue(hw->dma_rx_ch);
+                hw->tx_count = hw->len - au1xxx_get_dma_residue(hw->dma_tx_ch);
+
+                au1xxx_dbdma_reset(hw->dma_rx_ch);
+                au1xxx_dbdma_reset(hw->dma_tx_ch);
+                au1550_spi_reset_fifos(hw);
+
+                dev_err(hw->dev,
+                        "Unexpected SPI error: event=0x%x stat=0x%x!\n",
+                        evnt, stat);
+
+                complete(&hw->master_done);
+                return IRQ_HANDLED;
+        }
+
+        if ((evnt & PSC_SPIEVNT_MD) != 0) {
+                /* transfer completed successfully */
+                au1550_spi_mask_ack_all(hw);
+                hw->rx_count = hw->len;
+                hw->tx_count = hw->len;
+                complete(&hw->master_done);
+        }
+        return IRQ_HANDLED;
+}
+
+
+/* routines to handle different word sizes in pio mode */
+#define AU1550_SPI_RX_WORD(size, mask)                                  \
+static void au1550_spi_rx_word_##size(struct au1550_spi *hw)            \
+{                                                                       \
+        u32 fifoword = hw->regs->psc_spitxrx & (u32)(mask);             \
+        au_sync();                                                      \
+        if (hw->rx) {                                                   \
+                *(u##size *)hw->rx = (u##size)fifoword;                 \
+                hw->rx += (size) / 8;                                   \
+        }                                                               \
+        hw->rx_count += (size) / 8;                                     \
+}
+
+#define AU1550_SPI_TX_WORD(size, mask)                                  \
+static void au1550_spi_tx_word_##size(struct au1550_spi *hw)            \
+{                                                                       \
+        u32 fifoword = 0;                                               \
+        if (hw->tx) {                                                   \
+                fifoword = *(u##size *)hw->tx & (u32)(mask);            \
+                hw->tx += (size) / 8;                                   \
+        }                                                               \
+        hw->tx_count += (size) / 8;                                     \
+        if (hw->tx_count >= hw->len)                                    \
+                fifoword |= PSC_SPITXRX_LC;                             \
+        hw->regs->psc_spitxrx = fifoword;                               \
+        au_sync();                                                      \
+}
+
+AU1550_SPI_RX_WORD(8,0xff)
+AU1550_SPI_RX_WORD(16,0xffff)
+AU1550_SPI_RX_WORD(32,0xffffff)
+AU1550_SPI_TX_WORD(8,0xff)
+AU1550_SPI_TX_WORD(16,0xffff)
+AU1550_SPI_TX_WORD(32,0xffffff)
+
+static int au1550_spi_pio_txrxb(struct spi_device *spi, struct spi_transfer *t)
+{
+        u32 stat, mask;
+        struct au1550_spi *hw = spi_master_get_devdata(spi->master);
+
+        hw->tx = t->tx_buf;
+        hw->rx = t->rx_buf;
+        hw->len = t->len;
+        hw->tx_count = 0;
+        hw->rx_count = 0;
+
+        /* by default enable nearly all events after filling tx fifo */
+        mask = PSC_SPIMSK_SD;
+
+        /* fill the transmit FIFO */
+        while (hw->tx_count < hw->len) {
+
+                hw->tx_word(hw);
+
+                if (hw->tx_count >= hw->len) {
+                        /* mask tx fifo request interrupt as we are done */
+                        mask |= PSC_SPIMSK_TR;
+                }
+
+                stat = hw->regs->psc_spistat;
+                au_sync();
+                if (stat & PSC_SPISTAT_TF)
+                        break;
+        }
+
+        /* enable event interrupts */
+        hw->regs->psc_spimsk = mask;
+        au_sync();
+
+        /* start the transfer */
+        hw->regs->psc_spipcr = PSC_SPIPCR_MS;
+        au_sync();
+
+        wait_for_completion(&hw->master_done);
+
+        return hw->rx_count < hw->tx_count ? hw->rx_count : hw->tx_count;
+}
+
+static irqreturn_t au1550_spi_pio_irq_callback(struct au1550_spi *hw)
+{
+        int busy;
+        u32 stat, evnt;
+
+        stat = hw->regs->psc_spistat;
+        evnt = hw->regs->psc_spievent;
+        au_sync();
+        if ((stat & PSC_SPISTAT_DI) == 0) {
+                dev_err(hw->dev, "Unexpected IRQ!\n");
+                return IRQ_NONE;
+        }
+
+        if ((evnt & (PSC_SPIEVNT_MM | PSC_SPIEVNT_RO
+                                | PSC_SPIEVNT_RU | PSC_SPIEVNT_TO
+                                | PSC_SPIEVNT_TU | PSC_SPIEVNT_SD))
+                        != 0) {
+                dev_err(hw->dev,
+                        "Unexpected SPI error: event=0x%x stat=0x%x!\n",
+                        evnt, stat);
+                /*
+                 * due to an error we consider transfer as done,
+                 * so mask all events until before next transfer start
+                 */
+                au1550_spi_mask_ack_all(hw);
+                au1550_spi_reset_fifos(hw);
+                complete(&hw->master_done);
+                return IRQ_HANDLED;
+        }
+
+        /*
+         * while there is something to read from rx fifo
+         * or there is a space to write to tx fifo:
+         */
+        do {
+                busy = 0;
+                stat = hw->regs->psc_spistat;
+                au_sync();
+
+                if ((stat & PSC_SPISTAT_RE) == 0 && hw->rx_count < hw->len) {
+                        hw->rx_word(hw);
+                        /* ack the receive request event */
+                        hw->regs->psc_spievent = PSC_SPIEVNT_RR;
+                        au_sync();
+                        busy = 1;
+                }
+
+                if ((stat & PSC_SPISTAT_TF) == 0 && hw->tx_count < hw->len) {
+                        hw->tx_word(hw);
+                        /* ack the transmit request event */
+                        hw->regs->psc_spievent = PSC_SPIEVNT_TR;
+                        au_sync();
+                        busy = 1;
+                }
+        } while (busy);
+
+        evnt = hw->regs->psc_spievent;
+        au_sync();
+
+        if (hw->rx_count >= hw->len || (evnt & PSC_SPIEVNT_MD) != 0) {
+                /* transfer completed successfully */
+                au1550_spi_mask_ack_all(hw);
+                complete(&hw->master_done);
+        }
+        return IRQ_HANDLED;
+}
+
+static int au1550_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t)
+{
+        struct au1550_spi *hw = spi_master_get_devdata(spi->master);
+        return hw->txrx_bufs(spi, t);
+}
+
+static irqreturn_t au1550_spi_irq(int irq, void *dev, struct pt_regs *regs)
+{
+        struct au1550_spi *hw = dev;
+        return hw->irq_callback(hw);
+}
+
+static void au1550_spi_bits_handlers_set(struct au1550_spi *hw, int bpw)
+{
+        if (bpw <= 8) {
+                if (hw->usedma) {
+                        hw->txrx_bufs = &au1550_spi_dma_txrxb;
+                        hw->irq_callback = &au1550_spi_dma_irq_callback;
+                } else {
+                        hw->rx_word = &au1550_spi_rx_word_8;
+                        hw->tx_word = &au1550_spi_tx_word_8;
+                        hw->txrx_bufs = &au1550_spi_pio_txrxb;
+                        hw->irq_callback = &au1550_spi_pio_irq_callback;
+                }
+        } else if (bpw <= 16) {
+                hw->rx_word = &au1550_spi_rx_word_16;
+                hw->tx_word = &au1550_spi_tx_word_16;
+                hw->txrx_bufs = &au1550_spi_pio_txrxb;
+                hw->irq_callback = &au1550_spi_pio_irq_callback;
+        } else {
+                hw->rx_word = &au1550_spi_rx_word_32;
+                hw->tx_word = &au1550_spi_tx_word_32;
+                hw->txrx_bufs = &au1550_spi_pio_txrxb;
+                hw->irq_callback = &au1550_spi_pio_irq_callback;
+        }
+}
+
+static void __init au1550_spi_setup_psc_as_spi(struct au1550_spi *hw)
+{
+        u32 stat, cfg;
+
+        /* set up the PSC for SPI mode */
+        hw->regs->psc_ctrl = PSC_CTRL_DISABLE;
+        au_sync();
+        hw->regs->psc_sel = PSC_SEL_PS_SPIMODE;
+        au_sync();
+
+        hw->regs->psc_spicfg = 0;
+        au_sync();
+
+        hw->regs->psc_ctrl = PSC_CTRL_ENABLE;
+        au_sync();
+
+        do {
+                stat = hw->regs->psc_spistat;
+                au_sync();
+        } while ((stat & PSC_SPISTAT_SR) == 0);
+
+
+        cfg = hw->usedma ? 0 : PSC_SPICFG_DD_DISABLE;
+        cfg |= PSC_SPICFG_SET_LEN(8);
+        cfg |= PSC_SPICFG_RT_FIFO8 | PSC_SPICFG_TT_FIFO8;
+        /* use minimal allowed brg and div values as initial setting: */
+        cfg |= PSC_SPICFG_SET_BAUD(4) | PSC_SPICFG_SET_DIV(0);
+
+#ifdef AU1550_SPI_DEBUG_LOOPBACK
+        cfg |= PSC_SPICFG_LB;
+#endif
+
+        hw->regs->psc_spicfg = cfg;
+        au_sync();
+
+        au1550_spi_mask_ack_all(hw);
+
+        hw->regs->psc_spicfg |= PSC_SPICFG_DE_ENABLE;
+        au_sync();
+
+        do {
+                stat = hw->regs->psc_spistat;
+                au_sync();
+        } while ((stat & PSC_SPISTAT_DR) == 0);
+}
+
+
+static int __init au1550_spi_probe(struct platform_device *pdev)
+{
+        struct au1550_spi *hw;
+        struct spi_master *master;
+        int err = 0;
+
+        master = spi_alloc_master(&pdev->dev, sizeof(struct au1550_spi));
+        if (master == NULL) {
+                dev_err(&pdev->dev, "No memory for spi_master\n");
+                err = -ENOMEM;
+                goto err_nomem;
+        }
+
+        hw = spi_master_get_devdata(master);
+
+        hw->master = spi_master_get(master);
+        hw->pdata = pdev->dev.platform_data;
+        hw->dev = &pdev->dev;
+
+        if (hw->pdata == NULL) {
+                dev_err(&pdev->dev, "No platform data supplied\n");
+                err = -ENOENT;
+                goto err_no_pdata;
+        }
+
+        platform_set_drvdata(pdev, hw);
+
+        init_completion(&hw->master_done);
+
+        hw->bitbang.master = hw->master;
+        hw->bitbang.setup_transfer = au1550_spi_setupxfer;
+        hw->bitbang.chipselect = au1550_spi_chipsel;
+        hw->bitbang.master->setup = au1550_spi_setup;
+        hw->bitbang.txrx_bufs = au1550_spi_txrx_bufs;
+
+        switch (hw->pdata->bus_num) {
+        case 0:
+                hw->irq = AU1550_PSC0_INT;
+                hw->regs = (volatile psc_spi_t *)PSC0_BASE_ADDR;
+                hw->dma_rx_id = DSCR_CMD0_PSC0_RX;
+                hw->dma_tx_id = DSCR_CMD0_PSC0_TX;
+                break;
+        case 1:
+                hw->irq = AU1550_PSC1_INT;
+                hw->regs = (volatile psc_spi_t *)PSC1_BASE_ADDR;
+                hw->dma_rx_id = DSCR_CMD0_PSC1_RX;
+                hw->dma_tx_id = DSCR_CMD0_PSC1_TX;
+                break;
+        case 2:
+                hw->irq = AU1550_PSC2_INT;
+                hw->regs = (volatile psc_spi_t *)PSC2_BASE_ADDR;
+                hw->dma_rx_id = DSCR_CMD0_PSC2_RX;
+                hw->dma_tx_id = DSCR_CMD0_PSC2_TX;
+                break;
+        case 3:
+                hw->irq = AU1550_PSC3_INT;
+                hw->regs = (volatile psc_spi_t *)PSC3_BASE_ADDR;
+                hw->dma_rx_id = DSCR_CMD0_PSC3_RX;
+                hw->dma_tx_id = DSCR_CMD0_PSC3_TX;
+                break;
+        default:
+                dev_err(&pdev->dev, "Wrong bus_num of SPI\n");
+                err = -ENOENT;
+                goto err_no_pdata;
+        }
+
+        if (request_mem_region((unsigned long)hw->regs, sizeof(psc_spi_t),
+                        pdev->name) == NULL) {
+                dev_err(&pdev->dev, "Cannot reserve iomem region\n");
+                err = -ENXIO;
+                goto err_no_iores;
+        }
+
+
+        if (usedma) {
+                if (pdev->dev.dma_mask == NULL)
+                        dev_warn(&pdev->dev, "no dma mask\n");
+                else
+                        hw->usedma = 1;
+        }
+
+        if (hw->usedma) {
+                /*
+                 * create memory device with 8 bits dev_devwidth
+                 * needed for proper byte ordering to spi fifo
+                 */
+                int memid = au1xxx_ddma_add_device(&au1550_spi_mem_dbdev);
+                if (!memid) {
+                        dev_err(&pdev->dev,
+                                "Cannot create dma 8 bit mem device\n");
+                        err = -ENXIO;
+                        goto err_dma_add_dev;
+                }
+
+                hw->dma_tx_ch = au1xxx_dbdma_chan_alloc(memid,
+                        hw->dma_tx_id, NULL, (void *)hw);
+                if (hw->dma_tx_ch == 0) {
+                        dev_err(&pdev->dev,
+                                "Cannot allocate tx dma channel\n");
+                        err = -ENXIO;
+                        goto err_no_txdma;
+                }
+                au1xxx_dbdma_set_devwidth(hw->dma_tx_ch, 8);
+                if (au1xxx_dbdma_ring_alloc(hw->dma_tx_ch,
+                        AU1550_SPI_DBDMA_DESCRIPTORS) == 0) {
+                        dev_err(&pdev->dev,
+                                "Cannot allocate tx dma descriptors\n");
+                        err = -ENXIO;
+                        goto err_no_txdma_descr;
+                }
+
+
+                hw->dma_rx_ch = au1xxx_dbdma_chan_alloc(hw->dma_rx_id,
+                        memid, NULL, (void *)hw);
+                if (hw->dma_rx_ch == 0) {
+                        dev_err(&pdev->dev,
+                                "Cannot allocate rx dma channel\n");
+                        err = -ENXIO;
+                        goto err_no_rxdma;
+                }
+                au1xxx_dbdma_set_devwidth(hw->dma_rx_ch, 8);
+                if (au1xxx_dbdma_ring_alloc(hw->dma_rx_ch,
+                        AU1550_SPI_DBDMA_DESCRIPTORS) == 0) {
+                        dev_err(&pdev->dev,
+                                "Cannot allocate rx dma descriptors\n");
+                        err = -ENXIO;
+                        goto err_no_rxdma_descr;
+                }
+
+                err = au1550_spi_dma_rxtmp_alloc(hw,
+                        AU1550_SPI_DMA_RXTMP_MINSIZE);
+                if (err < 0) {
+                        dev_err(&pdev->dev,
+                                "Cannot allocate initial rx dma tmp buffer\n");
+                        goto err_dma_rxtmp_alloc;
+                }
+        }
+
+        au1550_spi_bits_handlers_set(hw, 8);
+
+        err = request_irq(hw->irq, au1550_spi_irq, 0, pdev->name, hw);
+        if (err) {
+                dev_err(&pdev->dev, "Cannot claim IRQ\n");
+                goto err_no_irq;
+        }
+
+        master->bus_num = hw->pdata->bus_num;
+        master->num_chipselect = hw->pdata->num_chipselect;
+
+        /*
+         *  precompute valid range for spi freq - from au1550 datasheet:
+         *    psc_tempclk = psc_mainclk / (2 << DIV)
+         *    spiclk = psc_tempclk / (2 * (BRG + 1))
+         *    BRG valid range is 4..63
+         *    DIV valid range is 0..3
+         *  round the min and max frequencies to values that would still
+         *  produce valid brg and div
+         */
+        {
+                int min_div = (2 << 0) * (2 * (4 + 1));
+                int max_div = (2 << 3) * (2 * (63 + 1));
+                hw->freq_max = hw->pdata->mainclk_hz / min_div;
+                hw->freq_min = hw->pdata->mainclk_hz / (max_div + 1) + 1;
+        }
+
+        au1550_spi_setup_psc_as_spi(hw);
+
+        err = spi_bitbang_start(&hw->bitbang);
+        if (err) {
+                dev_err(&pdev->dev, "Failed to register SPI master\n");
+                goto err_register;
+        }
+
+        dev_info(&pdev->dev,
+                "spi master registered: bus_num=%d num_chipselect=%d\n",
+                master->bus_num, master->num_chipselect);
+
+        return 0;
+
+err_register:
+        free_irq(hw->irq, hw);
+
+err_no_irq:
+        au1550_spi_dma_rxtmp_free(hw);
+
+err_dma_rxtmp_alloc:
+err_no_rxdma_descr:
+        if (hw->usedma)
+                au1xxx_dbdma_chan_free(hw->dma_rx_ch);
+
+err_no_rxdma:
+err_no_txdma_descr:
+        if (hw->usedma)
+                au1xxx_dbdma_chan_free(hw->dma_tx_ch);
+
+err_no_txdma:
+err_dma_add_dev:
+        release_mem_region((unsigned long)hw->regs, sizeof(psc_spi_t));
+
+err_no_iores:
+err_no_pdata:
+        spi_master_put(hw->master);
+
+err_nomem:
+        return err;
+}
+
+static int __exit au1550_spi_remove(struct platform_device *pdev)
+{
+        struct au1550_spi *hw = platform_get_drvdata(pdev);
+
+        dev_info(&pdev->dev, "spi master remove: bus_num=%d\n",
+                hw->master->bus_num);
+
+        spi_bitbang_stop(&hw->bitbang);
+        free_irq(hw->irq, hw);
+        release_mem_region((unsigned long)hw->regs, sizeof(psc_spi_t));
+
+        if (hw->usedma) {
+                au1550_spi_dma_rxtmp_free(hw);
+                au1xxx_dbdma_chan_free(hw->dma_rx_ch);
+                au1xxx_dbdma_chan_free(hw->dma_tx_ch);
+        }
+
+        platform_set_drvdata(pdev, NULL);
+
+        spi_master_put(hw->master);
+        return 0;
+}
+
+static struct platform_driver au1550_spi_drv = {
+        .remove = __exit_p(au1550_spi_remove),
+        .driver = {
+                .name = "au1550-spi",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init au1550_spi_init(void)
+{
+        return platform_driver_probe(&au1550_spi_drv, au1550_spi_probe);
+}
+module_init(au1550_spi_init);
+
+static void __exit au1550_spi_exit(void)
+{
+        platform_driver_unregister(&au1550_spi_drv);
+}
+module_exit(au1550_spi_exit);
+
+MODULE_DESCRIPTION("Au1550 PSC SPI Driver");
+MODULE_AUTHOR("Jan Nikitenko <jan.nikitenko@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 6657331eed93..c3219b29b5ac 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -152,6 +152,11 @@ static void spi_drv_shutdown(struct device *dev)
         sdrv->shutdown(to_spi_device(dev));
 }
 
+/**
+ * spi_register_driver - register a SPI driver
+ * @sdrv: the driver to register
+ * Context: can sleep
+ */
 int spi_register_driver(struct spi_driver *sdrv)
 {
         sdrv->driver.bus = &spi_bus_type;
@@ -183,7 +188,13 @@ static LIST_HEAD(board_list);
 static DECLARE_MUTEX(board_lock);
 
 
-/* On typical mainboards, this is purely internal; and it's not needed
+/**
+ * spi_new_device - instantiate one new SPI device
+ * @master: Controller to which device is connected
+ * @chip: Describes the SPI device
+ * Context: can sleep
+ *
+ * On typical mainboards, this is purely internal; and it's not needed
  * after board init creates the hard-wired devices.  Some development
  * platforms may not be able to use spi_register_board_info though, and
  * this is exported so that for example a USB or parport based adapter
@@ -251,7 +262,12 @@ fail:
 }
 EXPORT_SYMBOL_GPL(spi_new_device);
 
-/*
+/**
+ * spi_register_board_info - register SPI devices for a given board
+ * @info: array of chip descriptors
+ * @n: how many descriptors are provided
+ * Context: can sleep
+ *
  * Board-specific early init code calls this (probably during arch_initcall)
  * with segments of the SPI device table.  Any device nodes are created later,
  * after the relevant parent SPI controller (bus_num) is defined.  We keep
@@ -337,9 +353,10 @@ static struct class spi_master_class = {
 /**
  * spi_alloc_master - allocate SPI master controller
  * @dev: the controller, possibly using the platform_bus
- * @size: how much driver-private data to preallocate; the pointer to this
+ * @size: how much zeroed driver-private data to allocate; the pointer to this
  *      memory is in the class_data field of the returned class_device,
  *      accessible with spi_master_get_devdata().
+ * Context: can sleep
  *
  * This call is used only by SPI master controller drivers, which are the
  * only ones directly touching chip registers.  It's how they allocate
@@ -375,6 +392,7 @@ EXPORT_SYMBOL_GPL(spi_alloc_master);
 /**
  * spi_register_master - register SPI master controller
  * @master: initialized master, originally from spi_alloc_master()
+ * Context: can sleep
  *
  * SPI master controllers connect to their drivers using some non-SPI bus,
  * such as the platform bus.  The final stage of probe() in that code
@@ -437,6 +455,7 @@ static int __unregister(struct device *dev, void *unused)
 /**
  * spi_unregister_master - unregister SPI master controller
  * @master: the master being unregistered
+ * Context: can sleep
  *
  * This call is used only by SPI master controller drivers, which are the
  * only ones directly touching chip registers.
@@ -455,6 +474,7 @@ EXPORT_SYMBOL_GPL(spi_unregister_master);
 /**
  * spi_busnum_to_master - look up master associated with bus_num
  * @bus_num: the master's bus number
+ * Context: can sleep
  *
  * This call may be used with devices that are registered after
  * arch init time.  It returns a refcounted pointer to the relevant
@@ -492,6 +512,7 @@ static void spi_complete(void *arg)
  * spi_sync - blocking/synchronous SPI data transfers
  * @spi: device with which data will be exchanged
  * @message: describes the data transfers
+ * Context: can sleep
  *
  * This call may only be used from a context that may sleep.  The sleep
  * is non-interruptible, and has no timeout.  Low-overhead controller
@@ -508,7 +529,7 @@ static void spi_complete(void *arg)
  *
  * The return value is a negative error code if the message could not be
  * submitted, else zero.  When the value is zero, then message->status is
- * also defined:  it's the completion code for the transfer, either zero
+ * also defined;  it's the completion code for the transfer, either zero
  * or a negative error code from the controller driver.
  */
 int spi_sync(struct spi_device *spi, struct spi_message *message)
@@ -538,6 +559,7 @@ static u8	*buf;
  * @n_tx: size of txbuf, in bytes
  * @rxbuf: buffer into which data will be read
  * @n_rx: size of rxbuf, in bytes (need not be dma-safe)
+ * Context: can sleep
  *
  * This performs a half duplex MicroWire style transaction with the
  * device, sending txbuf and then reading rxbuf.  The return value
@@ -545,7 +567,8 @@ static u8	*buf;
  * This call may only be used from a context that may sleep.
  *
  * Parameters to this routine are always copied using a small buffer;
- * performance-sensitive or bulk transfer code should instead use
+ * portable code should never use this for more than 32 bytes.
+ * Performance-sensitive or bulk transfer code should instead use
  * spi_{async,sync}() calls with dma-safe buffers.
  */
 int spi_write_then_read(struct spi_device *spi,
diff --git a/drivers/spi/spi_butterfly.c b/drivers/spi/spi_butterfly.c
index 312987a03210..0ee2b2090252 100644
--- a/drivers/spi/spi_butterfly.c
+++ b/drivers/spi/spi_butterfly.c
@@ -20,7 +20,7 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
-#include <linux/platform_device.h>
+#include <linux/device.h>
 #include <linux/parport.h>
 
 #include <linux/sched.h>
@@ -40,8 +40,6 @@
  * and use this custom parallel port cable.
  */
 
-#undef  HAVE_USI        /* nyet */
-
 
 /* DATA output bits (pins 2..9 == D0..D7) */
 #define butterfly_nreset (1 << 1)               /* pin 3 */
@@ -49,19 +47,13 @@
 #define spi_sck_bit     (1 << 0)                /* pin 2 */
 #define spi_mosi_bit    (1 << 7)                /* pin 9 */
 
-#define usi_sck_bit     (1 << 3)                /* pin 5 */
-#define usi_mosi_bit    (1 << 4)                /* pin 6 */
-
 #define vcc_bits        ((1 << 6) | (1 << 5))   /* pins 7, 8 */
 
 /* STATUS input bits */
 #define spi_miso_bit    PARPORT_STATUS_BUSY     /* pin 11 */
 
-#define usi_miso_bit    PARPORT_STATUS_PAPEROUT /* pin 12 */
-
 /* CONTROL output bits */
 #define spi_cs_bit      PARPORT_CONTROL_SELECT  /* pin 17 */
-/* USI uses no chipselect */
 
 
 
@@ -70,15 +62,6 @@ static inline struct butterfly *spidev_to_pp(struct spi_device *spi)
         return spi->controller_data;
 }
 
-static inline int is_usidev(struct spi_device *spi)
-{
-#ifdef  HAVE_USI
-        return spi->chip_select != 1;
-#else
-        return 0;
-#endif
-}
-
 
 struct butterfly {
         /* REVISIT ... for now, this must be first */
@@ -97,23 +80,13 @@ struct butterfly {
 
 /*----------------------------------------------------------------------*/
 
-/*
- * these routines may be slower than necessary because they're hiding
- * the fact that there are two different SPI busses on this cable: one
- * to the DataFlash chip (or AVR SPI controller), the other to the
- * AVR USI controller.
- */
-
 static inline void
 setsck(struct spi_device *spi, int is_on)
 {
         struct butterfly        *pp = spidev_to_pp(spi);
         u8                      bit, byte = pp->lastbyte;
 
-        if (is_usidev(spi))
-                bit = usi_sck_bit;
-        else
-                bit = spi_sck_bit;
+        bit = spi_sck_bit;
 
         if (is_on)
                 byte |= bit;
@@ -129,10 +102,7 @@ setmosi(struct spi_device *spi, int is_on)
         struct butterfly        *pp = spidev_to_pp(spi);
         u8                      bit, byte = pp->lastbyte;
 
-        if (is_usidev(spi))
-                bit = usi_mosi_bit;
-        else
-                bit = spi_mosi_bit;
+        bit = spi_mosi_bit;
 
         if (is_on)
                 byte |= bit;
@@ -148,10 +118,7 @@ static inline int getmiso(struct spi_device *spi)
         int                     value;
         u8                      bit;
 
-        if (is_usidev(spi))
-                bit = usi_miso_bit;
-        else
-                bit = spi_miso_bit;
+        bit = spi_miso_bit;
 
         /* only STATUS_BUSY is NOT negated */
         value = !(parport_read_status(pp->port) & bit);
@@ -166,10 +133,6 @@ static void butterfly_chipselect(struct spi_device *spi, int value)
         if (value != BITBANG_CS_INACTIVE)
                 setsck(spi, spi->mode & SPI_CPOL);
 
-        /* no chipselect on this USI link config */
-        if (is_usidev(spi))
-                return;
-
         /* here, value == "activate or not";
          * most PARPORT_CONTROL_* bits are negated, so we must
          * morph it to value == "bit value to write in control register"
@@ -237,24 +200,16 @@ static void butterfly_attach(struct parport *p)
         int                     status;
         struct butterfly        *pp;
         struct spi_master       *master;
-        struct platform_device  *pdev;
+        struct device           *dev = p->physport->dev;
 
-        if (butterfly)
+        if (butterfly || !dev)
                 return;
 
         /* REVISIT:  this just _assumes_ a butterfly is there ... no probe,
          * and no way to be selective about what it binds to.
          */
 
-        /* FIXME where should master->cdev.dev come from?
-         * e.g. /sys/bus/pnp0/00:0b, some PCI thing, etc
-         * setting up a platform device like this is an ugly kluge...
-         */
-        pdev = platform_device_register_simple("butterfly", -1, NULL, 0);
-        if (IS_ERR(pdev))
-                return;
-
-        master = spi_alloc_master(&pdev->dev, sizeof *pp);
+        master = spi_alloc_master(dev, sizeof *pp);
         if (!master) {
                 status = -ENOMEM;
                 goto done;
@@ -300,7 +255,7 @@ static void butterfly_attach(struct parport *p)
         parport_frob_control(pp->port, spi_cs_bit, 0);
 
         /* stabilize power with chip in reset (nRESET), and
-         * both spi_sck_bit and usi_sck_bit clear (CPOL=0)
+         * spi_sck_bit clear (CPOL=0)
          */
         pp->lastbyte |= vcc_bits;
         parport_write_data(pp->port, pp->lastbyte);
@@ -334,23 +289,6 @@ static void butterfly_attach(struct parport *p)
                 pr_debug("%s: dataflash at %s\n", p->name,
                                 pp->dataflash->dev.bus_id);
 
-#ifdef  HAVE_USI
-        /* Bus 2 is only for talking to the AVR, and it can work no
-         * matter who masters bus 1; needs appropriate AVR firmware.
-         */
-        pp->info[1].max_speed_hz = 10 /* ?? */ * 1000 * 1000;
-        strcpy(pp->info[1].modalias, "butterfly");
-        // pp->info[1].platform_data = ... TBD ... ;
-        pp->info[1].chip_select = 2,
-        pp->info[1].controller_data = pp;
-        pp->butterfly = spi_new_device(pp->bitbang.master, &pp->info[1]);
-        if (pp->butterfly)
-                pr_debug("%s: butterfly at %s\n", p->name,
-                                pp->butterfly->dev.bus_id);
-
-        /* FIXME setup ACK for the IRQ line ...  */
-#endif
-
         // dev_info(_what?_, ...)
         pr_info("%s: AVR Butterfly\n", p->name);
         butterfly = pp;
@@ -366,14 +304,12 @@ clean1:
 clean0:
         (void) spi_master_put(pp->bitbang.master);
 done:
-        platform_device_unregister(pdev);
         pr_debug("%s: butterfly probe, fail %d\n", p->name, status);
 }
 
 static void butterfly_detach(struct parport *p)
 {
         struct butterfly        *pp;
-        struct platform_device  *pdev;
         int                     status;
 
         /* FIXME this global is ugly ... but, how to quickly get from
@@ -386,7 +322,6 @@ static void butterfly_detach(struct parport *p)
         butterfly = NULL;
 
         /* stop() unregisters child devices too */
-        pdev = to_platform_device(pp->bitbang.master->cdev.dev);
         status = spi_bitbang_stop(&pp->bitbang);
 
         /* turn off VCC */
@@ -397,8 +332,6 @@ static void butterfly_detach(struct parport *p)
         parport_unregister_device(pp->pd);
 
         (void) spi_master_put(pp->bitbang.master);
-
-        platform_device_unregister(pdev);
 }
 
 static struct parport_driver butterfly_driver = {
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
new file mode 100644
index 000000000000..c0a6dce800a3
--- /dev/null
+++ b/drivers/spi/spidev.c
@@ -0,0 +1,584 @@
+/*
+ * spidev.c -- simple synchronous userspace interface to SPI devices
+ *
+ * Copyright (C) 2006 SWAPP
+ *      Andrea Paterniani <a.paterniani@swapp-eng.it>
+ * Copyright (C) 2007 David Brownell (simplification, cleanup)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/ioctl.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+
+#include <linux/spi/spi.h>
+#include <linux/spi/spidev.h>
+
+#include <asm/uaccess.h>
+
+
+/*
+ * This supports acccess to SPI devices using normal userspace I/O calls.
+ * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
+ * and often mask message boundaries, full SPI support requires full duplex
+ * transfers.  There are several kinds of of internal message boundaries to
+ * handle chipselect management and other protocol options.
+ *
+ * SPI has a character major number assigned.  We allocate minor numbers
+ * dynamically using a bitmask.  You must use hotplug tools, such as udev
+ * (or mdev with busybox) to create and destroy the /dev/spidevB.C device
+ * nodes, since there is no fixed association of minor numbers with any
+ * particular SPI bus or device.
+ */
+#define SPIDEV_MAJOR                    153     /* assigned */
+#define N_SPI_MINORS                    32      /* ... up to 256 */
+
+static unsigned long    minors[N_SPI_MINORS / BITS_PER_LONG];
+
+
+/* Bit masks for spi_device.mode management */
+#define SPI_MODE_MASK                   (SPI_CPHA | SPI_CPOL)
+
+
+struct spidev_data {
+        struct device           dev;
+        struct spi_device       *spi;
+        struct list_head        device_entry;
+
+        struct mutex            buf_lock;
+        unsigned                users;
+        u8                      *buffer;
+};
+
+static LIST_HEAD(device_list);
+static DEFINE_MUTEX(device_list_lock);
+
+static unsigned bufsiz = 4096;
+module_param(bufsiz, uint, S_IRUGO);
+MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
+
+/*-------------------------------------------------------------------------*/
+
+/* Read-only message with current device setup */
+static ssize_t
+spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
+{
+        struct spidev_data      *spidev;
+        struct spi_device       *spi;
+        ssize_t                 status = 0;
+
+        /* chipselect only toggles at start or end of operation */
+        if (count > bufsiz)
+                return -EMSGSIZE;
+
+        spidev = filp->private_data;
+        spi = spidev->spi;
+
+        mutex_lock(&spidev->buf_lock);
+        status = spi_read(spi, spidev->buffer, count);
+        if (status == 0) {
+                unsigned long   missing;
+
+                missing = copy_to_user(buf, spidev->buffer, count);
+                if (count && missing == count)
+                        status = -EFAULT;
+                else
+                        status = count - missing;
+        }
+        mutex_unlock(&spidev->buf_lock);
+
+        return status;
+}
+
+/* Write-only message with current device setup */
+static ssize_t
+spidev_write(struct file *filp, const char __user *buf,
+                size_t count, loff_t *f_pos)
+{
+        struct spidev_data      *spidev;
+        struct spi_device       *spi;
+        ssize_t                 status = 0;
+        unsigned long           missing;
+
+        /* chipselect only toggles at start or end of operation */
+        if (count > bufsiz)
+                return -EMSGSIZE;
+
+        spidev = filp->private_data;
+        spi = spidev->spi;
+
+        mutex_lock(&spidev->buf_lock);
+        missing = copy_from_user(spidev->buffer, buf, count);
+        if (missing == 0) {
+                status = spi_write(spi, spidev->buffer, count);
+                if (status == 0)
+                        status = count;
+        } else
+                status = -EFAULT;
+        mutex_unlock(&spidev->buf_lock);
+
+        return status;
+}
+
+static int spidev_message(struct spidev_data *spidev,
+                struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
+{
+        struct spi_message      msg;
+        struct spi_transfer     *k_xfers;
+        struct spi_transfer     *k_tmp;
+        struct spi_ioc_transfer *u_tmp;
+        struct spi_device       *spi = spidev->spi;
+        unsigned                n, total;
+        u8                      *buf;
+        int                     status = -EFAULT;
+
+        spi_message_init(&msg);
+        k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
+        if (k_xfers == NULL)
+                return -ENOMEM;
+
+        /* Construct spi_message, copying any tx data to bounce buffer.
+         * We walk the array of user-provided transfers, using each one
+         * to initialize a kernel version of the same transfer.
+         */
+        mutex_lock(&spidev->buf_lock);
+        buf = spidev->buffer;
+        total = 0;
+        for (n = n_xfers, k_tmp = k_xfers, u_tmp = u_xfers;
+                        n;
+                        n--, k_tmp++, u_tmp++) {
+                k_tmp->len = u_tmp->len;
+
+                if (u_tmp->rx_buf) {
+                        k_tmp->rx_buf = buf;
+                        if (!access_ok(VERIFY_WRITE, u_tmp->rx_buf, u_tmp->len))
+                                goto done;
+                }
+                if (u_tmp->tx_buf) {
+                        k_tmp->tx_buf = buf;
+                        if (copy_from_user(buf, (const u8 __user *)u_tmp->tx_buf,
+                                        u_tmp->len))
+                                goto done;
+                }
+
+                total += k_tmp->len;
+                if (total > bufsiz) {
+                        status = -EMSGSIZE;
+                        goto done;
+                }
+                buf += k_tmp->len;
+
+                k_tmp->cs_change = !!u_tmp->cs_change;
+                k_tmp->bits_per_word = u_tmp->bits_per_word;
+                k_tmp->delay_usecs = u_tmp->delay_usecs;
+                k_tmp->speed_hz = u_tmp->speed_hz;
+#ifdef VERBOSE
+                dev_dbg(&spi->dev,
+                        "  xfer len %zd %s%s%s%dbits %u usec %uHz\n",
+                        u_tmp->len,
+                        u_tmp->rx_buf ? "rx " : "",
+                        u_tmp->tx_buf ? "tx " : "",
+                        u_tmp->cs_change ? "cs " : "",
+                        u_tmp->bits_per_word ? : spi->bits_per_word,
+                        u_tmp->delay_usecs,
+                        u_tmp->speed_hz ? : spi->max_speed_hz);
+#endif
+                spi_message_add_tail(k_tmp, &msg);
+        }
+
+        status = spi_sync(spi, &msg);
+        if (status < 0)
+                goto done;
+
+        /* copy any rx data out of bounce buffer */
+        buf = spidev->buffer;
+        for (n = n_xfers, u_tmp = u_xfers; n; n--, u_tmp++) {
+                if (u_tmp->rx_buf) {
+                        if (__copy_to_user((u8 __user *)u_tmp->rx_buf, buf,
+                                        u_tmp->len)) {
+                                status = -EFAULT;
+                                goto done;
+                        }
+                }
+                buf += u_tmp->len;
+        }
+        status = total;
+
+done:
+        mutex_unlock(&spidev->buf_lock);
+        kfree(k_xfers);
+        return status;
+}
+
+static int
+spidev_ioctl(struct inode *inode, struct file *filp,
+                unsigned int cmd, unsigned long arg)
+{
+        int                     err = 0;
+        int                     retval = 0;
+        struct spidev_data      *spidev;
+        struct spi_device       *spi;
+        u32                     tmp;
+        unsigned                n_ioc;
+        struct spi_ioc_transfer *ioc;
+
+        /* Check type and command number */
+        if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC)
+                return -ENOTTY;
+
+        /* Check access direction once here; don't repeat below.
+         * IOC_DIR is from the user perspective, while access_ok is
+         * from the kernel perspective; so they look reversed.
+         */
+        if (_IOC_DIR(cmd) & _IOC_READ)
+                err = !access_ok(VERIFY_WRITE,
+                                (void __user *)arg, _IOC_SIZE(cmd));
+        if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)
+                err = !access_ok(VERIFY_READ,
+                                (void __user *)arg, _IOC_SIZE(cmd));
+        if (err)
+                return -EFAULT;
+
+        spidev = filp->private_data;
+        spi = spidev->spi;
+
+        switch (cmd) {
+        /* read requests */
+        case SPI_IOC_RD_MODE:
+                retval = __put_user(spi->mode & SPI_MODE_MASK,
+                                        (__u8 __user *)arg);
+                break;
+        case SPI_IOC_RD_LSB_FIRST:
+                retval = __put_user((spi->mode & SPI_LSB_FIRST) ?  1 : 0,
+                                        (__u8 __user *)arg);
+                break;
+        case SPI_IOC_RD_BITS_PER_WORD:
+                retval = __put_user(spi->bits_per_word, (__u8 __user *)arg);
+                break;
+        case SPI_IOC_RD_MAX_SPEED_HZ:
+                retval = __put_user(spi->max_speed_hz, (__u32 __user *)arg);
+                break;
+
+        /* write requests */
+        case SPI_IOC_WR_MODE:
+                retval = __get_user(tmp, (u8 __user *)arg);
+                if (retval == 0) {
+                        u8      save = spi->mode;
+
+                        if (tmp & ~SPI_MODE_MASK) {
+                                retval = -EINVAL;
+                                break;
+                        }
+
+                        tmp |= spi->mode & ~SPI_MODE_MASK;
+                        spi->mode = (u8)tmp;
+                        retval = spi_setup(spi);
+                        if (retval < 0)
+                                spi->mode = save;
+                        else
+                                dev_dbg(&spi->dev, "spi mode %02x\n", tmp);
+                }
+                break;
+        case SPI_IOC_WR_LSB_FIRST:
+                retval = __get_user(tmp, (__u8 __user *)arg);
+                if (retval == 0) {
+                        u8      save = spi->mode;
+
+                        if (tmp)
+                                spi->mode |= SPI_LSB_FIRST;
+                        else
+                                spi->mode &= ~SPI_LSB_FIRST;
+                        retval = spi_setup(spi);
+                        if (retval < 0)
+                                spi->mode = save;
+                        else
+                                dev_dbg(&spi->dev, "%csb first\n",
+                                                tmp ? 'l' : 'm');
+                }
+                break;
+        case SPI_IOC_WR_BITS_PER_WORD:
+                retval = __get_user(tmp, (__u8 __user *)arg);
+                if (retval == 0) {
+                        u8      save = spi->bits_per_word;
+
+                        spi->bits_per_word = tmp;
+                        retval = spi_setup(spi);
+                        if (retval < 0)
+                                spi->bits_per_word = save;
+                        else
+                                dev_dbg(&spi->dev, "%d bits per word\n", tmp);
+                }
+                break;
+        case SPI_IOC_WR_MAX_SPEED_HZ:
+                retval = __get_user(tmp, (__u32 __user *)arg);
+                if (retval == 0) {
+                        u32     save = spi->max_speed_hz;
+
+                        spi->max_speed_hz = tmp;
+                        retval = spi_setup(spi);
+                        if (retval < 0)
+                                spi->max_speed_hz = save;
+                        else
+                                dev_dbg(&spi->dev, "%d Hz (max)\n", tmp);
+                }
+                break;
+
+        default:
+                /* segmented and/or full-duplex I/O request */
+                if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
+                                || _IOC_DIR(cmd) != _IOC_WRITE)
+                        return -ENOTTY;
+
+                tmp = _IOC_SIZE(cmd);
+                if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
+                        retval = -EINVAL;
+                        break;
+                }
+                n_ioc = tmp / sizeof(struct spi_ioc_transfer);
+                if (n_ioc == 0)
+                        break;
+
+                /* copy into scratch area */
+                ioc = kmalloc(tmp, GFP_KERNEL);
+                if (!ioc) {
+                        retval = -ENOMEM;
+                        break;
+                }
+                if (__copy_from_user(ioc, (void __user *)arg, tmp)) {
+                        retval = -EFAULT;
+                        break;
+                }
+
+                /* translate to spi_message, execute */
+                retval = spidev_message(spidev, ioc, n_ioc);
+                kfree(ioc);
+                break;
+        }
+        return retval;
+}
+
+static int spidev_open(struct inode *inode, struct file *filp)
+{
+        struct spidev_data      *spidev;
+        int                     status = -ENXIO;
+
+        mutex_lock(&device_list_lock);
+
+        list_for_each_entry(spidev, &device_list, device_entry) {
+                if (spidev->dev.devt == inode->i_rdev) {
+                        status = 0;
+                        break;
+                }
+        }
+        if (status == 0) {
+                if (!spidev->buffer) {
+                        spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
+                        if (!spidev->buffer) {
+                                dev_dbg(&spidev->spi->dev, "open/ENOMEM\n");
+                                status = -ENOMEM;
+                        }
+                }
+                if (status == 0) {
+                        spidev->users++;
+                        filp->private_data = spidev;
+                        nonseekable_open(inode, filp);
+                }
+        } else
+                pr_debug("spidev: nothing for minor %d\n", iminor(inode));
+
+        mutex_unlock(&device_list_lock);
+        return status;
+}
+
+static int spidev_release(struct inode *inode, struct file *filp)
+{
+        struct spidev_data      *spidev;
+        int                     status = 0;
+
+        mutex_lock(&device_list_lock);
+        spidev = filp->private_data;
+        filp->private_data = NULL;
+        spidev->users--;
+        if (!spidev->users) {
+                kfree(spidev->buffer);
+                spidev->buffer = NULL;
+        }
+        mutex_unlock(&device_list_lock);
+
+        return status;
+}
+
+static struct file_operations spidev_fops = {
+        .owner =        THIS_MODULE,
+        /* REVISIT switch to aio primitives, so that userspace
+         * gets more complete API coverage.  It'll simplify things
+         * too, except for the locking.
+         */
+        .write =        spidev_write,
+        .read =         spidev_read,
+        .ioctl =        spidev_ioctl,
+        .open =         spidev_open,
+        .release =      spidev_release,
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* The main reason to have this class is to make mdev/udev create the
+ * /dev/spidevB.C character device nodes exposing our userspace API.
+ * It also simplifies memory management.
+ */
+
+static void spidev_classdev_release(struct device *dev)
+{
+        struct spidev_data      *spidev;
+
+        spidev = container_of(dev, struct spidev_data, dev);
+        kfree(spidev);
+}
+
+static struct class spidev_class = {
+        .name           = "spidev",
+        .owner          = THIS_MODULE,
+        .dev_release    = spidev_classdev_release,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int spidev_probe(struct spi_device *spi)
+{
+        struct spidev_data      *spidev;
+        int                     status;
+        unsigned long           minor;
+
+        /* Allocate driver data */
+        spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
+        if (!spidev)
+                return -ENOMEM;
+
+        /* Initialize the driver data */
+        spidev->spi = spi;
+        mutex_init(&spidev->buf_lock);
+
+        INIT_LIST_HEAD(&spidev->device_entry);
+
+        /* If we can allocate a minor number, hook up this device.
+         * Reusing minors is fine so long as udev or mdev is working.
+         */
+        mutex_lock(&device_list_lock);
+        minor = find_first_zero_bit(minors, ARRAY_SIZE(minors));
+        if (minor < N_SPI_MINORS) {
+                spidev->dev.parent = &spi->dev;
+                spidev->dev.class = &spidev_class;
+                spidev->dev.devt = MKDEV(SPIDEV_MAJOR, minor);
+                snprintf(spidev->dev.bus_id, sizeof spidev->dev.bus_id,
+                                "spidev%d.%d",
+                                spi->master->bus_num, spi->chip_select);
+                status = device_register(&spidev->dev);
+        } else {
+                dev_dbg(&spi->dev, "no minor number available!\n");
+                status = -ENODEV;
+        }
+        if (status == 0) {
+                set_bit(minor, minors);
+                dev_set_drvdata(&spi->dev, spidev);
+                list_add(&spidev->device_entry, &device_list);
+        }
+        mutex_unlock(&device_list_lock);
+
+        if (status != 0)
+                kfree(spidev);
+
+        return status;
+}
+
+static int spidev_remove(struct spi_device *spi)
+{
+        struct spidev_data      *spidev = dev_get_drvdata(&spi->dev);
+
+        mutex_lock(&device_list_lock);
+
+        list_del(&spidev->device_entry);
+        dev_set_drvdata(&spi->dev, NULL);
+        clear_bit(MINOR(spidev->dev.devt), minors);
+        device_unregister(&spidev->dev);
+
+        mutex_unlock(&device_list_lock);
+
+        return 0;
+}
+
+static struct spi_driver spidev_spi = {
+        .driver = {
+                .name =         "spidev",
+                .owner =        THIS_MODULE,
+        },
+        .probe =        spidev_probe,
+        .remove =       __devexit_p(spidev_remove),
+
+        /* NOTE:  suspend/resume methods are not necessary here.
+         * We don't do anything except pass the requests to/from
+         * the underlying controller.  The refrigerator handles
+         * most issues; the controller driver handles the rest.
+         */
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int __init spidev_init(void)
+{
+        int status;
+
+        /* Claim our 256 reserved device numbers.  Then register a class
+         * that will key udev/mdev to add/remove /dev nodes.  Last, register
+         * the driver which manages those device numbers.
+         */
+        BUILD_BUG_ON(N_SPI_MINORS > 256);
+        status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
+        if (status < 0)
+                return status;
+
+        status = class_register(&spidev_class);
+        if (status < 0) {
+                unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
+                return status;
+        }
+
+        status = spi_register_driver(&spidev_spi);
+        if (status < 0) {
+                class_unregister(&spidev_class);
+                unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
+        }
+        return status;
+}
+module_init(spidev_init);
+
+static void __exit spidev_exit(void)
+{
+        spi_unregister_driver(&spidev_spi);
+        class_unregister(&spidev_class);
+        unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
+}
+module_exit(spidev_exit);
+
+MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
+MODULE_DESCRIPTION("User mode SPI device interface");
+MODULE_LICENSE("GPL");
diff --git a/drivers/telephony/ixj.c b/drivers/telephony/ixj.c
index 71cb64e41a1b..c7b0a357b04a 100644
--- a/drivers/telephony/ixj.c
+++ b/drivers/telephony/ixj.c
@@ -7692,7 +7692,7 @@ static int __init ixj_probe_pci(int *cnt)
         IXJ *j = NULL;
 
         for (i = 0; i < IXJMAX - *cnt; i++) {
-                pci = pci_find_device(PCI_VENDOR_ID_QUICKNET,
+                pci = pci_get_device(PCI_VENDOR_ID_QUICKNET,
                                       PCI_DEVICE_ID_QUICKNET_XJ, pci);
                 if (!pci)
                         break;
@@ -7712,6 +7712,7 @@ static int __init ixj_probe_pci(int *cnt)
                         printk(KERN_INFO "ixj: found Internet PhoneJACK PCI at 0x%x\n", j->DSPbase);
                 ++*cnt;
         }
+        pci_dev_put(pci);
         return probe;
 }
 
diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index b3f779f5933a..b082d95bbbaa 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -77,7 +77,6 @@
 #include <linux/sched.h>
 #include <linux/signal.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/stat.h>
 #include <linux/timer.h>
 #include <linux/wait.h>
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 14de3b1b6a20..0081c1d12687 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -59,7 +59,6 @@
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
-#include <linux/smp_lock.h>
 #include <linux/mutex.h>
 #include <asm/uaccess.h>
 #include <linux/usb.h>
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 6584cf00f7f3..15e740e3a5c4 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -49,7 +49,6 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
-#include <linux/smp_lock.h>
 #include <linux/signal.h>
 #include <linux/poll.h>
 #include <linux/init.h>
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index bde29ab2b504..f6b74a678de5 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -16,7 +16,6 @@
 #include <linux/sched.h>
 #include <linux/list.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/ioctl.h>
 #include <linux/usb.h>
 #include <linux/usbdevice_fs.h>
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index cddfc62c4611..cd4f11157280 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -36,7 +36,6 @@
 #include <linux/usb.h>
 #include <linux/namei.h>
 #include <linux/usbdevice_fs.h>
-#include <linux/smp_lock.h>
 #include <linux/parser.h>
 #include <linux/notifier.h>
 #include <asm/byteorder.h>
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index dfd1b5c87ca3..18ddc5e67e39 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -31,7 +31,6 @@
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/errno.h>
-#include <linux/smp_lock.h>
 #include <linux/usb.h>
 #include <linux/mutex.h>
 #include <linux/workqueue.h>
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 2a6e3163d944..ba163f35bf21 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -31,7 +31,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/list.h>
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 7d7909cf2558..fcb5526cb085 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -41,7 +41,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 1dd8b57f4420..325bf7cfb83f 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -28,7 +28,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 65c91d3735de..ae931af05cef 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -30,7 +30,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 49d737725f70..52779c52b56d 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -54,7 +54,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index e552668d36b3..f847c3414be3 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -22,7 +22,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index 8c85e33f74a4..7078374d0b79 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -67,7 +67,6 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index c7458f7e56cc..099aff64f536 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -24,7 +24,6 @@
 #include <linux/ioport.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index e8bbe8bc2598..a66637e725f3 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -26,7 +26,6 @@
 #include <linux/ioport.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 5fa5647ea095..4cfa3ff2c993 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -38,7 +38,6 @@
 #include <linux/ioport.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index a7fa0d75567d..ff0dba01f1c7 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -43,7 +43,6 @@
 #include <linux/pci_ids.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/image/mdc800.c b/drivers/usb/image/mdc800.c
index d308afd06935..36502a06f73a 100644
--- a/drivers/usb/image/mdc800.c
+++ b/drivers/usb/image/mdc800.c
@@ -94,7 +94,6 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <linux/smp_lock.h>
 #include <linux/wait.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 896cb2b71020..51bd80d2b8cc 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -128,7 +128,6 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/usb.h>
 #include <linux/proc_fs.h>
 
diff --git a/drivers/usb/input/xpad.c b/drivers/usb/input/xpad.c
index 735723912950..8c8cd95a6989 100644
--- a/drivers/usb/input/xpad.c
+++ b/drivers/usb/input/xpad.c
@@ -74,7 +74,6 @@
 #include <linux/stat.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
-#include <linux/smp_lock.h>
 #include <linux/usb/input.h>
 
 #define DRIVER_VERSION "v0.0.6"
diff --git a/drivers/usb/misc/idmouse.c b/drivers/usb/misc/idmouse.c
index 15c70bd048c4..8d0e360636e6 100644
--- a/drivers/usb/misc/idmouse.c
+++ b/drivers/usb/misc/idmouse.c
@@ -22,7 +22,6 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/mutex.h>
 #include <asm/uaccess.h>
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index 5dce797bddb7..1713e19a7899 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -80,7 +80,6 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/mutex.h>
 #include <asm/uaccess.h>
diff --git a/drivers/usb/misc/rio500.c b/drivers/usb/misc/rio500.c
index fdf68479a166..88f6abe73624 100644
--- a/drivers/usb/misc/rio500.c
+++ b/drivers/usb/misc/rio500.c
@@ -39,7 +39,6 @@
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/usb.h>
-#include <linux/smp_lock.h>
 #include <linux/wait.h>
 
 #include "rio500_usb.h"
diff --git a/drivers/usb/misc/sisusbvga/sisusb_con.c b/drivers/usb/misc/sisusbvga/sisusb_con.c
index 1730d8642a47..5947afb0017e 100644
--- a/drivers/usb/misc/sisusbvga/sisusb_con.c
+++ b/drivers/usb/misc/sisusbvga/sisusb_con.c
@@ -62,7 +62,6 @@
 #include <linux/selection.h>
 #include <linux/spinlock.h>
 #include <linux/kref.h>
-#include <linux/smp_lock.h>
 #include <linux/ioport.h>
 #include <linux/interrupt.h>
 #include <linux/vmalloc.h>
@@ -322,7 +321,7 @@ sisusbcon_deinit(struct vc_data *c)
 /* interface routine */
 static u8
 sisusbcon_build_attr(struct vc_data *c, u8 color, u8 intensity,
-                            u8 blink, u8 underline, u8 reverse)
+                            u8 blink, u8 underline, u8 reverse, u8 unused)
 {
         u8 attr = color;
 
diff --git a/drivers/usb/mon/mon_main.c b/drivers/usb/mon/mon_main.c
index 8a1df2c9c73e..8977ec0d0f99 100644
--- a/drivers/usb/mon/mon_main.c
+++ b/drivers/usb/mon/mon_main.c
@@ -9,7 +9,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/usb.h>
-#include <linux/smp_lock.h>
 #include <linux/notifier.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 7639022cdf84..87f378806db6 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -28,7 +28,6 @@
 #include <linux/spinlock.h>
 #include <linux/mutex.h>
 #include <linux/list.h>
-#include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index 21f3ddbc9080..6dac1ffdde86 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -47,7 +47,6 @@
 #include <linux/usb.h>
 #include <linux/usb_usual.h>
 #include <linux/blkdev.h>
-#include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/mutex.h>
 #include <scsi/scsi_host.h>
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 344c37595305..1132ba5ff391 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -5,6 +5,11 @@
 menu "Graphics support"
 
 source "drivers/video/backlight/Kconfig"
+source "drivers/video/display/Kconfig"
+
+config VGASTATE
+       tristate
+       default n
 
 config FB
         tristate "Support for frame buffer devices"
@@ -90,6 +95,43 @@ config FB_CFB_IMAGEBLIT
           blitting. This is used by drivers that don't provide their own
           (accelerated) version.
 
+config FB_SYS_FILLRECT
+        tristate
+        depends on FB
+        default n
+        ---help---
+          Include the sys_fillrect function for generic software rectangle
+          filling. This is used by drivers that don't provide their own
+          (accelerated) version and the framebuffer is in system RAM.
+
+config FB_SYS_COPYAREA
+        tristate
+        depends on FB
+        default n
+        ---help---
+          Include the sys_copyarea function for generic software area copying.
+          This is used by drivers that don't provide their own (accelerated)
+          version and the framebuffer is in system RAM.
+
+config FB_SYS_IMAGEBLIT
+        tristate
+        depends on FB
+        default n
+        ---help---
+          Include the sys_imageblit function for generic software image
+          blitting. This is used by drivers that don't provide their own
+          (accelerated) version and the framebuffer is in system RAM.
+
+config FB_SYS_FOPS
+       tristate
+       depends on FB
+       default n
+
+config FB_DEFERRED_IO
+        bool
+        depends on FB
+        default y
+
 config FB_SVGALIB
         tristate
         depends on FB
@@ -375,9 +417,10 @@ config FB_FM2
 config FB_ARC
         tristate "Arc Monochrome LCD board support"
         depends on FB && X86
-        select FB_CFB_FILLRECT
-        select FB_CFB_COPYAREA
-        select FB_CFB_IMAGEBLIT
+        select FB_SYS_FILLRECT
+        select FB_SYS_COPYAREA
+        select FB_SYS_IMAGEBLIT
+        select FB_SYS_FOPS
         help
           This enables support for the Arc Monochrome LCD board. The board
           is based on the KS-108 lcd controller and is typically a matrix
@@ -475,6 +518,8 @@ config FB_VGA16
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
+        select VGASTATE
+        select FONT_8x16 if FRAMEBUFFER_CONSOLE
         help
           This is the frame buffer device driver for VGA 16 color graphic
           cards. Say Y if you have such a card.
@@ -519,15 +564,25 @@ config FB_HP300
         default y
 
 config FB_TGA
-        tristate "TGA framebuffer support"
-        depends on FB && ALPHA
+        tristate "TGA/SFB+ framebuffer support"
+        depends on FB && (ALPHA || TC)
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
         select BITREVERSE
-        help
-          This is the frame buffer device driver for generic TGA graphic
-          cards. Say Y if you have one of those.
+        ---help---
+          This is the frame buffer device driver for generic TGA and SFB+
+          graphic cards.  These include DEC ZLXp-E1, -E2 and -E3 PCI cards,
+          also known as PBXGA-A, -B and -C, and DEC ZLX-E1, -E2 and -E3
+          TURBOchannel cards, also known as PMAGD-A, -B and -C.
+
+          Due to hardware limitations ZLX-E2 and E3 cards are not supported
+          for DECstation 5000/200 systems.  Additionally due to firmware
+          limitations these cards may cause troubles with booting DECstation
+          5000/240 and /260 systems, but are fully supported under Linux if
+          you manage to get it going. ;-)
+
+          Say Y if you have one of those.
 
 config FB_VESA
         bool "VESA VGA graphics support"
@@ -551,6 +606,21 @@ config FB_IMAC
         help
           This is the frame buffer device driver for the Intel-based Macintosh
 
+config FB_HECUBA
+       tristate "Hecuba board support"
+       depends on FB && X86 && MMU
+       select FB_SYS_FILLRECT
+       select FB_SYS_COPYAREA
+       select FB_SYS_IMAGEBLIT
+       select FB_SYS_FOPS
+       select FB_DEFERRED_IO
+       help
+         This enables support for the Hecuba board. This driver was tested
+         with an E-Ink 800x600 display and x86 SBCs through a 16 bit GPIO
+         interface (8 bit data, 4 bit control). If you anticpate using
+         this driver, say Y or M; otherwise say N. You must specify the
+         GPIO IO address to be used for setting control and data.
+
 config FB_HGA
         tristate "Hercules mono graphics support"
         depends on FB && X86
@@ -686,6 +756,7 @@ config FB_NVIDIA
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
         select BITREVERSE
+        select VGASTATE
         help
           This driver supports graphics boards with the nVidia chips, TNT
           and newer. For very old chipsets, such as the RIVA128, then use
@@ -724,6 +795,7 @@ config FB_RIVA
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
         select BITREVERSE
+        select VGASTATE
         help
           This driver supports graphics boards with the nVidia Riva/Geforce
           chips.
@@ -770,6 +842,7 @@ config FB_I810
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
+        select VGASTATE
         help
           This driver supports the on-board graphics built in to the Intel 810 
           and 815 chipsets.  Say Y if you have and plan to use such a board.
@@ -809,6 +882,22 @@ config FB_I810_I2C
         select FB_DDC
         help
 
+config FB_LE80578
+        tristate "Intel LE80578 (Vermilion) support"
+        depends on FB && PCI && X86
+        select FB_MODE_HELPERS
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        help
+          This driver supports the LE80578 (Vermilion Range) chipset
+
+config FB_CARILLO_RANCH
+        tristate "Intel Carillo Ranch support"
+        depends on FB_LE80578 && FB && PCI && X86
+        help
+          This driver supports the LE80578 (Carillo Ranch) board
+
 config FB_INTEL
         tristate "Intel 830M/845G/852GM/855GM/865G/915G/945G support (EXPERIMENTAL)"
         depends on FB && EXPERIMENTAL && PCI && X86
@@ -1120,6 +1209,8 @@ config FB_S3
         select FB_CFB_IMAGEBLIT
         select FB_TILEBLITTING
         select FB_SVGALIB
+        select VGASTATE
+        select FONT_8x16 if FRAMEBUFFER_CONSOLE
         ---help---
           Driver for graphics boards with S3 Trio / S3 Virge chip.
 
@@ -1130,6 +1221,7 @@ config FB_SAVAGE
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
+        select VGASTATE
         help
           This driver supports notebooks and computers with S3 Savage PCI/AGP
           chips.
@@ -1196,6 +1288,7 @@ config FB_NEOMAGIC
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
+        select VGASTATE
         help
           This driver supports notebooks with NeoMagic PCI chips.
           Say Y if you have such a graphics card. 
@@ -1662,13 +1755,25 @@ config FB_PS3_DEFAULT_SIZE_M
           The default value can be overridden on the kernel command line
           using the "ps3fb" option (e.g. "ps3fb=9M");
 
-config FB_VIRTUAL
-        tristate "Virtual Frame Buffer support (ONLY FOR TESTING!)"
-        depends on FB
+config FB_XILINX
+        tristate "Xilinx frame buffer support"
+        depends on FB && XILINX_VIRTEX
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
         ---help---
+          Include support for the Xilinx ML300/ML403 reference design
+          framebuffer. ML300 carries a 640*480 LCD display on the board,
+          ML403 uses a standard DB15 VGA connector.
+
+config FB_VIRTUAL
+        tristate "Virtual Frame Buffer support (ONLY FOR TESTING!)"
+        depends on FB
+        select FB_SYS_FILLRECT
+        select FB_SYS_COPYAREA
+        select FB_SYS_IMAGEBLIT
+        select FB_SYS_FOPS
+        ---help---
           This is a `virtual' frame buffer device. It operates on a chunk of
           unswappable kernel memory instead of on the memory of a graphics
           board. This means you cannot see any output sent to this frame
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 558473d040d6..a916c204274f 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -4,6 +4,7 @@
 
 # Each configuration option enables a list of files.
 
+obj-$(CONFIG_VGASTATE)            += vgastate.o
 obj-y                             += fb_notify.o
 obj-$(CONFIG_FB)                  += fb.o
 fb-y                              := fbmem.o fbmon.o fbcmap.o fbsysfs.o \
@@ -12,14 +13,19 @@ fb-objs                           := $(fb-y)
 
 obj-$(CONFIG_VT)                  += console/
 obj-$(CONFIG_LOGO)                += logo/
-obj-y                             += backlight/
+obj-y                             += backlight/ display/
 
 obj-$(CONFIG_FB_CFB_FILLRECT)  += cfbfillrect.o
 obj-$(CONFIG_FB_CFB_COPYAREA)  += cfbcopyarea.o
 obj-$(CONFIG_FB_CFB_IMAGEBLIT) += cfbimgblt.o
+obj-$(CONFIG_FB_SYS_FILLRECT)  += sysfillrect.o
+obj-$(CONFIG_FB_SYS_COPYAREA)  += syscopyarea.o
+obj-$(CONFIG_FB_SYS_IMAGEBLIT) += sysimgblt.o
+obj-$(CONFIG_FB_SYS_FOPS)      += fb_sys_fops.o
 obj-$(CONFIG_FB_SVGALIB)       += svgalib.o
 obj-$(CONFIG_FB_MACMODES)      += macmodes.o
 obj-$(CONFIG_FB_DDC)           += fb_ddc.o
+obj-$(CONFIG_FB_DEFERRED_IO)   += fb_defio.o
 
 # Hardware specific drivers go first
 obj-$(CONFIG_FB_AMIGA)            += amifb.o c2p.o
@@ -30,7 +36,7 @@ obj-$(CONFIG_FB_PM2)              += pm2fb.o
 obj-$(CONFIG_FB_PM3)              += pm3fb.o
 
 obj-$(CONFIG_FB_MATROX)           += matrox/
-obj-$(CONFIG_FB_RIVA)             += riva/ vgastate.o
+obj-$(CONFIG_FB_RIVA)             += riva/
 obj-$(CONFIG_FB_NVIDIA)           += nvidia/
 obj-$(CONFIG_FB_ATY)              += aty/ macmodes.o
 obj-$(CONFIG_FB_ATY128)           += aty/ macmodes.o
@@ -40,8 +46,7 @@ obj-$(CONFIG_FB_KYRO)             += kyro/
 obj-$(CONFIG_FB_SAVAGE)           += savage/
 obj-$(CONFIG_FB_GEODE)            += geode/
 obj-$(CONFIG_FB_MBX)              += mbx/
-obj-$(CONFIG_FB_I810)             += vgastate.o
-obj-$(CONFIG_FB_NEOMAGIC)         += neofb.o vgastate.o
+obj-$(CONFIG_FB_NEOMAGIC)         += neofb.o
 obj-$(CONFIG_FB_3DFX)             += tdfxfb.o
 obj-$(CONFIG_FB_CONTROL)          += controlfb.o
 obj-$(CONFIG_FB_PLATINUM)         += platinumfb.o
@@ -51,7 +56,8 @@ obj-$(CONFIG_FB_IMSTT)            += imsttfb.o
 obj-$(CONFIG_FB_FM2)              += fm2fb.o
 obj-$(CONFIG_FB_CYBLA)            += cyblafb.o
 obj-$(CONFIG_FB_TRIDENT)          += tridentfb.o
-obj-$(CONFIG_FB_S3)               += s3fb.o vgastate.o
+obj-$(CONFIG_FB_LE80578)          += vermilion/
+obj-$(CONFIG_FB_S3)               += s3fb.o
 obj-$(CONFIG_FB_STI)              += stifb.o
 obj-$(CONFIG_FB_FFB)              += ffb.o sbuslib.o
 obj-$(CONFIG_FB_CG6)              += cg6.o sbuslib.o
@@ -66,6 +72,7 @@ obj-$(CONFIG_FB_ACORN)            += acornfb.o
 obj-$(CONFIG_FB_ATARI)            += atafb.o c2p.o atafb_mfb.o \
                                      atafb_iplan2p2.o atafb_iplan2p4.o atafb_iplan2p8.o
 obj-$(CONFIG_FB_MAC)              += macfb.o
+obj-$(CONFIG_FB_HECUBA)           += hecubafb.o
 obj-$(CONFIG_FB_HGA)              += hgafb.o
 obj-$(CONFIG_FB_XVR500)           += sunxvr500.o
 obj-$(CONFIG_FB_XVR2500)          += sunxvr2500.o
@@ -102,11 +109,12 @@ obj-$(CONFIG_FB_PNX4008_DUM_RGB)  += pnx4008/
 obj-$(CONFIG_FB_IBM_GXT4500)      += gxt4500.o
 obj-$(CONFIG_FB_PS3)              += ps3fb.o
 obj-$(CONFIG_FB_SM501)            += sm501fb.o
+obj-$(CONFIG_FB_XILINX)           += xilinxfb.o
 
 # Platform or fallback drivers go here
 obj-$(CONFIG_FB_VESA)             += vesafb.o
 obj-$(CONFIG_FB_IMAC)             += imacfb.o
-obj-$(CONFIG_FB_VGA16)            += vga16fb.o vgastate.o
+obj-$(CONFIG_FB_VGA16)            += vga16fb.o
 obj-$(CONFIG_FB_OF)               += offb.o
 
 # the test framebuffer is last
diff --git a/drivers/video/arcfb.c b/drivers/video/arcfb.c
index 30a8369757e7..db15baca3f7b 100644
--- a/drivers/video/arcfb.c
+++ b/drivers/video/arcfb.c
@@ -262,7 +262,8 @@ static void arcfb_lcd_update_page(struct arcfb_par *par, unsigned int upper,
         ks108_set_yaddr(par, chipindex, upper/8);
 
         linesize = par->info->var.xres/8;
-        src = par->info->screen_base + (left/8) + (upper * linesize);
+        src = (unsigned char __force *) par->info->screen_base + (left/8) +
+                (upper * linesize);
         ks108_set_xaddr(par, chipindex, left);
 
         bitmask=1;
@@ -368,7 +369,7 @@ static void arcfb_fillrect(struct fb_info *info,
 {
         struct arcfb_par *par = info->par;
 
-        cfb_fillrect(info, rect);
+        sys_fillrect(info, rect);
 
         /* update the physical lcd */
         arcfb_lcd_update(par, rect->dx, rect->dy, rect->width, rect->height);
@@ -379,7 +380,7 @@ static void arcfb_copyarea(struct fb_info *info,
 {
         struct arcfb_par *par = info->par;
 
-        cfb_copyarea(info, area);
+        sys_copyarea(info, area);
 
         /* update the physical lcd */
         arcfb_lcd_update(par, area->dx, area->dy, area->width, area->height);
@@ -389,7 +390,7 @@ static void arcfb_imageblit(struct fb_info *info, const struct fb_image *image)
 {
         struct arcfb_par *par = info->par;
 
-        cfb_imageblit(info, image);
+        sys_imageblit(info, image);
 
         /* update the physical lcd */
         arcfb_lcd_update(par, image->dx, image->dy, image->width,
@@ -439,14 +440,11 @@ static int arcfb_ioctl(struct fb_info *info,
  * the fb. it's inefficient for them to do anything less than 64*8
  * writes since we update the lcd in each write() anyway.
  */
-static ssize_t arcfb_write(struct file *file, const char __user *buf, size_t count,
-                                loff_t *ppos)
+static ssize_t arcfb_write(struct fb_info *info, const char __user *buf,
+                           size_t count, loff_t *ppos)
 {
         /* modded from epson 1355 */
 
-        struct inode *inode;
-        int fbidx;
-        struct fb_info *info;
         unsigned long p;
         int err=-EINVAL;
         unsigned int fbmemlength,x,y,w,h, bitppos, startpos, endpos, bitcount;
@@ -454,13 +452,6 @@ static ssize_t arcfb_write(struct file *file, const char __user *buf, size_t cou
         unsigned int xres;
 
         p = *ppos;
-        inode = file->f_path.dentry->d_inode;
-        fbidx = iminor(inode);
-        info = registered_fb[fbidx];
-
-        if (!info || !info->screen_base)
-                return -ENODEV;
-
         par = info->par;
         xres = info->var.xres;
         fbmemlength = (xres * info->var.yres)/8;
@@ -477,7 +468,7 @@ static ssize_t arcfb_write(struct file *file, const char __user *buf, size_t cou
         if (count) {
                 char *base_addr;
 
-                base_addr = info->screen_base;
+                base_addr = (char __force *)info->screen_base;
                 count -= copy_from_user(base_addr + p, buf, count);
                 *ppos += count;
                 err = -EFAULT;
@@ -503,6 +494,7 @@ static ssize_t arcfb_write(struct file *file, const char __user *buf, size_t cou
 static struct fb_ops arcfb_ops = {
         .owner          = THIS_MODULE,
         .fb_open        = arcfb_open,
+        .fb_read        = fb_sys_read,
         .fb_write       = arcfb_write,
         .fb_release     = arcfb_release,
         .fb_pan_display = arcfb_pan_display,
@@ -603,7 +595,7 @@ static int arcfb_remove(struct platform_device *dev)
 
         if (info) {
                 unregister_framebuffer(info);
-                vfree(info->screen_base);
+                vfree((void __force *)info->screen_base);
                 framebuffer_release(info);
         }
         return 0;
diff --git a/drivers/video/aty/ati_ids.h b/drivers/video/aty/ati_ids.h
index 39ab483fc250..90e7df22f508 100644
--- a/drivers/video/aty/ati_ids.h
+++ b/drivers/video/aty/ati_ids.h
@@ -209,4 +209,4 @@
 #define PCI_CHIP_R423_5D57              0x5D57
 #define PCI_CHIP_RS350_7834             0x7834
 #define PCI_CHIP_RS350_7835             0x7835
-
+#define PCI_CHIP_RS480_5955             0x5955
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index e86d7e0c9825..7fea4d8ae8e2 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -2165,18 +2165,29 @@ static void __devexit aty128_remove(struct pci_dev *pdev)
 static int aty128fb_blank(int blank, struct fb_info *fb)
 {
         struct aty128fb_par *par = fb->par;
-        u8 state = 0;
+        u8 state;
 
         if (par->lock_blank || par->asleep)
                 return 0;
 
-        if (blank & FB_BLANK_VSYNC_SUSPEND)
-                state |= 2;
-        if (blank & FB_BLANK_HSYNC_SUSPEND)
-                state |= 1;
-        if (blank & FB_BLANK_POWERDOWN)
-                state |= 4;
-
+        switch (blank) {
+        case FB_BLANK_NORMAL:
+                state = 4;
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+                state = 6;
+                break;
+        case FB_BLANK_HSYNC_SUSPEND:
+                state = 5;
+                break;
+        case FB_BLANK_POWERDOWN:
+                state = 7;
+                break;
+        case FB_BLANK_UNBLANK:
+        default:
+                state = 0;
+                break;
+        }
         aty_st_8(CRTC_EXT_CNTL+1, state);
 
         if (par->chip_gen == rage_M3) {
@@ -2430,7 +2441,7 @@ static int aty128_pci_suspend(struct pci_dev *pdev, pm_message_t state)
         wait_for_idle(par);
 
         /* Blank display and LCD */
-        aty128fb_blank(VESA_POWERDOWN, info);
+        aty128fb_blank(FB_BLANK_POWERDOWN, info);
 
         /* Sleep */
         par->asleep = 1;
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 8514f2a6f060..ea67dd902d4e 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -2297,20 +2297,6 @@ static int __devinit aty_init(struct fb_info *info)
                 par->pll_limits.xclk = 53;
         }
 #endif
-        if (pll)
-                par->pll_limits.pll_max = pll;
-        if (mclk)
-                par->pll_limits.mclk = mclk;
-        if (xclk)
-                par->pll_limits.xclk = xclk;
-
-        aty_calc_mem_refresh(par, par->pll_limits.xclk);
-        par->pll_per = 1000000/par->pll_limits.pll_max;
-        par->mclk_per = 1000000/par->pll_limits.mclk;
-        par->xclk_per = 1000000/par->pll_limits.xclk;
-
-        par->ref_clk_per = 1000000000000ULL / 14318180;
-        xtal = "14.31818";
 
 #ifdef CONFIG_FB_ATY_GX
         if (!M64_HAS(INTEGRATED)) {
@@ -2338,6 +2324,7 @@ static int __devinit aty_init(struct fb_info *info)
                 case DAC_IBMRGB514:
                         par->dac_ops = &aty_dac_ibm514;
                         break;
+#ifdef CONFIG_ATARI
                 case DAC_ATI68860_B:
                 case DAC_ATI68860_C:
                         par->dac_ops = &aty_dac_ati68860b;
@@ -2346,6 +2333,7 @@ static int __devinit aty_init(struct fb_info *info)
                 case DAC_ATT21C498:
                         par->dac_ops = &aty_dac_att21c498;
                         break;
+#endif
                 default:
                         PRINTKI("aty_init: DAC type not implemented yet!\n");
                         par->dac_ops = &aty_dac_unsupported;
@@ -2389,8 +2377,29 @@ static int __devinit aty_init(struct fb_info *info)
                 /* for many chips, the mclk is 67 MHz for SDRAM, 63 MHz otherwise */
                 if (par->pll_limits.mclk == 67 && par->ram_type < SDRAM)
                         par->pll_limits.mclk = 63;
+                /* Mobility + 32bit memory interface need halved XCLK. */
+                if (M64_HAS(MOBIL_BUS) && par->ram_type == SDRAM32)
+                        par->pll_limits.xclk = (par->pll_limits.xclk + 1) >> 1;
         }
+#endif
 
+        /* Allow command line to override clocks. */
+        if (pll)
+                par->pll_limits.pll_max = pll;
+        if (mclk)
+                par->pll_limits.mclk = mclk;
+        if (xclk)
+                par->pll_limits.xclk = xclk;
+
+        aty_calc_mem_refresh(par, par->pll_limits.xclk);
+        par->pll_per = 1000000/par->pll_limits.pll_max;
+        par->mclk_per = 1000000/par->pll_limits.mclk;
+        par->xclk_per = 1000000/par->pll_limits.xclk;
+
+        par->ref_clk_per = 1000000000000ULL / 14318180;
+        xtal = "14.31818";
+
+#ifdef CONFIG_FB_ATY_CT
         if (M64_HAS(GTB_DSP)) {
                 u8 pll_ref_div = aty_ld_pll_ct(PLL_REF_DIV, par);
 
diff --git a/drivers/video/aty/mach64_ct.c b/drivers/video/aty/mach64_ct.c
index 1fdcfdbf669b..cc9e9779b75f 100644
--- a/drivers/video/aty/mach64_ct.c
+++ b/drivers/video/aty/mach64_ct.c
@@ -608,12 +608,10 @@ static void aty_resume_pll_ct(const struct fb_info *info,
                 aty_st_pll_ct(SCLK_FB_DIV, pll->ct.sclk_fb_div, par);
                 aty_st_pll_ct(SPLL_CNTL2, pll->ct.spll_cntl2, par);
                 /*
-                 * The sclk has been started. However, I believe the first clock
-                 * ticks it generates are not very stable. Hope this primitive loop
-                 * helps for Rage Mobilities that sometimes crash when
-                 * we switch to sclk. (Daniel Mantione, 13-05-2003)
+                 * SCLK has been started. Wait for the PLL to lock. 5 ms
+                 * should be enough according to mach64 programmer's guide.
                  */
-                udelay(500);
+                mdelay(5);
         }
 
         aty_st_pll_ct(PLL_REF_DIV, pll->ct.pll_ref_div, par);
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index 9d629fe1709d..2ce050193018 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -100,6 +100,8 @@
         { PCI_VENDOR_ID_ATI, id, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (flags) | (CHIP_FAMILY_##family) }
 
 static struct pci_device_id radeonfb_pci_table[] = {
+        /* Radeon Xpress 200m */
+        CHIP_DEF(PCI_CHIP_RS480_5955,   RS480,  CHIP_HAS_CRTC2 | CHIP_IS_IGP | CHIP_IS_MOBILITY),
         /* Mobility M6 */
         CHIP_DEF(PCI_CHIP_RADEON_LY,    RV100,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
         CHIP_DEF(PCI_CHIP_RADEON_LZ,    RV100,  CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
@@ -1994,7 +1996,8 @@ static void radeon_identify_vram(struct radeonfb_info *rinfo)
         /* framebuffer size */
         if ((rinfo->family == CHIP_FAMILY_RS100) ||
             (rinfo->family == CHIP_FAMILY_RS200) ||
-            (rinfo->family == CHIP_FAMILY_RS300)) {
+            (rinfo->family == CHIP_FAMILY_RS300) ||
+            (rinfo->family == CHIP_FAMILY_RS480) ) {
           u32 tom = INREG(NB_TOM);
           tmp = ((((tom >> 16) - (tom & 0xffff) + 1) << 6) * 1024);
 
diff --git a/drivers/video/aty/radeon_pm.c b/drivers/video/aty/radeon_pm.c
index 1786ae188322..be1d57bf9dc8 100644
--- a/drivers/video/aty/radeon_pm.c
+++ b/drivers/video/aty/radeon_pm.c
@@ -2826,11 +2826,15 @@ void radeonfb_pm_init(struct radeonfb_info *rinfo, int dynclk, int ignore_devlis
         rinfo->pm_reg = pci_find_capability(rinfo->pdev, PCI_CAP_ID_PM);
 
         /* Enable/Disable dynamic clocks: TODO add sysfs access */
-        rinfo->dynclk = dynclk;
-        if (dynclk == 1) {
+        if (rinfo->family == CHIP_FAMILY_RS480)
+                rinfo->dynclk = -1;
+        else
+                rinfo->dynclk = dynclk;
+
+        if (rinfo->dynclk == 1) {
                 radeon_pm_enable_dynamic_mode(rinfo);
                 printk("radeonfb: Dynamic Clock Power Management enabled\n");
-        } else if (dynclk == 0) {
+        } else if (rinfo->dynclk == 0) {
                 radeon_pm_disable_dynamic_mode(rinfo);
                 printk("radeonfb: Dynamic Clock Power Management disabled\n");
         }
diff --git a/drivers/video/aty/radeonfb.h b/drivers/video/aty/radeonfb.h
index 319000360285..7ebffcdfd1e3 100644
--- a/drivers/video/aty/radeonfb.h
+++ b/drivers/video/aty/radeonfb.h
@@ -48,6 +48,7 @@ enum radeon_family {
         CHIP_FAMILY_RV350,
         CHIP_FAMILY_RV380,    /* RV370/RV380/M22/M24 */
         CHIP_FAMILY_R420,     /* R420/R423/M18 */
+        CHIP_FAMILY_RS480,
         CHIP_FAMILY_LAST,
 };
 
@@ -64,7 +65,8 @@ enum radeon_family {
                                 ((rinfo)->family == CHIP_FAMILY_RV350) || \
                                 ((rinfo)->family == CHIP_FAMILY_R350)  || \
                                 ((rinfo)->family == CHIP_FAMILY_RV380) || \
-                                ((rinfo)->family == CHIP_FAMILY_R420))
+                                ((rinfo)->family == CHIP_FAMILY_R420)  || \
+                                ((rinfo)->family == CHIP_FAMILY_RS480) )
 
 /*
  * Chip flags
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 47d15b5d985a..fbef663fc057 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -63,3 +63,11 @@ config BACKLIGHT_PROGEAR
         help
           If you have a Frontpath ProGear say Y to enable the
           backlight driver.
+
+config BACKLIGHT_CARILLO_RANCH
+        tristate "Intel Carillo Ranch Backlight Driver"
+        depends on BACKLIGHT_CLASS_DEVICE && LCD_CLASS_DEVICE && PCI && X86 && FB_LE80578
+        default n
+        help
+          If you have a Intel LE80578 (Carillo Ranch) say Y to enable the
+          backlight driver.
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 0c3ce46f5094..c6e2266f63e2 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -6,3 +6,4 @@ obj-$(CONFIG_BACKLIGHT_CORGI)	+= corgi_bl.o
 obj-$(CONFIG_BACKLIGHT_HP680)   += hp680_bl.o
 obj-$(CONFIG_BACKLIGHT_LOCOMO)  += locomolcd.o
 obj-$(CONFIG_BACKLIGHT_PROGEAR) += progear_bl.o
+obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o
diff --git a/drivers/video/backlight/cr_bllcd.c b/drivers/video/backlight/cr_bllcd.c
new file mode 100644
index 000000000000..e9bbc3455c94
--- /dev/null
+++ b/drivers/video/backlight/cr_bllcd.c
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) Intel Corp. 2007.
+ * All Rights Reserved.
+ *
+ * Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
+ * develop this driver.
+ *
+ * This file is part of the Carillo Ranch video subsystem driver.
+ * The Carillo Ranch video subsystem driver 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.
+ *
+ * The Carillo Ranch video subsystem driver is distributed
+ * in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this driver; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Authors:
+ *   Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
+ *   Alan Hourihane <alanh-at-tungstengraphics-dot-com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <linux/lcd.h>
+#include <linux/pci.h>
+#include <asm/uaccess.h>
+
+/* The LVDS- and panel power controls sits on the
+ * GPIO port of the ISA bridge.
+ */
+
+#define CRVML_DEVICE_LPC    0x27B8
+#define CRVML_REG_GPIOBAR   0x48
+#define CRVML_REG_GPIOEN    0x4C
+#define CRVML_GPIOEN_BIT    (1 << 4)
+#define CRVML_PANEL_PORT    0x38
+#define CRVML_LVDS_ON       0x00000001
+#define CRVML_PANEL_ON      0x00000002
+#define CRVML_BACKLIGHT_OFF 0x00000004
+
+/* The PLL Clock register sits on Host bridge */
+#define CRVML_DEVICE_MCH   0x5001
+#define CRVML_REG_MCHBAR   0x44
+#define CRVML_REG_MCHEN    0x54
+#define CRVML_MCHEN_BIT    (1 << 28)
+#define CRVML_MCHMAP_SIZE  4096
+#define CRVML_REG_CLOCK    0xc3c
+#define CRVML_CLOCK_SHIFT  8
+#define CRVML_CLOCK_MASK   0x00000f00
+
+static struct pci_dev *lpc_dev;
+static u32 gpio_bar;
+
+struct cr_panel {
+        struct backlight_device *cr_backlight_device;
+        struct lcd_device *cr_lcd_device;
+};
+
+static int cr_backlight_set_intensity(struct backlight_device *bd)
+{
+        int intensity = bd->props.brightness;
+        u32 addr = gpio_bar + CRVML_PANEL_PORT;
+        u32 cur = inl(addr);
+
+        if (bd->props.power == FB_BLANK_UNBLANK)
+                intensity = FB_BLANK_UNBLANK;
+        if (bd->props.fb_blank == FB_BLANK_UNBLANK)
+                intensity = FB_BLANK_UNBLANK;
+        if (bd->props.power == FB_BLANK_POWERDOWN)
+                intensity = FB_BLANK_POWERDOWN;
+        if (bd->props.fb_blank == FB_BLANK_POWERDOWN)
+                intensity = FB_BLANK_POWERDOWN;
+
+        if (intensity == FB_BLANK_UNBLANK) { /* FULL ON */
+                cur &= ~CRVML_BACKLIGHT_OFF;
+                outl(cur, addr);
+        } else if (intensity == FB_BLANK_POWERDOWN) { /* OFF */
+                cur |= CRVML_BACKLIGHT_OFF;
+                outl(cur, addr);
+        } /* anything else, don't bother */
+
+        return 0;
+}
+
+static int cr_backlight_get_intensity(struct backlight_device *bd)
+{
+        u32 addr = gpio_bar + CRVML_PANEL_PORT;
+        u32 cur = inl(addr);
+        u8 intensity;
+
+        if (cur & CRVML_BACKLIGHT_OFF)
+                intensity = FB_BLANK_POWERDOWN;
+        else
+                intensity = FB_BLANK_UNBLANK;
+
+        return intensity;
+}
+
+static struct backlight_ops cr_backlight_ops = {
+        .get_brightness = cr_backlight_get_intensity,
+        .update_status = cr_backlight_set_intensity,
+};
+
+static void cr_panel_on(void)
+{
+        u32 addr = gpio_bar + CRVML_PANEL_PORT;
+        u32 cur = inl(addr);
+
+        if (!(cur & CRVML_PANEL_ON)) {
+                /* Make sure LVDS controller is down. */
+                if (cur & 0x00000001) {
+                        cur &= ~CRVML_LVDS_ON;
+                        outl(cur, addr);
+                }
+                /* Power up Panel */
+                schedule_timeout(HZ / 10);
+                cur |= CRVML_PANEL_ON;
+                outl(cur, addr);
+        }
+
+        /* Power up LVDS controller */
+
+        if (!(cur & CRVML_LVDS_ON)) {
+                schedule_timeout(HZ / 10);
+                outl(cur | CRVML_LVDS_ON, addr);
+        }
+}
+
+static void cr_panel_off(void)
+{
+        u32 addr = gpio_bar + CRVML_PANEL_PORT;
+        u32 cur = inl(addr);
+
+        /* Power down LVDS controller first to avoid high currents */
+        if (cur & CRVML_LVDS_ON) {
+                cur &= ~CRVML_LVDS_ON;
+                outl(cur, addr);
+        }
+        if (cur & CRVML_PANEL_ON) {
+                schedule_timeout(HZ / 10);
+                outl(cur & ~CRVML_PANEL_ON, addr);
+        }
+}
+
+static int cr_lcd_set_power(struct lcd_device *ld, int power)
+{
+        if (power == FB_BLANK_UNBLANK)
+                cr_panel_on();
+        if (power == FB_BLANK_POWERDOWN)
+                cr_panel_off();
+
+        return 0;
+}
+
+static struct lcd_ops cr_lcd_ops = {
+        .set_power = cr_lcd_set_power,
+};
+
+static int cr_backlight_probe(struct platform_device *pdev)
+{
+        struct cr_panel *crp;
+        u8 dev_en;
+
+        crp = kzalloc(sizeof(crp), GFP_KERNEL);
+        if (crp == NULL)
+                return -ENOMEM;
+
+        lpc_dev = pci_get_device(PCI_VENDOR_ID_INTEL,
+                                        CRVML_DEVICE_LPC, NULL);
+        if (!lpc_dev) {
+                printk("INTEL CARILLO RANCH LPC not found.\n");
+                return -ENODEV;
+        }
+
+        pci_read_config_byte(lpc_dev, CRVML_REG_GPIOEN, &dev_en);
+        if (!(dev_en & CRVML_GPIOEN_BIT)) {
+                printk(KERN_ERR
+                       "Carillo Ranch GPIO device was not enabled.\n");
+                pci_dev_put(lpc_dev);
+                return -ENODEV;
+        }
+
+        crp->cr_backlight_device = backlight_device_register("cr-backlight",
+                                                             &pdev->dev, NULL,
+                                                             &cr_backlight_ops);
+        if (IS_ERR(crp->cr_backlight_device)) {
+                pci_dev_put(lpc_dev);
+                return PTR_ERR(crp->cr_backlight_device);
+        }
+
+        crp->cr_lcd_device = lcd_device_register("cr-lcd",
+                                                        &pdev->dev,
+                                                        &cr_lcd_ops);
+
+        if (IS_ERR(crp->cr_lcd_device)) {
+                pci_dev_put(lpc_dev);
+                return PTR_ERR(crp->cr_backlight_device);
+        }
+
+        pci_read_config_dword(lpc_dev, CRVML_REG_GPIOBAR,
+                              &gpio_bar);
+        gpio_bar &= ~0x3F;
+
+        crp->cr_backlight_device->props.power = FB_BLANK_UNBLANK;
+        crp->cr_backlight_device->props.brightness = 0;
+        crp->cr_backlight_device->props.max_brightness = 0;
+        cr_backlight_set_intensity(crp->cr_backlight_device);
+
+        cr_lcd_set_power(crp->cr_lcd_device, FB_BLANK_UNBLANK);
+
+        platform_set_drvdata(pdev, crp);
+
+        return 0;
+}
+
+static int cr_backlight_remove(struct platform_device *pdev)
+{
+        struct cr_panel *crp = platform_get_drvdata(pdev);
+        crp->cr_backlight_device->props.power = FB_BLANK_POWERDOWN;
+        crp->cr_backlight_device->props.brightness = 0;
+        crp->cr_backlight_device->props.max_brightness = 0;
+        cr_backlight_set_intensity(crp->cr_backlight_device);
+        cr_lcd_set_power(crp->cr_lcd_device, FB_BLANK_POWERDOWN);
+        backlight_device_unregister(crp->cr_backlight_device);
+        lcd_device_unregister(crp->cr_lcd_device);
+        pci_dev_put(lpc_dev);
+
+        return 0;
+}
+
+static struct platform_driver cr_backlight_driver = {
+        .probe = cr_backlight_probe,
+        .remove = cr_backlight_remove,
+        .driver = {
+                   .name = "cr_backlight",
+                   },
+};
+
+static struct platform_device *crp;
+
+static int __init cr_backlight_init(void)
+{
+        int ret = platform_driver_register(&cr_backlight_driver);
+
+        if (!ret) {
+                crp = platform_device_alloc("cr_backlight", -1);
+                if (!crp)
+                        return -ENOMEM;
+
+                ret = platform_device_add(crp);
+
+                if (ret) {
+                        platform_device_put(crp);
+                        platform_driver_unregister(&cr_backlight_driver);
+                }
+        }
+
+        printk("Carillo Ranch Backlight Driver Initialized.\n");
+
+        return ret;
+}
+
+static void __exit cr_backlight_exit(void)
+{
+        platform_device_unregister(crp);
+        platform_driver_unregister(&cr_backlight_driver);
+}
+
+module_init(cr_backlight_init);
+module_exit(cr_backlight_exit);
+
+MODULE_AUTHOR("Tungsten Graphics Inc.");
+MODULE_DESCRIPTION("Carillo Ranch Backlight Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/cfbcopyarea.c b/drivers/video/cfbcopyarea.c
index 6faea4034e3d..032210f45be3 100644
--- a/drivers/video/cfbcopyarea.c
+++ b/drivers/video/cfbcopyarea.c
@@ -22,8 +22,6 @@
  *  help moving some redundant computations and branches out of the loop, too.
  */
 
-
-
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
@@ -31,6 +29,7 @@
 #include <linux/slab.h>
 #include <asm/types.h>
 #include <asm/io.h>
+#include "fb_draw.h"
 
 #if BITS_PER_LONG == 32
 #  define FB_WRITEL fb_writel
@@ -41,17 +40,6 @@
 #endif
 
     /*
-     *  Compose two values, using a bitmask as decision value
-     *  This is equivalent to (a & mask) | (b & ~mask)
-     */
-
-static inline unsigned long
-comp(unsigned long a, unsigned long b, unsigned long mask)
-{
-    return ((a ^ b) & mask) ^ b;
-}
-
-    /*
      *  Generic bitwise copy algorithm
      */
 
diff --git a/drivers/video/cfbfillrect.c b/drivers/video/cfbfillrect.c
index f00b50aab606..71623b4f8ca2 100644
--- a/drivers/video/cfbfillrect.c
+++ b/drivers/video/cfbfillrect.c
@@ -21,6 +21,7 @@
 #include <linux/string.h>
 #include <linux/fb.h>
 #include <asm/types.h>
+#include "fb_draw.h"
 
 #if BITS_PER_LONG == 32
 #  define FB_WRITEL fb_writel
@@ -31,73 +32,6 @@
 #endif
 
     /*
-     *  Compose two values, using a bitmask as decision value
-     *  This is equivalent to (a & mask) | (b & ~mask)
-     */
-
-static inline unsigned long
-comp(unsigned long a, unsigned long b, unsigned long mask)
-{
-    return ((a ^ b) & mask) ^ b;
-}
-
-    /*
-     *  Create a pattern with the given pixel's color
-     */
-
-#if BITS_PER_LONG == 64
-static inline unsigned long
-pixel_to_pat( u32 bpp, u32 pixel)
-{
-        switch (bpp) {
-        case 1:
-                return 0xfffffffffffffffful*pixel;
-        case 2:
-                return 0x5555555555555555ul*pixel;
-        case 4:
-                return 0x1111111111111111ul*pixel;
-        case 8:
-                return 0x0101010101010101ul*pixel;
-        case 12:
-                return 0x0001001001001001ul*pixel;
-        case 16:
-                return 0x0001000100010001ul*pixel;
-        case 24:
-                return 0x0000000001000001ul*pixel;
-        case 32:
-                return 0x0000000100000001ul*pixel;
-        default:
-                panic("pixel_to_pat(): unsupported pixelformat\n");
-    }
-}
-#else
-static inline unsigned long
-pixel_to_pat( u32 bpp, u32 pixel)
-{
-        switch (bpp) {
-        case 1:
-                return 0xfffffffful*pixel;
-        case 2:
-                return 0x55555555ul*pixel;
-        case 4:
-                return 0x11111111ul*pixel;
-        case 8:
-                return 0x01010101ul*pixel;
-        case 12:
-                return 0x00001001ul*pixel;
-        case 16:
-                return 0x00010001ul*pixel;
-        case 24:
-                return 0x00000001ul*pixel;
-        case 32:
-                return 0x00000001ul*pixel;
-        default:
-                panic("pixel_to_pat(): unsupported pixelformat\n");
-    }
-}
-#endif
-
-    /*
      *  Aligned pattern fill using 32/64-bit memory accesses
      */
 
diff --git a/drivers/video/cirrusfb.c b/drivers/video/cirrusfb.c
index 2c4bc6205738..8269d704ab2a 100644
--- a/drivers/video/cirrusfb.c
+++ b/drivers/video/cirrusfb.c
@@ -98,15 +98,6 @@
 #define assert(expr)
 #endif
 
-#ifdef TRUE
-#undef TRUE
-#endif
-#ifdef FALSE
-#undef FALSE
-#endif
-#define TRUE  1
-#define FALSE 0
-
 #define MB_ (1024*1024)
 #define KB_ (1024)
 
@@ -146,9 +137,9 @@ static const struct cirrusfb_board_info_rec {
         char *name;             /* ASCII name of chipset */
         long maxclock[5];               /* maximum video clock */
         /* for  1/4bpp, 8bpp 15/16bpp, 24bpp, 32bpp - numbers from xorg code */
-        unsigned init_sr07 : 1; /* init SR07 during init_vgachip() */
-        unsigned init_sr1f : 1; /* write SR1F during init_vgachip() */
-        unsigned scrn_start_bit19 : 1; /* construct bit 19 of screen start address */
+        bool init_sr07 : 1; /* init SR07 during init_vgachip() */
+        bool init_sr1f : 1; /* write SR1F during init_vgachip() */
+        bool scrn_start_bit19 : 1; /* construct bit 19 of screen start address */
 
         /* initial SR07 value, then for each mode */
         unsigned char sr07;
@@ -166,9 +157,9 @@ static const struct cirrusfb_board_info_rec {
                         /* the SD64/P4 have a higher max. videoclock */
                         140000, 140000, 140000, 140000, 140000,
                 },
-                .init_sr07              = TRUE,
-                .init_sr1f              = TRUE,
-                .scrn_start_bit19       = TRUE,
+                .init_sr07              = true,
+                .init_sr1f              = true,
+                .scrn_start_bit19       = true,
                 .sr07                   = 0xF0,
                 .sr07_1bpp              = 0xF0,
                 .sr07_8bpp              = 0xF1,
@@ -180,9 +171,9 @@ static const struct cirrusfb_board_info_rec {
                         /* guess */
                         90000, 90000, 90000, 90000, 90000
                 },
-                .init_sr07              = TRUE,
-                .init_sr1f              = TRUE,
-                .scrn_start_bit19       = FALSE,
+                .init_sr07              = true,
+                .init_sr1f              = true,
+                .scrn_start_bit19       = false,
                 .sr07                   = 0x80,
                 .sr07_1bpp              = 0x80,
                 .sr07_8bpp              = 0x81,
@@ -194,9 +185,9 @@ static const struct cirrusfb_board_info_rec {
                         /* guess */
                         90000, 90000, 90000, 90000, 90000
                 },
-                .init_sr07              = TRUE,
-                .init_sr1f              = TRUE,
-                .scrn_start_bit19       = FALSE,
+                .init_sr07              = true,
+                .init_sr1f              = true,
+                .scrn_start_bit19       = false,
                 .sr07                   = 0x20,
                 .sr07_1bpp              = 0x20,
                 .sr07_8bpp              = 0x21,
@@ -208,9 +199,9 @@ static const struct cirrusfb_board_info_rec {
                         /* guess */
                         90000, 90000, 90000, 90000, 90000
                 },
-                .init_sr07              = TRUE,
-                .init_sr1f              = TRUE,
-                .scrn_start_bit19       = FALSE,
+                .init_sr07              = true,
+                .init_sr1f              = true,
+                .scrn_start_bit19       = false,
                 .sr07                   = 0x80,
                 .sr07_1bpp              = 0x80,
                 .sr07_8bpp              = 0x81,
@@ -221,9 +212,9 @@ static const struct cirrusfb_board_info_rec {
                 .maxclock               = {
                         135100, 135100, 85500, 85500, 0
                 },
-                .init_sr07              = TRUE,
-                .init_sr1f              = FALSE,
-                .scrn_start_bit19       = TRUE,
+                .init_sr07              = true,
+                .init_sr1f              = false,
+                .scrn_start_bit19       = true,
                 .sr07                   = 0x20,
                 .sr07_1bpp              = 0x20,
                 .sr07_8bpp              = 0x21,
@@ -235,9 +226,9 @@ static const struct cirrusfb_board_info_rec {
                         /* for the GD5430.  GD5446 can do more... */
                         85500, 85500, 50000, 28500, 0
                 },
-                .init_sr07              = TRUE,
-                .init_sr1f              = TRUE,
-                .scrn_start_bit19       = TRUE,
+                .init_sr07              = true,
+                .init_sr1f              = true,
+                .scrn_start_bit19       = true,
                 .sr07                   = 0xA0,
                 .sr07_1bpp              = 0xA1,
                 .sr07_1bpp_mux          = 0xA7,
@@ -250,9 +241,9 @@ static const struct cirrusfb_board_info_rec {
                 .maxclock               = {
                         135100, 200000, 200000, 135100, 135100
                 },
-                .init_sr07              = TRUE,
-                .init_sr1f              = TRUE,
-                .scrn_start_bit19       = TRUE,
+                .init_sr07              = true,
+                .init_sr1f              = true,
+                .scrn_start_bit19       = true,
                 .sr07                   = 0x10,
                 .sr07_1bpp              = 0x11,
                 .sr07_8bpp              = 0x11,
@@ -264,9 +255,9 @@ static const struct cirrusfb_board_info_rec {
                         /* guess */
                         135100, 135100, 135100, 135100, 135100,
                 },
-                .init_sr07              = FALSE,
-                .init_sr1f              = FALSE,
-                .scrn_start_bit19       = TRUE,
+                .init_sr07              = false,
+                .init_sr1f              = false,
+                .scrn_start_bit19       = true,
         }
 };
 
@@ -815,7 +806,7 @@ static int cirrusfb_check_var(struct fb_var_screeninfo *var,
 
         default:
                 DPRINTK("Unsupported bpp size: %d\n", var->bits_per_pixel);
-                assert (FALSE);
+                assert(false);
                 /* should never occur */
                 break;
         }
@@ -886,7 +877,7 @@ static int cirrusfb_decode_var (const struct fb_var_screeninfo *var,
 
         default:
                 DPRINTK("Unsupported bpp size: %d\n", var->bits_per_pixel);
-                assert (FALSE);
+                assert(false);
                 /* should never occur */
                 break;
         }
@@ -3203,7 +3194,7 @@ void cirrusfb_dbg_print_regs (caddr_t regbase, cirrusfb_dbg_reg_class_t reg_clas
                         break;
                 default:
                         /* should never occur */
-                        assert (FALSE);
+                        assert(false);
                         break;
                 }
 
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 0429fd2cece0..73813c60d03a 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -107,7 +107,9 @@ static struct display fb_display[MAX_NR_CONSOLES];
 
 static signed char con2fb_map[MAX_NR_CONSOLES];
 static signed char con2fb_map_boot[MAX_NR_CONSOLES];
+#ifndef MODULE
 static int logo_height;
+#endif
 static int logo_lines;
 /* logo_shown is an index to vc_cons when >= 0; otherwise follows FBCON_LOGO
    enums.  */
@@ -576,6 +578,13 @@ static int fbcon_takeover(int show_logo)
         return err;
 }
 
+#ifdef MODULE
+static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
+                               int cols, int rows, int new_cols, int new_rows)
+{
+        logo_shown = FBCON_LOGO_DONTSHOW;
+}
+#else
 static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
                                int cols, int rows, int new_cols, int new_rows)
 {
@@ -584,6 +593,11 @@ static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
         int cnt, erase = vc->vc_video_erase_char, step;
         unsigned short *save = NULL, *r, *q;
 
+        if (info->flags & FBINFO_MODULE) {
+                logo_shown = FBCON_LOGO_DONTSHOW;
+                return;
+        }
+
         /*
          * remove underline attribute from erase character
          * if black and white framebuffer.
@@ -618,8 +632,13 @@ static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
                         r -= cols;
                 }
                 if (!save) {
-                        vc->vc_y += logo_lines;
-                        vc->vc_pos += logo_lines * vc->vc_size_row;
+                        int lines;
+                        if (vc->vc_y + logo_lines >= rows)
+                                lines = rows - vc->vc_y - 1;
+                        else
+                                lines = logo_lines;
+                        vc->vc_y += lines;
+                        vc->vc_pos += lines * vc->vc_size_row;
                 }
         }
         scr_memsetw((unsigned short *) vc->vc_origin,
@@ -650,6 +669,7 @@ static void fbcon_prepare_logo(struct vc_data *vc, struct fb_info *info,
                 vc->vc_top = logo_lines;
         }
 }
+#endif /* MODULE */
 
 #ifdef CONFIG_FB_TILEBLITTING
 static void set_blitting_type(struct vc_data *vc, struct fb_info *info)
@@ -665,6 +685,17 @@ static void set_blitting_type(struct vc_data *vc, struct fb_info *info)
                 fbcon_set_bitops(ops);
         }
 }
+
+static int fbcon_invalid_charcount(struct fb_info *info, unsigned charcount)
+{
+        int err = 0;
+
+        if (info->flags & FBINFO_MISC_TILEBLITTING &&
+            info->tileops->fb_get_tilemax(info) < charcount)
+                err = 1;
+
+        return err;
+}
 #else
 static void set_blitting_type(struct vc_data *vc, struct fb_info *info)
 {
@@ -675,6 +706,12 @@ static void set_blitting_type(struct vc_data *vc, struct fb_info *info)
         fbcon_set_rotation(info);
         fbcon_set_bitops(ops);
 }
+
+static int fbcon_invalid_charcount(struct fb_info *info, unsigned charcount)
+{
+        return 0;
+}
+
 #endif /* CONFIG_MISC_TILEBLITTING */
 
 
@@ -968,7 +1005,9 @@ static const char *fbcon_startup(void)
         if (!p->fontdata) {
                 if (!fontname[0] || !(font = find_font(fontname)))
                         font = get_default_font(info->var.xres,
-                                                info->var.yres);
+                                                info->var.yres,
+                                                info->pixmap.blit_x,
+                                                info->pixmap.blit_y);
                 vc->vc_font.width = font->width;
                 vc->vc_font.height = font->height;
                 vc->vc_font.data = (void *)(p->fontdata = font->data);
@@ -1088,7 +1127,9 @@ static void fbcon_init(struct vc_data *vc, int init)
 
                         if (!fontname[0] || !(font = find_font(fontname)))
                                 font = get_default_font(info->var.xres,
-                                                        info->var.yres);
+                                                        info->var.yres,
+                                                        info->pixmap.blit_x,
+                                                        info->pixmap.blit_y);
                         vc->vc_font.width = font->width;
                         vc->vc_font.height = font->height;
                         vc->vc_font.data = (void *)(p->fontdata = font->data);
@@ -1305,7 +1346,7 @@ static void fbcon_cursor(struct vc_data *vc, int mode)
         int y;
         int c = scr_readw((u16 *) vc->vc_pos);
 
-        if (fbcon_is_inactive(vc, info))
+        if (fbcon_is_inactive(vc, info) || vc->vc_deccm != 1)
                 return;
 
         ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1;
@@ -2475,6 +2516,7 @@ static int fbcon_copy_font(struct vc_data *vc, int con)
 
 static int fbcon_set_font(struct vc_data *vc, struct console_font *font, unsigned flags)
 {
+        struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
         unsigned charcount = font->charcount;
         int w = font->width;
         int h = font->height;
@@ -2488,6 +2530,15 @@ static int fbcon_set_font(struct vc_data *vc, struct console_font *font, unsigne
         if (charcount != 256 && charcount != 512)
                 return -EINVAL;
 
+        /* Make sure drawing engine can handle the font */
+        if (!(info->pixmap.blit_x & (1 << (font->width - 1))) ||
+            !(info->pixmap.blit_y & (1 << (font->height - 1))))
+                return -EINVAL;
+
+        /* Make sure driver can handle the font length */
+        if (fbcon_invalid_charcount(info, charcount))
+                return -EINVAL;
+
         size = h * pitch * charcount;
 
         new_data = kmalloc(FONT_EXTRA_WORDS * sizeof(int) + size, GFP_USER);
@@ -2532,7 +2583,8 @@ static int fbcon_set_def_font(struct vc_data *vc, struct console_font *font, cha
         const struct font_desc *f;
 
         if (!name)
-                f = get_default_font(info->var.xres, info->var.yres);
+                f = get_default_font(info->var.xres, info->var.yres,
+                                     info->pixmap.blit_x, info->pixmap.blit_y);
         else if (!(f = find_font(name)))
                 return -ENOENT;
 
@@ -2829,7 +2881,7 @@ static void fbcon_set_all_vcs(struct fb_info *info)
         struct fbcon_ops *ops = info->fbcon_par;
         struct vc_data *vc;
         struct display *p;
-        int i, rows, cols;
+        int i, rows, cols, fg = -1;
 
         if (!ops || ops->currcon < 0)
                 return;
@@ -2840,34 +2892,23 @@ static void fbcon_set_all_vcs(struct fb_info *info)
                     registered_fb[con2fb_map[i]] != info)
                         continue;
 
+                if (CON_IS_VISIBLE(vc)) {
+                        fg = i;
+                        continue;
+                }
+
                 p = &fb_display[vc->vc_num];
                 set_blitting_type(vc, info);
                 var_to_display(p, &info->var, info);
-                cols = FBCON_SWAP(ops->rotate, info->var.xres, info->var.yres);
-                rows = FBCON_SWAP(ops->rotate, info->var.yres, info->var.xres);
+                cols = FBCON_SWAP(p->rotate, info->var.xres, info->var.yres);
+                rows = FBCON_SWAP(p->rotate, info->var.yres, info->var.xres);
                 cols /= vc->vc_font.width;
                 rows /= vc->vc_font.height;
                 vc_resize(vc, cols, rows);
-
-                if (CON_IS_VISIBLE(vc)) {
-                        updatescrollmode(p, info, vc);
-                        scrollback_max = 0;
-                        scrollback_current = 0;
-
-                        if (!fbcon_is_inactive(vc, info)) {
-                            ops->var.xoffset = ops->var.yoffset =
-                                p->yscroll = 0;
-                            ops->update_start(info);
-                        }
-
-                        fbcon_set_palette(vc, color_table);
-                        update_screen(vc);
-                        if (softback_buf)
-                                fbcon_update_softback(vc);
-                }
         }
 
-        ops->p = &fb_display[ops->currcon];
+        if (fg != -1)
+                fbcon_modechanged(info);
 }
 
 static int fbcon_mode_deleted(struct fb_info *info,
@@ -3002,6 +3043,42 @@ static void fbcon_new_modelist(struct fb_info *info)
         }
 }
 
+static void fbcon_get_requirement(struct fb_info *info,
+                                  struct fb_blit_caps *caps)
+{
+        struct vc_data *vc;
+        struct display *p;
+
+        if (caps->flags) {
+                int i, charcnt;
+
+                for (i = first_fb_vc; i <= last_fb_vc; i++) {
+                        vc = vc_cons[i].d;
+                        if (vc && vc->vc_mode == KD_TEXT &&
+                            info->node == con2fb_map[i]) {
+                                p = &fb_display[i];
+                                caps->x |= 1 << (vc->vc_font.width - 1);
+                                caps->y |= 1 << (vc->vc_font.height - 1);
+                                charcnt = (p->userfont) ?
+                                        FNTCHARCNT(p->fontdata) : 256;
+                                if (caps->len < charcnt)
+                                        caps->len = charcnt;
+                        }
+                }
+        } else {
+                vc = vc_cons[fg_console].d;
+
+                if (vc && vc->vc_mode == KD_TEXT &&
+                    info->node == con2fb_map[fg_console]) {
+                        p = &fb_display[fg_console];
+                        caps->x = 1 << (vc->vc_font.width - 1);
+                        caps->y = 1 << (vc->vc_font.height - 1);
+                        caps->len = (p->userfont) ?
+                                FNTCHARCNT(p->fontdata) : 256;
+                }
+        }
+}
+
 static int fbcon_event_notify(struct notifier_block *self, 
                               unsigned long action, void *data)
 {
@@ -3009,6 +3086,7 @@ static int fbcon_event_notify(struct notifier_block *self,
         struct fb_info *info = event->info;
         struct fb_videomode *mode;
         struct fb_con2fbmap *con2fb;
+        struct fb_blit_caps *caps;
         int ret = 0;
 
         /*
@@ -3057,6 +3135,10 @@ static int fbcon_event_notify(struct notifier_block *self,
         case FB_EVENT_NEW_MODELIST:
                 fbcon_new_modelist(info);
                 break;
+        case FB_EVENT_GET_REQ:
+                caps = event->data;
+                fbcon_get_requirement(info, caps);
+                break;
         }
 
 done:
diff --git a/drivers/video/console/fonts.c b/drivers/video/console/fonts.c
index c960728b7e82..a6828d0a4c56 100644
--- a/drivers/video/console/fonts.c
+++ b/drivers/video/console/fonts.c
@@ -98,6 +98,8 @@ const struct font_desc *find_font(const char *name)
  *      get_default_font - get default font
  *      @xres: screen size of X
  *      @yres: screen size of Y
+ *      @font_w: bit array of supported widths (1 - 32)
+ *      @font_h: bit array of supported heights (1 - 32)
  *
  *      Get the default font for a specified screen size.
  *      Dimensions are in pixels.
@@ -107,7 +109,8 @@ const struct font_desc *find_font(const char *name)
  *
  */
 
-const struct font_desc *get_default_font(int xres, int yres)
+const struct font_desc *get_default_font(int xres, int yres, u32 font_w,
+                                         u32 font_h)
 {
     int i, c, cc;
     const struct font_desc *f, *g;
@@ -129,6 +132,11 @@ const struct font_desc *get_default_font(int xres, int yres)
 #endif
         if ((yres < 400) == (f->height <= 8))
             c += 1000;
+
+        if (!(font_w & (1 << (f->width - 1))) ||
+            !(font_w & (1 << (f->height - 1))))
+            c += 1000;
+
         if (c > cc) {
             cc = c;
             g = f;
diff --git a/drivers/video/console/mdacon.c b/drivers/video/console/mdacon.c
index 124ecbe6f88c..bd8d995fe25d 100644
--- a/drivers/video/console/mdacon.c
+++ b/drivers/video/console/mdacon.c
@@ -384,7 +384,7 @@ static inline u16 mda_convert_attr(u16 ch)
 }
 
 static u8 mdacon_build_attr(struct vc_data *c, u8 color, u8 intensity, 
-                            u8 blink, u8 underline, u8 reverse)
+                            u8 blink, u8 underline, u8 reverse, u8 italic)
 {
         /* The attribute is just a bit vector:
          *
@@ -397,6 +397,7 @@ static u8 mdacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
         return (intensity & 3) |
                 ((underline & 1) << 2) |
                 ((reverse   & 1) << 3) |
+                (!!italic << 4) |
                 ((blink     & 1) << 7);
 }
 
diff --git a/drivers/video/console/promcon.c b/drivers/video/console/promcon.c
index b78eac63459f..ae02e4eb18e7 100644
--- a/drivers/video/console/promcon.c
+++ b/drivers/video/console/promcon.c
@@ -548,7 +548,8 @@ promcon_scroll(struct vc_data *conp, int t, int b, int dir, int count)
 }
 
 #if !(PROMCON_COLOR)
-static u8 promcon_build_attr(struct vc_data *conp, u8 _color, u8 _intensity, u8 _blink, u8 _underline, u8 _reverse)
+static u8 promcon_build_attr(struct vc_data *conp, u8 _color, u8 _intensity,
+    u8 _blink, u8 _underline, u8 _reverse, u8 _italic)
 {
         return (_reverse) ? 0xf : 0x7;
 }
diff --git a/drivers/video/console/sticon.c b/drivers/video/console/sticon.c
index 57b21e533036..67a682d6cc7b 100644
--- a/drivers/video/console/sticon.c
+++ b/drivers/video/console/sticon.c
@@ -314,7 +314,7 @@ static unsigned long sticon_getxy(struct vc_data *conp, unsigned long pos,
 }
 
 static u8 sticon_build_attr(struct vc_data *conp, u8 color, u8 intens,
-                            u8 blink, u8 underline, u8 reverse)
+                            u8 blink, u8 underline, u8 reverse, u8 italic)
 {
     u8 attr = ((color & 0x70) >> 1) | ((color & 7));
 
diff --git a/drivers/video/console/sticore.c b/drivers/video/console/sticore.c
index 88e7038eab88..717b360d0415 100644
--- a/drivers/video/console/sticore.c
+++ b/drivers/video/console/sticore.c
@@ -495,7 +495,7 @@ sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
                 return NULL;
         fbfont = find_font(fbfont_name);
         if (!fbfont)
-                fbfont = get_default_font(1024,768);
+                fbfont = get_default_font(1024,768, ~(u32)0, ~(u32)0);
         if (!fbfont)
                 return NULL;
 
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 3e67c34df9a5..2460b82a1d93 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -86,8 +86,6 @@ static int vgacon_set_origin(struct vc_data *c);
 static void vgacon_save_screen(struct vc_data *c);
 static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
                          int lines);
-static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
-                            u8 blink, u8 underline, u8 reverse);
 static void vgacon_invert_region(struct vc_data *c, u16 * p, int count);
 static unsigned long vgacon_uni_pagedir[2];
 
@@ -578,12 +576,14 @@ static void vgacon_deinit(struct vc_data *c)
 }
 
 static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
-                            u8 blink, u8 underline, u8 reverse)
+                            u8 blink, u8 underline, u8 reverse, u8 italic)
 {
         u8 attr = color;
 
         if (vga_can_do_color) {
-                if (underline)
+                if (italic)
+                        attr = (attr & 0xF0) | c->vc_itcolor;
+                else if (underline)
                         attr = (attr & 0xf0) | c->vc_ulcolor;
                 else if (intensity == 0)
                         attr = (attr & 0xf0) | c->vc_halfcolor;
@@ -597,7 +597,9 @@ static u8 vgacon_build_attr(struct vc_data *c, u8 color, u8 intensity,
         if (intensity == 2)
                 attr ^= 0x08;
         if (!vga_can_do_color) {
-                if (underline)
+                if (italic)
+                        attr = (attr & 0xF8) | 0x02;
+                else if (underline)
                         attr = (attr & 0xf8) | 0x01;
                 else if (intensity == 0)
                         attr = (attr & 0xf0) | 0x08;
@@ -658,6 +660,9 @@ static void vgacon_set_cursor_size(int xpos, int from, int to)
 
 static void vgacon_cursor(struct vc_data *c, int mode)
 {
+        if (c->vc_mode != KD_TEXT)
+                return;
+
         vgacon_restore_screen(c);
 
         switch (mode) {
@@ -1316,7 +1321,7 @@ static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
         unsigned long oldo;
         unsigned int delta;
 
-        if (t || b != c->vc_rows || vga_is_gfx)
+        if (t || b != c->vc_rows || vga_is_gfx || c->vc_mode != KD_TEXT)
                 return 0;
 
         if (!vga_hardscroll_enabled || lines >= c->vc_rows / 2)
diff --git a/drivers/video/display/Kconfig b/drivers/video/display/Kconfig
new file mode 100644
index 000000000000..f99af931d4f8
--- /dev/null
+++ b/drivers/video/display/Kconfig
@@ -0,0 +1,24 @@
+#
+# Display drivers configuration
+#
+
+menu "Display device support"
+
+config DISPLAY_SUPPORT
+        tristate "Display panel/monitor support"
+        ---help---
+          This framework adds support for low-level control of a display.
+          This includes support for power.
+
+          Enable this to be able to choose the drivers for controlling the
+          physical display panel/monitor on some platforms. This not only
+          covers LCD displays for PDAs but also other types of displays
+          such as CRT, TVout etc.
+
+          To have support for your specific display panel you will have to
+          select the proper drivers which depend on this option.
+
+comment "Display hardware drivers"
+        depends on DISPLAY_SUPPORT
+
+endmenu
diff --git a/drivers/video/display/Makefile b/drivers/video/display/Makefile
new file mode 100644
index 000000000000..c0ea832bf171
--- /dev/null
+++ b/drivers/video/display/Makefile
@@ -0,0 +1,6 @@
+# Display drivers
+
+display-objs                            := display-sysfs.o
+
+obj-$(CONFIG_DISPLAY_SUPPORT)           += display.o
+
diff --git a/drivers/video/display/display-sysfs.c b/drivers/video/display/display-sysfs.c
new file mode 100644
index 000000000000..35477177bef4
--- /dev/null
+++ b/drivers/video/display/display-sysfs.c
@@ -0,0 +1,217 @@
+/*
+ *  display-sysfs.c - Display output driver sysfs interface
+ *
+ *  Copyright (C) 2007 James Simmons <jsimmons@infradead.org>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or (at
+ *  your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#include <linux/module.h>
+#include <linux/display.h>
+#include <linux/ctype.h>
+#include <linux/idr.h>
+#include <linux/err.h>
+
+static ssize_t display_show_name(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct display_device *dsp = dev_get_drvdata(dev);
+        return snprintf(buf, PAGE_SIZE, "%s\n", dsp->name);
+}
+
+static ssize_t display_show_type(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct display_device *dsp = dev_get_drvdata(dev);
+        return snprintf(buf, PAGE_SIZE, "%s\n", dsp->type);
+}
+
+static ssize_t display_show_contrast(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct display_device *dsp = dev_get_drvdata(dev);
+        ssize_t rc = -ENXIO;
+
+        mutex_lock(&dsp->lock);
+        if (likely(dsp->driver) && dsp->driver->get_contrast)
+                rc = sprintf(buf, "%d\n", dsp->driver->get_contrast(dsp));
+        mutex_unlock(&dsp->lock);
+        return rc;
+}
+
+static ssize_t display_store_contrast(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct display_device *dsp = dev_get_drvdata(dev);
+        ssize_t ret = -EINVAL, size;
+        int contrast;
+        char *endp;
+
+        contrast = simple_strtoul(buf, &endp, 0);
+        size = endp - buf;
+
+        if (*endp && isspace(*endp))
+                size++;
+
+        if (size != count)
+                return ret;
+
+        mutex_lock(&dsp->lock);
+        if (likely(dsp->driver && dsp->driver->set_contrast)) {
+                pr_debug("display: set contrast to %d\n", contrast);
+                dsp->driver->set_contrast(dsp, contrast);
+                ret = count;
+        }
+        mutex_unlock(&dsp->lock);
+        return ret;
+}
+
+static ssize_t display_show_max_contrast(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+        struct display_device *dsp = dev_get_drvdata(dev);
+        ssize_t rc = -ENXIO;
+
+        mutex_lock(&dsp->lock);
+        if (likely(dsp->driver))
+                rc = sprintf(buf, "%d\n", dsp->driver->max_contrast);
+        mutex_unlock(&dsp->lock);
+        return rc;
+}
+
+static struct device_attribute display_attrs[] = {
+        __ATTR(name, S_IRUGO, display_show_name, NULL),
+        __ATTR(type, S_IRUGO, display_show_type, NULL),
+        __ATTR(contrast, S_IRUGO | S_IWUSR, display_show_contrast, display_store_contrast),
+        __ATTR(max_contrast, S_IRUGO, display_show_max_contrast, NULL),
+};
+
+static int display_suspend(struct device *dev, pm_message_t state)
+{
+        struct display_device *dsp = dev_get_drvdata(dev);
+
+        mutex_lock(&dsp->lock);
+        if (likely(dsp->driver->suspend))
+                dsp->driver->suspend(dsp, state);
+        mutex_unlock(&dsp->lock);
+        return 0;
+};
+
+static int display_resume(struct device *dev)
+{
+        struct display_device *dsp = dev_get_drvdata(dev);
+
+        mutex_lock(&dsp->lock);
+        if (likely(dsp->driver->resume))
+                dsp->driver->resume(dsp);
+        mutex_unlock(&dsp->lock);
+        return 0;
+};
+
+static struct mutex allocated_dsp_lock;
+static DEFINE_IDR(allocated_dsp);
+static struct class *display_class;
+
+struct display_device *display_device_register(struct display_driver *driver,
+                                                struct device *parent, void *devdata)
+{
+        struct display_device *new_dev = NULL;
+        int ret = -EINVAL;
+
+        if (unlikely(!driver))
+                return ERR_PTR(ret);
+
+        mutex_lock(&allocated_dsp_lock);
+        ret = idr_pre_get(&allocated_dsp, GFP_KERNEL);
+        mutex_unlock(&allocated_dsp_lock);
+        if (!ret)
+                return ERR_PTR(ret);
+
+        new_dev = kzalloc(sizeof(struct display_device), GFP_KERNEL);
+        if (likely(new_dev) && unlikely(driver->probe(new_dev, devdata))) {
+                // Reserve the index for this display
+                mutex_lock(&allocated_dsp_lock);
+                ret = idr_get_new(&allocated_dsp, new_dev, &new_dev->idx);
+                mutex_unlock(&allocated_dsp_lock);
+
+                if (!ret) {
+                        new_dev->dev = device_create(display_class, parent, 0,
+                                                "display%d", new_dev->idx);
+                        if (!IS_ERR(new_dev->dev)) {
+                                dev_set_drvdata(new_dev->dev, new_dev);
+                                new_dev->parent = parent;
+                                new_dev->driver = driver;
+                                mutex_init(&new_dev->lock);
+                                return new_dev;
+                        }
+                        mutex_lock(&allocated_dsp_lock);
+                        idr_remove(&allocated_dsp, new_dev->idx);
+                        mutex_unlock(&allocated_dsp_lock);
+                        ret = -EINVAL;
+                }
+        }
+        kfree(new_dev);
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL(display_device_register);
+
+void display_device_unregister(struct display_device *ddev)
+{
+        if (!ddev)
+                return;
+        // Free device
+        mutex_lock(&ddev->lock);
+        device_unregister(ddev->dev);
+        mutex_unlock(&ddev->lock);
+        // Mark device index as avaliable
+        mutex_lock(&allocated_dsp_lock);
+        idr_remove(&allocated_dsp, ddev->idx);
+        mutex_unlock(&allocated_dsp_lock);
+        kfree(ddev);
+}
+EXPORT_SYMBOL(display_device_unregister);
+
+static int __init display_class_init(void)
+{
+        display_class = class_create(THIS_MODULE, "display");
+        if (IS_ERR(display_class)) {
+                printk(KERN_ERR "Failed to create display class\n");
+                display_class = NULL;
+                return -EINVAL;
+        }
+        display_class->dev_attrs = display_attrs;
+        display_class->suspend = display_suspend;
+        display_class->resume = display_resume;
+        mutex_init(&allocated_dsp_lock);
+        return 0;
+}
+
+static void __exit display_class_exit(void)
+{
+        class_destroy(display_class);
+}
+
+module_init(display_class_init);
+module_exit(display_class_exit);
+
+MODULE_DESCRIPTION("Display Hardware handling");
+MODULE_AUTHOR("James Simmons <jsimmons@infradead.org>");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/video/epson1355fb.c b/drivers/video/epson1355fb.c
index 29e07c109887..ca2c54ce508e 100644
--- a/drivers/video/epson1355fb.c
+++ b/drivers/video/epson1355fb.c
@@ -403,17 +403,10 @@ static inline unsigned long copy_to_user16(void *to, const void *from,
 
 
 static ssize_t
-epson1355fb_read(struct file *file, char *buf, size_t count, loff_t * ppos)
+epson1355fb_read(struct fb_info *info, char *buf, size_t count, loff_t * ppos)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
-        int fbidx = iminor(inode);
-        struct fb_info *info = registered_fb[fbidx];
         unsigned long p = *ppos;
 
-        /* from fbmem.c except for our own copy_*_user */
-        if (!info || !info->screen_base)
-                return -ENODEV;
-
         if (p >= info->fix.smem_len)
                 return 0;
         if (count >= info->fix.smem_len)
@@ -434,20 +427,13 @@ epson1355fb_read(struct file *file, char *buf, size_t count, loff_t * ppos)
 }
 
 static ssize_t
-epson1355fb_write(struct file *file, const char *buf,
+epson1355fb_write(struct fb_info *info, const char *buf,
                   size_t count, loff_t * ppos)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
-        int fbidx = iminor(inode);
-        struct fb_info *info = registered_fb[fbidx];
         unsigned long p = *ppos;
         int err;
 
         /* from fbmem.c except for our own copy_*_user */
-        if (!info || !info->screen_base)
-                return -ENODEV;
-
-        /* from fbmem.c except for our own copy_*_user */
         if (p > info->fix.smem_len)
                 return -ENOSPC;
         if (count >= info->fix.smem_len)
@@ -650,9 +636,10 @@ int __init epson1355fb_probe(struct platform_device *dev)
         }
 
         info = framebuffer_alloc(sizeof(struct epson1355_par) + sizeof(u32) * 256, &dev->dev);
-        if (!info)
+        if (!info) {
                 rc = -ENOMEM;
                 goto bail;
+        }
 
         default_par = info->par;
         default_par->reg_addr = (unsigned long) ioremap(EPSON1355FB_REGS_PHYS, EPSON1355FB_REGS_LEN);
diff --git a/drivers/video/fb_defio.c b/drivers/video/fb_defio.c
new file mode 100644
index 000000000000..1a8643f053d8
--- /dev/null
+++ b/drivers/video/fb_defio.c
@@ -0,0 +1,151 @@
+/*
+ *  linux/drivers/video/fb_defio.c
+ *
+ *  Copyright (C) 2006 Jaya Kumar
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive
+ * for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/fb.h>
+#include <linux/list.h>
+#include <asm/uaccess.h>
+
+/* to support deferred IO */
+#include <linux/rmap.h>
+#include <linux/pagemap.h>
+
+/* this is to find and return the vmalloc-ed fb pages */
+static struct page* fb_deferred_io_nopage(struct vm_area_struct *vma,
+                                        unsigned long vaddr, int *type)
+{
+        unsigned long offset;
+        struct page *page;
+        struct fb_info *info = vma->vm_private_data;
+        /* info->screen_base is in System RAM */
+        void *screen_base = (void __force *) info->screen_base;
+
+        offset = (vaddr - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);
+        if (offset >= info->fix.smem_len)
+                return NOPAGE_SIGBUS;
+
+        page = vmalloc_to_page(screen_base + offset);
+        if (!page)
+                return NOPAGE_OOM;
+
+        get_page(page);
+        if (type)
+                *type = VM_FAULT_MINOR;
+        return page;
+}
+
+int fb_deferred_io_fsync(struct file *file, struct dentry *dentry, int datasync)
+{
+        struct fb_info *info = file->private_data;
+
+        /* Kill off the delayed work */
+        cancel_rearming_delayed_work(&info->deferred_work);
+
+        /* Run it immediately */
+        return schedule_delayed_work(&info->deferred_work, 0);
+}
+EXPORT_SYMBOL_GPL(fb_deferred_io_fsync);
+
+/* vm_ops->page_mkwrite handler */
+static int fb_deferred_io_mkwrite(struct vm_area_struct *vma,
+                                  struct page *page)
+{
+        struct fb_info *info = vma->vm_private_data;
+        struct fb_deferred_io *fbdefio = info->fbdefio;
+
+        /* this is a callback we get when userspace first tries to
+        write to the page. we schedule a workqueue. that workqueue
+        will eventually mkclean the touched pages and execute the
+        deferred framebuffer IO. then if userspace touches a page
+        again, we repeat the same scheme */
+
+        /* protect against the workqueue changing the page list */
+        mutex_lock(&fbdefio->lock);
+        list_add(&page->lru, &fbdefio->pagelist);
+        mutex_unlock(&fbdefio->lock);
+
+        /* come back after delay to process the deferred IO */
+        schedule_delayed_work(&info->deferred_work, fbdefio->delay);
+        return 0;
+}
+
+static struct vm_operations_struct fb_deferred_io_vm_ops = {
+        .nopage         = fb_deferred_io_nopage,
+        .page_mkwrite   = fb_deferred_io_mkwrite,
+};
+
+static int fb_deferred_io_mmap(struct fb_info *info, struct vm_area_struct *vma)
+{
+        vma->vm_ops = &fb_deferred_io_vm_ops;
+        vma->vm_flags |= ( VM_IO | VM_RESERVED | VM_DONTEXPAND );
+        vma->vm_private_data = info;
+        return 0;
+}
+
+/* workqueue callback */
+static void fb_deferred_io_work(struct work_struct *work)
+{
+        struct fb_info *info = container_of(work, struct fb_info,
+                                                deferred_work.work);
+        struct list_head *node, *next;
+        struct page *cur;
+        struct fb_deferred_io *fbdefio = info->fbdefio;
+
+        /* here we mkclean the pages, then do all deferred IO */
+        mutex_lock(&fbdefio->lock);
+        list_for_each_entry(cur, &fbdefio->pagelist, lru) {
+                lock_page(cur);
+                page_mkclean(cur);
+                unlock_page(cur);
+        }
+
+        /* driver's callback with pagelist */
+        fbdefio->deferred_io(info, &fbdefio->pagelist);
+
+        /* clear the list */
+        list_for_each_safe(node, next, &fbdefio->pagelist) {
+                list_del(node);
+        }
+        mutex_unlock(&fbdefio->lock);
+}
+
+void fb_deferred_io_init(struct fb_info *info)
+{
+        struct fb_deferred_io *fbdefio = info->fbdefio;
+
+        BUG_ON(!fbdefio);
+        mutex_init(&fbdefio->lock);
+        info->fbops->fb_mmap = fb_deferred_io_mmap;
+        INIT_DELAYED_WORK(&info->deferred_work, fb_deferred_io_work);
+        INIT_LIST_HEAD(&fbdefio->pagelist);
+        if (fbdefio->delay == 0) /* set a default of 1 s */
+                fbdefio->delay = HZ;
+}
+EXPORT_SYMBOL_GPL(fb_deferred_io_init);
+
+void fb_deferred_io_cleanup(struct fb_info *info)
+{
+        struct fb_deferred_io *fbdefio = info->fbdefio;
+
+        BUG_ON(!fbdefio);
+        cancel_delayed_work(&info->deferred_work);
+        flush_scheduled_work();
+}
+EXPORT_SYMBOL_GPL(fb_deferred_io_cleanup);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/fb_draw.h b/drivers/video/fb_draw.h
new file mode 100644
index 000000000000..c5c45203833b
--- /dev/null
+++ b/drivers/video/fb_draw.h
@@ -0,0 +1,72 @@
+#ifndef _FB_DRAW_H
+#define _FB_DRAW_H
+
+#include <asm/types.h>
+
+    /*
+     *  Compose two values, using a bitmask as decision value
+     *  This is equivalent to (a & mask) | (b & ~mask)
+     */
+
+static inline unsigned long
+comp(unsigned long a, unsigned long b, unsigned long mask)
+{
+    return ((a ^ b) & mask) ^ b;
+}
+
+    /*
+     *  Create a pattern with the given pixel's color
+     */
+
+#if BITS_PER_LONG == 64
+static inline unsigned long
+pixel_to_pat( u32 bpp, u32 pixel)
+{
+        switch (bpp) {
+        case 1:
+                return 0xfffffffffffffffful*pixel;
+        case 2:
+                return 0x5555555555555555ul*pixel;
+        case 4:
+                return 0x1111111111111111ul*pixel;
+        case 8:
+                return 0x0101010101010101ul*pixel;
+        case 12:
+                return 0x0001001001001001ul*pixel;
+        case 16:
+                return 0x0001000100010001ul*pixel;
+        case 24:
+                return 0x0000000001000001ul*pixel;
+        case 32:
+                return 0x0000000100000001ul*pixel;
+        default:
+                panic("pixel_to_pat(): unsupported pixelformat\n");
+    }
+}
+#else
+static inline unsigned long
+pixel_to_pat( u32 bpp, u32 pixel)
+{
+        switch (bpp) {
+        case 1:
+                return 0xfffffffful*pixel;
+        case 2:
+                return 0x55555555ul*pixel;
+        case 4:
+                return 0x11111111ul*pixel;
+        case 8:
+                return 0x01010101ul*pixel;
+        case 12:
+                return 0x00001001ul*pixel;
+        case 16:
+                return 0x00010001ul*pixel;
+        case 24:
+                return 0x00000001ul*pixel;
+        case 32:
+                return 0x00000001ul*pixel;
+        default:
+                panic("pixel_to_pat(): unsupported pixelformat\n");
+    }
+}
+#endif
+#endif /* FB_DRAW_H */
diff --git a/drivers/video/fb_sys_fops.c b/drivers/video/fb_sys_fops.c
new file mode 100644
index 000000000000..cf2538d669cd
--- /dev/null
+++ b/drivers/video/fb_sys_fops.c
@@ -0,0 +1,104 @@
+/*
+ * linux/drivers/video/fb_sys_read.c - Generic file operations where
+ * framebuffer is in system RAM
+ *
+ * Copyright (C) 2007 Antonino Daplas <adaplas@pol.net>
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive
+ * for more details.
+ *
+ */
+#include <linux/fb.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+ssize_t fb_sys_read(struct fb_info *info, char __user *buf, size_t count,
+                    loff_t *ppos)
+{
+        unsigned long p = *ppos;
+        void *src;
+        int err = 0;
+        unsigned long total_size;
+
+        if (info->state != FBINFO_STATE_RUNNING)
+                return -EPERM;
+
+        total_size = info->screen_size;
+
+        if (total_size == 0)
+                total_size = info->fix.smem_len;
+
+        if (p >= total_size)
+                return 0;
+
+        if (count >= total_size)
+                count = total_size;
+
+        if (count + p > total_size)
+                count = total_size - p;
+
+        src = (void __force *)(info->screen_base + p);
+
+        if (info->fbops->fb_sync)
+                info->fbops->fb_sync(info);
+
+        if (copy_to_user(buf, src, count))
+                err = -EFAULT;
+
+        if  (!err)
+                *ppos += count;
+
+        return (err) ? err : count;
+}
+EXPORT_SYMBOL_GPL(fb_sys_read);
+
+ssize_t fb_sys_write(struct fb_info *info, const char __user *buf,
+                     size_t count, loff_t *ppos)
+{
+        unsigned long p = *ppos;
+        void *dst;
+        int err = 0;
+        unsigned long total_size;
+
+        if (info->state != FBINFO_STATE_RUNNING)
+                return -EPERM;
+
+        total_size = info->screen_size;
+
+        if (total_size == 0)
+                total_size = info->fix.smem_len;
+
+        if (p > total_size)
+                return -EFBIG;
+
+        if (count > total_size) {
+                err = -EFBIG;
+                count = total_size;
+        }
+
+        if (count + p > total_size) {
+                if (!err)
+                        err = -ENOSPC;
+
+                count = total_size - p;
+        }
+
+        dst = (void __force *) (info->screen_base + p);
+
+        if (info->fbops->fb_sync)
+                info->fbops->fb_sync(info);
+
+        if (copy_from_user(dst, buf, count))
+                err = -EFAULT;
+
+        if  (!err)
+                *ppos += count;
+
+        return (err) ? err : count;
+}
+EXPORT_SYMBOL_GPL(fb_sys_write);
+
+MODULE_AUTHOR("Antonino Daplas <adaplas@pol.net>");
+MODULE_DESCRIPTION("Generic file read (fb in system RAM)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 28225265159a..08d4e11d9121 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -354,59 +354,59 @@ static void fb_rotate_logo(struct fb_info *info, u8 *dst,
         if (rotate == FB_ROTATE_UD) {
                 fb_rotate_logo_ud(image->data, dst, image->width,
                                   image->height);
-                image->dx = info->var.xres - image->width;
-                image->dy = info->var.yres - image->height;
+                image->dx = info->var.xres - image->width - image->dx;
+                image->dy = info->var.yres - image->height - image->dy;
         } else if (rotate == FB_ROTATE_CW) {
                 fb_rotate_logo_cw(image->data, dst, image->width,
                                   image->height);
                 tmp = image->width;
                 image->width = image->height;
                 image->height = tmp;
-                image->dx = info->var.xres - image->width;
+                tmp = image->dy;
+                image->dy = image->dx;
+                image->dx = info->var.xres - image->width - tmp;
         } else if (rotate == FB_ROTATE_CCW) {
                 fb_rotate_logo_ccw(image->data, dst, image->width,
                                    image->height);
                 tmp = image->width;
                 image->width = image->height;
                 image->height = tmp;
-                image->dy = info->var.yres - image->height;
+                tmp = image->dx;
+                image->dx = image->dy;
+                image->dy = info->var.yres - image->height - tmp;
         }
 
         image->data = dst;
 }
 
 static void fb_do_show_logo(struct fb_info *info, struct fb_image *image,
-                            int rotate)
+                            int rotate, unsigned int num)
 {
-        int x;
+        unsigned int x;
 
         if (rotate == FB_ROTATE_UR) {
-                for (x = 0; x < num_online_cpus() &&
-                             x * (fb_logo.logo->width + 8) <=
-                             info->var.xres - fb_logo.logo->width; x++) {
+                for (x = 0;
+                     x < num && image->dx + image->width <= info->var.xres;
+                     x++) {
                         info->fbops->fb_imageblit(info, image);
-                        image->dx += fb_logo.logo->width + 8;
+                        image->dx += image->width + 8;
                 }
         } else if (rotate == FB_ROTATE_UD) {
-                for (x = 0; x < num_online_cpus() &&
-                             x * (fb_logo.logo->width + 8) <=
-                             info->var.xres - fb_logo.logo->width; x++) {
+                for (x = 0; x < num && image->dx >= 0; x++) {
                         info->fbops->fb_imageblit(info, image);
-                        image->dx -= fb_logo.logo->width + 8;
+                        image->dx -= image->width + 8;
                 }
         } else if (rotate == FB_ROTATE_CW) {
-                for (x = 0; x < num_online_cpus() &&
-                             x * (fb_logo.logo->width + 8) <=
-                             info->var.yres - fb_logo.logo->width; x++) {
+                for (x = 0;
+                     x < num && image->dy + image->height <= info->var.yres;
+                     x++) {
                         info->fbops->fb_imageblit(info, image);
-                        image->dy += fb_logo.logo->width + 8;
+                        image->dy += image->height + 8;
                 }
         } else if (rotate == FB_ROTATE_CCW) {
-                for (x = 0; x < num_online_cpus() &&
-                             x * (fb_logo.logo->width + 8) <=
-                             info->var.yres - fb_logo.logo->width; x++) {
+                for (x = 0; x < num && image->dy >= 0; x++) {
                         info->fbops->fb_imageblit(info, image);
-                        image->dy -= fb_logo.logo->width + 8;
+                        image->dy -= image->height + 8;
                 }
         }
 }
@@ -418,7 +418,8 @@ int fb_prepare_logo(struct fb_info *info, int rotate)
 
         memset(&fb_logo, 0, sizeof(struct logo_data));
 
-        if (info->flags & FBINFO_MISC_TILEBLITTING)
+        if (info->flags & FBINFO_MISC_TILEBLITTING ||
+            info->flags & FBINFO_MODULE)
                 return 0;
 
         if (info->fix.visual == FB_VISUAL_DIRECTCOLOR) {
@@ -483,7 +484,8 @@ int fb_show_logo(struct fb_info *info, int rotate)
         struct fb_image image;
 
         /* Return if the frame buffer is not mapped or suspended */
-        if (fb_logo.logo == NULL || info->state != FBINFO_STATE_RUNNING)
+        if (fb_logo.logo == NULL || info->state != FBINFO_STATE_RUNNING ||
+            info->flags & FBINFO_MODULE)
                 return 0;
 
         image.depth = 8;
@@ -532,7 +534,7 @@ int fb_show_logo(struct fb_info *info, int rotate)
                         fb_rotate_logo(info, logo_rotate, &image, rotate);
         }
 
-        fb_do_show_logo(info, &image, rotate);
+        fb_do_show_logo(info, &image, rotate, num_online_cpus());
 
         kfree(palette);
         if (saved_pseudo_palette != NULL)
@@ -586,7 +588,7 @@ fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
                 return -EPERM;
 
         if (info->fbops->fb_read)
-                return info->fbops->fb_read(file, buf, count, ppos);
+                return info->fbops->fb_read(info, buf, count, ppos);
         
         total_size = info->screen_size;
 
@@ -661,7 +663,7 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
                 return -EPERM;
 
         if (info->fbops->fb_write)
-                return info->fbops->fb_write(file, buf, count, ppos);
+                return info->fbops->fb_write(info, buf, count, ppos);
         
         total_size = info->screen_size;
 
@@ -771,14 +773,37 @@ fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var)
         return 0;
 }
 
+static int fb_check_caps(struct fb_info *info, struct fb_var_screeninfo *var,
+                         u32 activate)
+{
+        struct fb_event event;
+        struct fb_blit_caps caps, fbcaps;
+        int err = 0;
+
+        memset(&caps, 0, sizeof(caps));
+        memset(&fbcaps, 0, sizeof(fbcaps));
+        caps.flags = (activate & FB_ACTIVATE_ALL) ? 1 : 0;
+        event.info = info;
+        event.data = &caps;
+        fb_notifier_call_chain(FB_EVENT_GET_REQ, &event);
+        info->fbops->fb_get_caps(info, &fbcaps, var);
+
+        if (((fbcaps.x ^ caps.x) & caps.x) ||
+            ((fbcaps.y ^ caps.y) & caps.y) ||
+            (fbcaps.len < caps.len))
+                err = -EINVAL;
+
+        return err;
+}
+
 int
 fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
 {
-        int err, flags = info->flags;
+        int flags = info->flags;
+        int ret = 0;
 
         if (var->activate & FB_ACTIVATE_INV_MODE) {
                 struct fb_videomode mode1, mode2;
-                int ret = 0;
 
                 fb_var_to_videomode(&mode1, var);
                 fb_var_to_videomode(&mode2, &info->var);
@@ -796,40 +821,51 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
                 if (!ret)
                     fb_delete_videomode(&mode1, &info->modelist);
 
-                return ret;
+
+                ret = (ret) ? -EINVAL : 0;
+                goto done;
         }
 
         if ((var->activate & FB_ACTIVATE_FORCE) ||
             memcmp(&info->var, var, sizeof(struct fb_var_screeninfo))) {
+                u32 activate = var->activate;
+
                 if (!info->fbops->fb_check_var) {
                         *var = info->var;
-                        return 0;
+                        goto done;
                 }
 
-                if ((err = info->fbops->fb_check_var(var, info)))
-                        return err;
+                ret = info->fbops->fb_check_var(var, info);
+
+                if (ret)
+                        goto done;
 
                 if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
                         struct fb_videomode mode;
-                        int err = 0;
+
+                        if (info->fbops->fb_get_caps) {
+                                ret = fb_check_caps(info, var, activate);
+
+                                if (ret)
+                                        goto done;
+                        }
 
                         info->var = *var;
+
                         if (info->fbops->fb_set_par)
                                 info->fbops->fb_set_par(info);
 
                         fb_pan_display(info, &info->var);
-
                         fb_set_cmap(&info->cmap, info);
-
                         fb_var_to_videomode(&mode, &info->var);
 
                         if (info->modelist.prev && info->modelist.next &&
                             !list_empty(&info->modelist))
-                                err = fb_add_videomode(&mode, &info->modelist);
+                                ret = fb_add_videomode(&mode, &info->modelist);
 
-                        if (!err && (flags & FBINFO_MISC_USEREVENT)) {
+                        if (!ret && (flags & FBINFO_MISC_USEREVENT)) {
                                 struct fb_event event;
-                                int evnt = (var->activate & FB_ACTIVATE_ALL) ?
+                                int evnt = (activate & FB_ACTIVATE_ALL) ?
                                         FB_EVENT_MODE_CHANGE_ALL :
                                         FB_EVENT_MODE_CHANGE;
 
@@ -839,7 +875,9 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
                         }
                 }
         }
-        return 0;
+
+ done:
+        return ret;
 }
 
 int
@@ -1266,6 +1304,9 @@ static const struct file_operations fb_fops = {
 #ifdef HAVE_ARCH_FB_UNMAPPED_AREA
         .get_unmapped_area = get_fb_unmapped_area,
 #endif
+#ifdef CONFIG_FB_DEFERRED_IO
+        .fsync =        fb_deferred_io_fsync,
+#endif
 };
 
 struct class *fb_class;
@@ -1316,6 +1357,12 @@ register_framebuffer(struct fb_info *fb_info)
         }       
         fb_info->pixmap.offset = 0;
 
+        if (!fb_info->pixmap.blit_x)
+                fb_info->pixmap.blit_x = ~(u32)0;
+
+        if (!fb_info->pixmap.blit_y)
+                fb_info->pixmap.blit_y = ~(u32)0;
+
         if (!fb_info->modelist.prev || !fb_info->modelist.next)
                 INIT_LIST_HEAD(&fb_info->modelist);
 
diff --git a/drivers/video/fbmon.c b/drivers/video/fbmon.c
index 6b385c39b8b5..438b9411905c 100644
--- a/drivers/video/fbmon.c
+++ b/drivers/video/fbmon.c
@@ -48,8 +48,9 @@
 #define DPRINTK(fmt, args...)
 #endif
 
-#define FBMON_FIX_HEADER 1
-#define FBMON_FIX_INPUT  2
+#define FBMON_FIX_HEADER  1
+#define FBMON_FIX_INPUT   2
+#define FBMON_FIX_TIMINGS 3
 
 #ifdef CONFIG_FB_MODE_HELPERS
 struct broken_edid {
@@ -71,6 +72,12 @@ static const struct broken_edid brokendb[] = {
                 .model        = 0x5a44,
                 .fix          = FBMON_FIX_INPUT,
         },
+        /* Sharp UXGA? */
+        {
+                .manufacturer = "SHP",
+                .model        = 0x138e,
+                .fix          = FBMON_FIX_TIMINGS,
+        },
 };
 
 static const unsigned char edid_v1_header[] = { 0x00, 0xff, 0xff, 0xff,
@@ -87,6 +94,55 @@ static void copy_string(unsigned char *c, unsigned char *s)
   while (i-- && (*--s == 0x20)) *s = 0;
 }
 
+static int edid_is_serial_block(unsigned char *block)
+{
+        if ((block[0] == 0x00) && (block[1] == 0x00) &&
+            (block[2] == 0x00) && (block[3] == 0xff) &&
+            (block[4] == 0x00))
+                return 1;
+        else
+                return 0;
+}
+
+static int edid_is_ascii_block(unsigned char *block)
+{
+        if ((block[0] == 0x00) && (block[1] == 0x00) &&
+            (block[2] == 0x00) && (block[3] == 0xfe) &&
+            (block[4] == 0x00))
+                return 1;
+        else
+                return 0;
+}
+
+static int edid_is_limits_block(unsigned char *block)
+{
+        if ((block[0] == 0x00) && (block[1] == 0x00) &&
+            (block[2] == 0x00) && (block[3] == 0xfd) &&
+            (block[4] == 0x00))
+                return 1;
+        else
+                return 0;
+}
+
+static int edid_is_monitor_block(unsigned char *block)
+{
+        if ((block[0] == 0x00) && (block[1] == 0x00) &&
+            (block[2] == 0x00) && (block[3] == 0xfc) &&
+            (block[4] == 0x00))
+                return 1;
+        else
+                return 0;
+}
+
+static int edid_is_timing_block(unsigned char *block)
+{
+        if ((block[0] != 0x00) || (block[1] != 0x00) ||
+            (block[2] != 0x00) || (block[4] != 0x00))
+                return 1;
+        else
+                return 0;
+}
+
 static int check_edid(unsigned char *edid)
 {
         unsigned char *block = edid + ID_MANUFACTURER_NAME, manufacturer[4];
@@ -104,9 +160,6 @@ static int check_edid(unsigned char *edid)
         for (i = 0; i < ARRAY_SIZE(brokendb); i++) {
                 if (!strncmp(manufacturer, brokendb[i].manufacturer, 4) &&
                         brokendb[i].model == model) {
-                        printk("fbmon: The EDID Block of "
-                               "Manufacturer: %s Model: 0x%x is known to "
-                               "be broken,\n",  manufacturer, model);
                         fix = brokendb[i].fix;
                         break;
                 }
@@ -115,8 +168,10 @@ static int check_edid(unsigned char *edid)
         switch (fix) {
         case FBMON_FIX_HEADER:
                 for (i = 0; i < 8; i++) {
-                        if (edid[i] != edid_v1_header[i])
+                        if (edid[i] != edid_v1_header[i]) {
                                 ret = fix;
+                                break;
+                        }
                 }
                 break;
         case FBMON_FIX_INPUT:
@@ -126,14 +181,34 @@ static int check_edid(unsigned char *edid)
                 if (b[4] & 0x01 && b[0] & 0x80)
                         ret = fix;
                 break;
+        case FBMON_FIX_TIMINGS:
+                b = edid + DETAILED_TIMING_DESCRIPTIONS_START;
+                ret = fix;
+
+                for (i = 0; i < 4; i++) {
+                        if (edid_is_limits_block(b)) {
+                                ret = 0;
+                                break;
+                        }
+
+                        b += DETAILED_TIMING_DESCRIPTION_SIZE;
+                }
+
+                break;
         }
 
+        if (ret)
+                printk("fbmon: The EDID Block of "
+                       "Manufacturer: %s Model: 0x%x is known to "
+                       "be broken,\n",  manufacturer, model);
+
         return ret;
 }
 
 static void fix_edid(unsigned char *edid, int fix)
 {
-        unsigned char *b;
+        int i;
+        unsigned char *b, csum = 0;
 
         switch (fix) {
         case FBMON_FIX_HEADER:
@@ -145,6 +220,37 @@ static void fix_edid(unsigned char *edid, int fix)
                 b = edid + EDID_STRUCT_DISPLAY;
                 b[0] &= ~0x80;
                 edid[127] += 0x80;
+                break;
+        case FBMON_FIX_TIMINGS:
+                printk("fbmon: trying to fix monitor timings\n");
+                b = edid + DETAILED_TIMING_DESCRIPTIONS_START;
+                for (i = 0; i < 4; i++) {
+                        if (!(edid_is_serial_block(b) ||
+                              edid_is_ascii_block(b) ||
+                              edid_is_monitor_block(b) ||
+                              edid_is_timing_block(b))) {
+                                b[0] = 0x00;
+                                b[1] = 0x00;
+                                b[2] = 0x00;
+                                b[3] = 0xfd;
+                                b[4] = 0x00;
+                                b[5] = 60;   /* vfmin */
+                                b[6] = 60;   /* vfmax */
+                                b[7] = 30;   /* hfmin */
+                                b[8] = 75;   /* hfmax */
+                                b[9] = 17;   /* pixclock - 170 MHz*/
+                                b[10] = 0;   /* GTF */
+                                break;
+                        }
+
+                        b += DETAILED_TIMING_DESCRIPTION_SIZE;
+                }
+
+                for (i = 0; i < EDID_LENGTH - 1; i++)
+                        csum += edid[i];
+
+                edid[127] = 256 - csum;
+                break;
         }
 }
 
@@ -273,46 +379,6 @@ static void get_chroma(unsigned char *block, struct fb_monspecs *specs)
         DPRINTK("WhiteY:   0.%03d\n", specs->chroma.whitey);
 }
 
-static int edid_is_serial_block(unsigned char *block)
-{
-        if ((block[0] == 0x00) && (block[1] == 0x00) && 
-            (block[2] == 0x00) && (block[3] == 0xff) &&
-            (block[4] == 0x00))
-                return 1;
-        else
-                return 0;
-}
-
-static int edid_is_ascii_block(unsigned char *block)
-{
-        if ((block[0] == 0x00) && (block[1] == 0x00) && 
-            (block[2] == 0x00) && (block[3] == 0xfe) &&
-            (block[4] == 0x00))
-                return 1;
-        else
-                return 0;
-}
-
-static int edid_is_limits_block(unsigned char *block)
-{
-        if ((block[0] == 0x00) && (block[1] == 0x00) && 
-            (block[2] == 0x00) && (block[3] == 0xfd) &&
-            (block[4] == 0x00))
-                return 1;
-        else
-                return 0;
-}
-
-static int edid_is_monitor_block(unsigned char *block)
-{
-        if ((block[0] == 0x00) && (block[1] == 0x00) && 
-            (block[2] == 0x00) && (block[3] == 0xfc) &&
-            (block[4] == 0x00))
-                return 1;
-        else
-                return 0;
-}
-
 static void calc_mode_timings(int xres, int yres, int refresh,
                               struct fb_videomode *mode)
 {
@@ -795,15 +861,6 @@ static void get_monspecs(unsigned char *edid, struct fb_monspecs *specs)
         }
 }
 
-static int edid_is_timing_block(unsigned char *block)
-{
-        if ((block[0] != 0x00) || (block[1] != 0x00) ||
-            (block[2] != 0x00) || (block[4] != 0x00))
-                return 1;
-        else
-                return 0;
-}
-
 int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var)
 {
         int i;
diff --git a/drivers/video/fbsysfs.c b/drivers/video/fbsysfs.c
index 40c80c8190e2..d4a2c11d9809 100644
--- a/drivers/video/fbsysfs.c
+++ b/drivers/video/fbsysfs.c
@@ -376,7 +376,7 @@ static ssize_t show_pan(struct device *device,
 {
         struct fb_info *fb_info = dev_get_drvdata(device);
         return snprintf(buf, PAGE_SIZE, "%d,%d\n", fb_info->var.xoffset,
-                        fb_info->var.xoffset);
+                        fb_info->var.yoffset);
 }
 
 static ssize_t show_name(struct device *device,
diff --git a/drivers/video/hecubafb.c b/drivers/video/hecubafb.c
new file mode 100644
index 000000000000..abfcb50364c8
--- /dev/null
+++ b/drivers/video/hecubafb.c
@@ -0,0 +1,471 @@
+/*
+ * linux/drivers/video/hecubafb.c -- FB driver for Hecuba controller
+ *
+ * Copyright (C) 2006, Jaya Kumar
+ * This work was sponsored by CIS(M) Sdn Bhd
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of this archive for
+ * more details.
+ *
+ * Layout is based on skeletonfb.c by James Simmons and Geert Uytterhoeven.
+ * This work was possible because of apollo display code from E-Ink's website
+ * http://support.eink.com/community
+ * All information used to write this code is from public material made
+ * available by E-Ink on its support site. Some commands such as 0xA4
+ * were found by looping through cmd=0x00 thru 0xFF and supplying random
+ * values. There are other commands that the display is capable of,
+ * beyond the 5 used here but they are more complex.
+ *
+ * This driver is written to be used with the Hecuba display controller
+ * board, and tested with the EInk 800x600 display in 1 bit mode.
+ * The interface between Hecuba and the host is TTL based GPIO. The
+ * GPIO requirements are 8 writable data lines and 6 lines for control.
+ * Only 4 of the controls are actually used here but 6 for future use.
+ * The driver requires the IO addresses for data and control GPIO at
+ * load time. It is also possible to use this display with a standard
+ * PC parallel port.
+ *
+ * General notes:
+ * - User must set hecubafb_enable=1 to enable it
+ * - User must set dio_addr=0xIOADDR cio_addr=0xIOADDR c2io_addr=0xIOADDR
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/list.h>
+#include <asm/uaccess.h>
+
+/* Apollo controller specific defines */
+#define APOLLO_START_NEW_IMG    0xA0
+#define APOLLO_STOP_IMG_DATA    0xA1
+#define APOLLO_DISPLAY_IMG      0xA2
+#define APOLLO_ERASE_DISPLAY    0xA3
+#define APOLLO_INIT_DISPLAY     0xA4
+
+/* Hecuba interface specific defines */
+/* WUP is inverted, CD is inverted, DS is inverted */
+#define HCB_NWUP_BIT    0x01
+#define HCB_NDS_BIT     0x02
+#define HCB_RW_BIT      0x04
+#define HCB_NCD_BIT     0x08
+#define HCB_ACK_BIT     0x80
+
+/* Display specific information */
+#define DPY_W 600
+#define DPY_H 800
+
+struct hecubafb_par {
+        unsigned long dio_addr;
+        unsigned long cio_addr;
+        unsigned long c2io_addr;
+        unsigned char ctl;
+        struct fb_info *info;
+        unsigned int irq;
+};
+
+static struct fb_fix_screeninfo hecubafb_fix __devinitdata = {
+        .id =           "hecubafb",
+        .type =         FB_TYPE_PACKED_PIXELS,
+        .visual =       FB_VISUAL_MONO01,
+        .xpanstep =     0,
+        .ypanstep =     0,
+        .ywrapstep =    0,
+        .accel =        FB_ACCEL_NONE,
+};
+
+static struct fb_var_screeninfo hecubafb_var __devinitdata = {
+        .xres           = DPY_W,
+        .yres           = DPY_H,
+        .xres_virtual   = DPY_W,
+        .yres_virtual   = DPY_H,
+        .bits_per_pixel = 1,
+        .nonstd         = 1,
+};
+
+static unsigned long dio_addr;
+static unsigned long cio_addr;
+static unsigned long c2io_addr;
+static unsigned long splashval;
+static unsigned int nosplash;
+static unsigned int hecubafb_enable;
+static unsigned int irq;
+
+static DECLARE_WAIT_QUEUE_HEAD(hecubafb_waitq);
+
+static void hcb_set_ctl(struct hecubafb_par *par)
+{
+        outb(par->ctl, par->cio_addr);
+}
+
+static unsigned char hcb_get_ctl(struct hecubafb_par *par)
+{
+        return inb(par->c2io_addr);
+}
+
+static void hcb_set_data(struct hecubafb_par *par, unsigned char value)
+{
+        outb(value, par->dio_addr);
+}
+
+static int __devinit apollo_init_control(struct hecubafb_par *par)
+{
+        unsigned char ctl;
+        /* for init, we want the following setup to be set:
+        WUP = lo
+        ACK = hi
+        DS = hi
+        RW = hi
+        CD = lo
+        */
+
+        /* write WUP to lo, DS to hi, RW to hi, CD to lo */
+        par->ctl = HCB_NWUP_BIT | HCB_RW_BIT | HCB_NCD_BIT ;
+        par->ctl &= ~HCB_NDS_BIT;
+        hcb_set_ctl(par);
+
+        /* check ACK is not lo */
+        ctl = hcb_get_ctl(par);
+        if ((ctl & HCB_ACK_BIT)) {
+                printk(KERN_ERR "Fail because ACK is already low\n");
+                return -ENXIO;
+        }
+
+        return 0;
+}
+
+static void hcb_wait_for_ack(struct hecubafb_par *par)
+{
+
+        int timeout;
+        unsigned char ctl;
+
+        timeout=500;
+        do {
+                ctl = hcb_get_ctl(par);
+                if ((ctl & HCB_ACK_BIT))
+                        return;
+                udelay(1);
+        } while (timeout--);
+        printk(KERN_ERR "timed out waiting for ack\n");
+}
+
+static void hcb_wait_for_ack_clear(struct hecubafb_par *par)
+{
+
+        int timeout;
+        unsigned char ctl;
+
+        timeout=500;
+        do {
+                ctl = hcb_get_ctl(par);
+                if (!(ctl & HCB_ACK_BIT))
+                        return;
+                udelay(1);
+        } while (timeout--);
+        printk(KERN_ERR "timed out waiting for clear\n");
+}
+
+static void apollo_send_data(struct hecubafb_par *par, unsigned char data)
+{
+        /* set data */
+        hcb_set_data(par, data);
+
+        /* set DS low */
+        par->ctl |= HCB_NDS_BIT;
+        hcb_set_ctl(par);
+
+        hcb_wait_for_ack(par);
+
+        /* set DS hi */
+        par->ctl &= ~(HCB_NDS_BIT);
+        hcb_set_ctl(par);
+
+        hcb_wait_for_ack_clear(par);
+}
+
+static void apollo_send_command(struct hecubafb_par *par, unsigned char data)
+{
+        /* command so set CD to high */
+        par->ctl &= ~(HCB_NCD_BIT);
+        hcb_set_ctl(par);
+
+        /* actually strobe with command */
+        apollo_send_data(par, data);
+
+        /* clear CD back to low */
+        par->ctl |= (HCB_NCD_BIT);
+        hcb_set_ctl(par);
+}
+
+/* main hecubafb functions */
+
+static void hecubafb_dpy_update(struct hecubafb_par *par)
+{
+        int i;
+        unsigned char *buf = (unsigned char __force *)par->info->screen_base;
+
+        apollo_send_command(par, 0xA0);
+
+        for (i=0; i < (DPY_W*DPY_H/8); i++) {
+                apollo_send_data(par, *(buf++));
+        }
+
+        apollo_send_command(par, 0xA1);
+        apollo_send_command(par, 0xA2);
+}
+
+/* this is called back from the deferred io workqueue */
+static void hecubafb_dpy_deferred_io(struct fb_info *info,
+                                struct list_head *pagelist)
+{
+        hecubafb_dpy_update(info->par);
+}
+
+static void hecubafb_fillrect(struct fb_info *info,
+                                   const struct fb_fillrect *rect)
+{
+        struct hecubafb_par *par = info->par;
+
+        sys_fillrect(info, rect);
+
+        hecubafb_dpy_update(par);
+}
+
+static void hecubafb_copyarea(struct fb_info *info,
+                                   const struct fb_copyarea *area)
+{
+        struct hecubafb_par *par = info->par;
+
+        sys_copyarea(info, area);
+
+        hecubafb_dpy_update(par);
+}
+
+static void hecubafb_imageblit(struct fb_info *info,
+                                const struct fb_image *image)
+{
+        struct hecubafb_par *par = info->par;
+
+        sys_imageblit(info, image);
+
+        hecubafb_dpy_update(par);
+}
+
+/*
+ * this is the slow path from userspace. they can seek and write to
+ * the fb. it's inefficient to do anything less than a full screen draw
+ */
+static ssize_t hecubafb_write(struct fb_info *info, const char __user *buf,
+                                size_t count, loff_t *ppos)
+{
+        unsigned long p;
+        int err=-EINVAL;
+        struct hecubafb_par *par;
+        unsigned int xres;
+        unsigned int fbmemlength;
+
+        p = *ppos;
+        par = info->par;
+        xres = info->var.xres;
+        fbmemlength = (xres * info->var.yres)/8;
+
+        if (p > fbmemlength)
+                return -ENOSPC;
+
+        err = 0;
+        if ((count + p) > fbmemlength) {
+                count = fbmemlength - p;
+                err = -ENOSPC;
+        }
+
+        if (count) {
+                char *base_addr;
+
+                base_addr = (char __force *)info->screen_base;
+                count -= copy_from_user(base_addr + p, buf, count);
+                *ppos += count;
+                err = -EFAULT;
+        }
+
+        hecubafb_dpy_update(par);
+
+        if (count)
+                return count;
+
+        return err;
+}
+
+static struct fb_ops hecubafb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_read        = fb_sys_read,
+        .fb_write       = hecubafb_write,
+        .fb_fillrect    = hecubafb_fillrect,
+        .fb_copyarea    = hecubafb_copyarea,
+        .fb_imageblit   = hecubafb_imageblit,
+};
+
+static struct fb_deferred_io hecubafb_defio = {
+        .delay          = HZ,
+        .deferred_io    = hecubafb_dpy_deferred_io,
+};
+
+static int __devinit hecubafb_probe(struct platform_device *dev)
+{
+        struct fb_info *info;
+        int retval = -ENOMEM;
+        int videomemorysize;
+        unsigned char *videomemory;
+        struct hecubafb_par *par;
+
+        videomemorysize = (DPY_W*DPY_H)/8;
+
+        if (!(videomemory = vmalloc(videomemorysize)))
+                return retval;
+
+        memset(videomemory, 0, videomemorysize);
+
+        info = framebuffer_alloc(sizeof(struct hecubafb_par), &dev->dev);
+        if (!info)
+                goto err;
+
+        info->screen_base = (char __iomem *) videomemory;
+        info->fbops = &hecubafb_ops;
+
+        info->var = hecubafb_var;
+        info->fix = hecubafb_fix;
+        info->fix.smem_len = videomemorysize;
+        par = info->par;
+        par->info = info;
+
+        if (!dio_addr || !cio_addr || !c2io_addr) {
+                printk(KERN_WARNING "no IO addresses supplied\n");
+                goto err1;
+        }
+        par->dio_addr = dio_addr;
+        par->cio_addr = cio_addr;
+        par->c2io_addr = c2io_addr;
+        info->flags = FBINFO_FLAG_DEFAULT;
+
+        info->fbdefio = &hecubafb_defio;
+        fb_deferred_io_init(info);
+
+        retval = register_framebuffer(info);
+        if (retval < 0)
+                goto err1;
+        platform_set_drvdata(dev, info);
+
+        printk(KERN_INFO
+               "fb%d: Hecuba frame buffer device, using %dK of video memory\n",
+               info->node, videomemorysize >> 10);
+
+        /* this inits the dpy */
+        apollo_init_control(par);
+
+        apollo_send_command(par, APOLLO_INIT_DISPLAY);
+        apollo_send_data(par, 0x81);
+
+        /* have to wait while display resets */
+        udelay(1000);
+
+        /* if we were told to splash the screen, we just clear it */
+        if (!nosplash) {
+                apollo_send_command(par, APOLLO_ERASE_DISPLAY);
+                apollo_send_data(par, splashval);
+        }
+
+        return 0;
+err1:
+        framebuffer_release(info);
+err:
+        vfree(videomemory);
+        return retval;
+}
+
+static int __devexit hecubafb_remove(struct platform_device *dev)
+{
+        struct fb_info *info = platform_get_drvdata(dev);
+
+        if (info) {
+                fb_deferred_io_cleanup(info);
+                unregister_framebuffer(info);
+                vfree((void __force *)info->screen_base);
+                framebuffer_release(info);
+        }
+        return 0;
+}
+
+static struct platform_driver hecubafb_driver = {
+        .probe  = hecubafb_probe,
+        .remove = hecubafb_remove,
+        .driver = {
+                .name   = "hecubafb",
+        },
+};
+
+static struct platform_device *hecubafb_device;
+
+static int __init hecubafb_init(void)
+{
+        int ret;
+
+        if (!hecubafb_enable) {
+                printk(KERN_ERR "Use hecubafb_enable to enable the device\n");
+                return -ENXIO;
+        }
+
+        ret = platform_driver_register(&hecubafb_driver);
+        if (!ret) {
+                hecubafb_device = platform_device_alloc("hecubafb", 0);
+                if (hecubafb_device)
+                        ret = platform_device_add(hecubafb_device);
+                else
+                        ret = -ENOMEM;
+
+                if (ret) {
+                        platform_device_put(hecubafb_device);
+                        platform_driver_unregister(&hecubafb_driver);
+                }
+        }
+        return ret;
+
+}
+
+static void __exit hecubafb_exit(void)
+{
+        platform_device_unregister(hecubafb_device);
+        platform_driver_unregister(&hecubafb_driver);
+}
+
+module_param(nosplash, uint, 0);
+MODULE_PARM_DESC(nosplash, "Disable doing the splash screen");
+module_param(hecubafb_enable, uint, 0);
+MODULE_PARM_DESC(hecubafb_enable, "Enable communication with Hecuba board");
+module_param(dio_addr, ulong, 0);
+MODULE_PARM_DESC(dio_addr, "IO address for data, eg: 0x480");
+module_param(cio_addr, ulong, 0);
+MODULE_PARM_DESC(cio_addr, "IO address for control, eg: 0x400");
+module_param(c2io_addr, ulong, 0);
+MODULE_PARM_DESC(c2io_addr, "IO address for secondary control, eg: 0x408");
+module_param(splashval, ulong, 0);
+MODULE_PARM_DESC(splashval, "Splash pattern: 0x00 is black, 0x01 is white");
+module_param(irq, uint, 0);
+MODULE_PARM_DESC(irq, "IRQ for the Hecuba board");
+
+module_init(hecubafb_init);
+module_exit(hecubafb_exit);
+
+MODULE_DESCRIPTION("fbdev driver for Hecuba board");
+MODULE_AUTHOR("Jaya Kumar");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/i810/i810.h b/drivers/video/i810/i810.h
index aa65ffce915b..889e4ea5edc1 100644
--- a/drivers/video/i810/i810.h
+++ b/drivers/video/i810/i810.h
@@ -133,7 +133,7 @@
 /* Masks (AND ops) and OR's */
 #define FB_START_MASK               (0x3f << (32 - 6))
 #define MMIO_ADDR_MASK              (0x1FFF << (32 - 13))
-#define FREQ_MASK                   0x1EF
+#define FREQ_MASK                   (1 << 4)
 #define SCR_OFF                     0x20
 #define DRAM_ON                     0x08            
 #define DRAM_OFF                    0xE7
diff --git a/drivers/video/intelfb/intelfbhw.c b/drivers/video/intelfb/intelfbhw.c
index c1eb18bf0883..16bc8d75e36e 100644
--- a/drivers/video/intelfb/intelfbhw.c
+++ b/drivers/video/intelfb/intelfbhw.c
@@ -1428,6 +1428,24 @@ static void refresh_ring(struct intelfb_info *dinfo);
 static void reset_state(struct intelfb_info *dinfo);
 static void do_flush(struct intelfb_info *dinfo);
 
+static  u32 get_ring_space(struct intelfb_info *dinfo)
+{
+        u32 ring_space;
+
+        if (dinfo->ring_tail >= dinfo->ring_head)
+                ring_space = dinfo->ring.size -
+                        (dinfo->ring_tail - dinfo->ring_head);
+        else
+                ring_space = dinfo->ring_head - dinfo->ring_tail;
+
+        if (ring_space > RING_MIN_FREE)
+                ring_space -= RING_MIN_FREE;
+        else
+                ring_space = 0;
+
+        return ring_space;
+}
+
 static int
 wait_ring(struct intelfb_info *dinfo, int n)
 {
@@ -1442,13 +1460,8 @@ wait_ring(struct intelfb_info *dinfo, int n)
         end = jiffies + (HZ * 3);
         while (dinfo->ring_space < n) {
                 dinfo->ring_head = INREG(PRI_RING_HEAD) & RING_HEAD_MASK;
-                if (dinfo->ring_tail + RING_MIN_FREE < dinfo->ring_head)
-                        dinfo->ring_space = dinfo->ring_head
-                                - (dinfo->ring_tail + RING_MIN_FREE);
-                else
-                        dinfo->ring_space = (dinfo->ring.size +
-                                             dinfo->ring_head)
-                                - (dinfo->ring_tail + RING_MIN_FREE);
+                dinfo->ring_space = get_ring_space(dinfo);
+
                 if (dinfo->ring_head != last_head) {
                         end = jiffies + (HZ * 3);
                         last_head = dinfo->ring_head;
@@ -1513,12 +1526,7 @@ refresh_ring(struct intelfb_info *dinfo)
 
         dinfo->ring_head = INREG(PRI_RING_HEAD) & RING_HEAD_MASK;
         dinfo->ring_tail = INREG(PRI_RING_TAIL) & RING_TAIL_MASK;
-        if (dinfo->ring_tail + RING_MIN_FREE < dinfo->ring_head)
-                dinfo->ring_space = dinfo->ring_head
-                        - (dinfo->ring_tail + RING_MIN_FREE);
-        else
-                dinfo->ring_space = (dinfo->ring.size + dinfo->ring_head)
-                        - (dinfo->ring_tail + RING_MIN_FREE);
+        dinfo->ring_space = get_ring_space(dinfo);
 }
 
 static void
diff --git a/drivers/video/logo/Kconfig b/drivers/video/logo/Kconfig
index f0e6512c87ff..9397bcef3018 100644
--- a/drivers/video/logo/Kconfig
+++ b/drivers/video/logo/Kconfig
@@ -2,73 +2,69 @@
 # Logo configuration
 #
 
-menu "Logo configuration"
-
-config LOGO
+menuconfig LOGO
         bool "Bootup logo"
         depends on FB || SGI_NEWPORT_CONSOLE
         help
           Enable and select frame buffer bootup logos.
 
+if LOGO
+
 config LOGO_LINUX_MONO
         bool "Standard black and white Linux logo"
-        depends on LOGO
         default y
 
 config LOGO_LINUX_VGA16
         bool "Standard 16-color Linux logo"
-        depends on LOGO
         default y
 
 config LOGO_LINUX_CLUT224
         bool "Standard 224-color Linux logo"
-        depends on LOGO
         default y
 
 config LOGO_DEC_CLUT224
         bool "224-color Digital Equipment Corporation Linux logo"
-        depends on LOGO && (MACH_DECSTATION || ALPHA)
+        depends on MACH_DECSTATION || ALPHA
         default y
 
 config LOGO_MAC_CLUT224
         bool "224-color Macintosh Linux logo"
-        depends on LOGO && MAC
+        depends on MAC
         default y
 
 config LOGO_PARISC_CLUT224
         bool "224-color PA-RISC Linux logo"
-        depends on LOGO && PARISC
+        depends on PARISC
         default y
 
 config LOGO_SGI_CLUT224
         bool "224-color SGI Linux logo"
-        depends on LOGO && (SGI_IP22 || SGI_IP27 || SGI_IP32 || X86_VISWS)
+        depends on SGI_IP22 || SGI_IP27 || SGI_IP32 || X86_VISWS
         default y
 
 config LOGO_SUN_CLUT224
         bool "224-color Sun Linux logo"
-        depends on LOGO && SPARC
+        depends on SPARC
         default y
 
 config LOGO_SUPERH_MONO
         bool "Black and white SuperH Linux logo"
-        depends on LOGO && SUPERH
+        depends on SUPERH
         default y
 
 config LOGO_SUPERH_VGA16
         bool "16-color SuperH Linux logo"
-        depends on LOGO && SUPERH
+        depends on SUPERH
         default y
 
 config LOGO_SUPERH_CLUT224
         bool "224-color SuperH Linux logo"
-        depends on LOGO && SUPERH
+        depends on SUPERH
         default y
 
 config LOGO_M32R_CLUT224
         bool "224-color M32R Linux logo"
-        depends on LOGO && M32R
+        depends on M32R
         default y
 
-endmenu
-
+endif # LOGO
diff --git a/drivers/video/modedb.c b/drivers/video/modedb.c
index 3e517940c5a5..3741ad729401 100644
--- a/drivers/video/modedb.c
+++ b/drivers/video/modedb.c
@@ -395,7 +395,7 @@ static int my_atoi(const char *name)
 
     for (;; name++) {
         switch (*name) {
-            case '0'...'9':
+            case '0' ... '9':
                 val = 10*val+(*name-'0');
                 break;
             default:
@@ -548,7 +548,7 @@ int fb_find_mode(struct fb_var_screeninfo *var,
                     } else
                         goto done;
                     break;
-                case '0'...'9':
+                case '0' ... '9':
                     break;
                 case 'M':
                     if (!yres_specified)
diff --git a/drivers/video/neofb.c b/drivers/video/neofb.c
index 395ccedde9a6..bd30aba242d0 100644
--- a/drivers/video/neofb.c
+++ b/drivers/video/neofb.c
@@ -665,6 +665,7 @@ neofb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
         var->red.msb_right = 0;
         var->green.msb_right = 0;
         var->blue.msb_right = 0;
+        var->transp.msb_right = 0;
 
         switch (var->bits_per_pixel) {
         case 8:         /* PSEUDOCOLOUR, 256 */
diff --git a/drivers/video/nvidia/nv_accel.c b/drivers/video/nvidia/nv_accel.c
index 9efb8a3854e2..fa4821c5572b 100644
--- a/drivers/video/nvidia/nv_accel.c
+++ b/drivers/video/nvidia/nv_accel.c
@@ -69,27 +69,38 @@ static const int NVCopyROP_PM[16] = {
         0x5A,                   /* invert */
 };
 
-static inline void NVFlush(struct nvidia_par *par)
+static inline void nvidiafb_safe_mode(struct fb_info *info)
 {
+        struct nvidia_par *par = info->par;
+
+        touch_softlockup_watchdog();
+        info->pixmap.scan_align = 1;
+        par->lockup = 1;
+}
+
+static inline void NVFlush(struct fb_info *info)
+{
+        struct nvidia_par *par = info->par;
         int count = 1000000000;
 
         while (--count && READ_GET(par) != par->dmaPut) ;
 
         if (!count) {
                 printk("nvidiafb: DMA Flush lockup\n");
-                par->lockup = 1;
+                nvidiafb_safe_mode(info);
         }
 }
 
-static inline void NVSync(struct nvidia_par *par)
+static inline void NVSync(struct fb_info *info)
 {
+        struct nvidia_par *par = info->par;
         int count = 1000000000;
 
         while (--count && NV_RD32(par->PGRAPH, 0x0700)) ;
 
         if (!count) {
                 printk("nvidiafb: DMA Sync lockup\n");
-                par->lockup = 1;
+                nvidiafb_safe_mode(info);
         }
 }
 
@@ -101,8 +112,9 @@ static void NVDmaKickoff(struct nvidia_par *par)
         }
 }
 
-static void NVDmaWait(struct nvidia_par *par, int size)
+static void NVDmaWait(struct fb_info *info, int size)
 {
+        struct nvidia_par *par = info->par;
         int dmaGet;
         int count = 1000000000, cnt;
         size++;
@@ -135,34 +147,38 @@ static void NVDmaWait(struct nvidia_par *par, int size)
         }
 
         if (!count) {
-                printk("DMA Wait Lockup\n");
-                par->lockup = 1;
+                printk("nvidiafb: DMA Wait Lockup\n");
+                nvidiafb_safe_mode(info);
         }
 }
 
-static void NVSetPattern(struct nvidia_par *par, u32 clr0, u32 clr1,
+static void NVSetPattern(struct fb_info *info, u32 clr0, u32 clr1,
                          u32 pat0, u32 pat1)
 {
-        NVDmaStart(par, PATTERN_COLOR_0, 4);
+        struct nvidia_par *par = info->par;
+
+        NVDmaStart(info, par, PATTERN_COLOR_0, 4);
         NVDmaNext(par, clr0);
         NVDmaNext(par, clr1);
         NVDmaNext(par, pat0);
         NVDmaNext(par, pat1);
 }
 
-static void NVSetRopSolid(struct nvidia_par *par, u32 rop, u32 planemask)
+static void NVSetRopSolid(struct fb_info *info, u32 rop, u32 planemask)
 {
+        struct nvidia_par *par = info->par;
+
         if (planemask != ~0) {
-                NVSetPattern(par, 0, planemask, ~0, ~0);
+                NVSetPattern(info, 0, planemask, ~0, ~0);
                 if (par->currentRop != (rop + 32)) {
-                        NVDmaStart(par, ROP_SET, 1);
+                        NVDmaStart(info, par, ROP_SET, 1);
                         NVDmaNext(par, NVCopyROP_PM[rop]);
                         par->currentRop = rop + 32;
                 }
         } else if (par->currentRop != rop) {
                 if (par->currentRop >= 16)
-                        NVSetPattern(par, ~0, ~0, ~0, ~0);
-                NVDmaStart(par, ROP_SET, 1);
+                        NVSetPattern(info, ~0, ~0, ~0, ~0);
+                NVDmaStart(info, par, ROP_SET, 1);
                 NVDmaNext(par, NVCopyROP[rop]);
                 par->currentRop = rop;
         }
@@ -175,7 +191,7 @@ static void NVSetClippingRectangle(struct fb_info *info, int x1, int y1,
         int h = y2 - y1 + 1;
         int w = x2 - x1 + 1;
 
-        NVDmaStart(par, CLIP_POINT, 2);
+        NVDmaStart(info, par, CLIP_POINT, 2);
         NVDmaNext(par, (y1 << 16) | x1);
         NVDmaNext(par, (h << 16) | w);
 }
@@ -237,23 +253,23 @@ void NVResetGraphics(struct fb_info *info)
                 break;
         }
 
-        NVDmaStart(par, SURFACE_FORMAT, 4);
+        NVDmaStart(info, par, SURFACE_FORMAT, 4);
         NVDmaNext(par, surfaceFormat);
         NVDmaNext(par, pitch | (pitch << 16));
         NVDmaNext(par, 0);
         NVDmaNext(par, 0);
 
-        NVDmaStart(par, PATTERN_FORMAT, 1);
+        NVDmaStart(info, par, PATTERN_FORMAT, 1);
         NVDmaNext(par, patternFormat);
 
-        NVDmaStart(par, RECT_FORMAT, 1);
+        NVDmaStart(info, par, RECT_FORMAT, 1);
         NVDmaNext(par, rectFormat);
 
-        NVDmaStart(par, LINE_FORMAT, 1);
+        NVDmaStart(info, par, LINE_FORMAT, 1);
         NVDmaNext(par, lineFormat);
 
         par->currentRop = ~0;   /* set to something invalid */
-        NVSetRopSolid(par, ROP_COPY, ~0);
+        NVSetRopSolid(info, ROP_COPY, ~0);
 
         NVSetClippingRectangle(info, 0, 0, info->var.xres_virtual,
                                info->var.yres_virtual);
@@ -269,10 +285,10 @@ int nvidiafb_sync(struct fb_info *info)
                 return 0;
 
         if (!par->lockup)
-                NVFlush(par);
+                NVFlush(info);
 
         if (!par->lockup)
-                NVSync(par);
+                NVSync(info);
 
         return 0;
 }
@@ -287,7 +303,7 @@ void nvidiafb_copyarea(struct fb_info *info, const struct fb_copyarea *region)
         if (par->lockup)
                 return cfb_copyarea(info, region);
 
-        NVDmaStart(par, BLIT_POINT_SRC, 3);
+        NVDmaStart(info, par, BLIT_POINT_SRC, 3);
         NVDmaNext(par, (region->sy << 16) | region->sx);
         NVDmaNext(par, (region->dy << 16) | region->dx);
         NVDmaNext(par, (region->height << 16) | region->width);
@@ -312,19 +328,19 @@ void nvidiafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
                 color = ((u32 *) info->pseudo_palette)[rect->color];
 
         if (rect->rop != ROP_COPY)
-                NVSetRopSolid(par, rect->rop, ~0);
+                NVSetRopSolid(info, rect->rop, ~0);
 
-        NVDmaStart(par, RECT_SOLID_COLOR, 1);
+        NVDmaStart(info, par, RECT_SOLID_COLOR, 1);
         NVDmaNext(par, color);
 
-        NVDmaStart(par, RECT_SOLID_RECTS(0), 2);
+        NVDmaStart(info, par, RECT_SOLID_RECTS(0), 2);
         NVDmaNext(par, (rect->dx << 16) | rect->dy);
         NVDmaNext(par, (rect->width << 16) | rect->height);
 
         NVDmaKickoff(par);
 
         if (rect->rop != ROP_COPY)
-                NVSetRopSolid(par, ROP_COPY, ~0);
+                NVSetRopSolid(info, ROP_COPY, ~0);
 }
 
 static void nvidiafb_mono_color_expand(struct fb_info *info,
@@ -346,7 +362,7 @@ static void nvidiafb_mono_color_expand(struct fb_info *info,
                 bg = ((u32 *) info->pseudo_palette)[image->bg_color] | mask;
         }
 
-        NVDmaStart(par, RECT_EXPAND_TWO_COLOR_CLIP, 7);
+        NVDmaStart(info, par, RECT_EXPAND_TWO_COLOR_CLIP, 7);
         NVDmaNext(par, (image->dy << 16) | (image->dx & 0xffff));
         NVDmaNext(par, ((image->dy + image->height) << 16) |
                   ((image->dx + image->width) & 0xffff));
@@ -357,7 +373,7 @@ static void nvidiafb_mono_color_expand(struct fb_info *info,
         NVDmaNext(par, (image->dy << 16) | (image->dx & 0xffff));
 
         while (dsize >= RECT_EXPAND_TWO_COLOR_DATA_MAX_DWORDS) {
-                NVDmaStart(par, RECT_EXPAND_TWO_COLOR_DATA(0),
+                NVDmaStart(info, par, RECT_EXPAND_TWO_COLOR_DATA(0),
                            RECT_EXPAND_TWO_COLOR_DATA_MAX_DWORDS);
 
                 for (j = RECT_EXPAND_TWO_COLOR_DATA_MAX_DWORDS; j--;) {
@@ -370,7 +386,7 @@ static void nvidiafb_mono_color_expand(struct fb_info *info,
         }
 
         if (dsize) {
-                NVDmaStart(par, RECT_EXPAND_TWO_COLOR_DATA(0), dsize);
+                NVDmaStart(info, par, RECT_EXPAND_TWO_COLOR_DATA(0), dsize);
 
                 for (j = dsize; j--;) {
                         tmp = data[k++];
diff --git a/drivers/video/nvidia/nv_hw.c b/drivers/video/nvidia/nv_hw.c
index ea426115c6f9..f297c7b14a41 100644
--- a/drivers/video/nvidia/nv_hw.c
+++ b/drivers/video/nvidia/nv_hw.c
@@ -686,7 +686,7 @@ static void nForceUpdateArbitrationSettings(unsigned VClk,
 
         if ((par->Chipset & 0x0FF0) == 0x01A0) {
                 unsigned int uMClkPostDiv;
-                dev = pci_find_slot(0, 3);
+                dev = pci_get_bus_and_slot(0, 3);
                 pci_read_config_dword(dev, 0x6C, &uMClkPostDiv);
                 uMClkPostDiv = (uMClkPostDiv >> 8) & 0xf;
 
@@ -694,11 +694,11 @@ static void nForceUpdateArbitrationSettings(unsigned VClk,
                         uMClkPostDiv = 4;
                 MClk = 400000 / uMClkPostDiv;
         } else {
-                dev = pci_find_slot(0, 5);
+                dev = pci_get_bus_and_slot(0, 5);
                 pci_read_config_dword(dev, 0x4c, &MClk);
                 MClk /= 1000;
         }
-
+        pci_dev_put(dev);
         pll = NV_RD32(par->PRAMDAC0, 0x0500);
         M = (pll >> 0) & 0xFF;
         N = (pll >> 8) & 0xFF;
@@ -707,19 +707,21 @@ static void nForceUpdateArbitrationSettings(unsigned VClk,
         sim_data.pix_bpp = (char)pixelDepth;
         sim_data.enable_video = 0;
         sim_data.enable_mp = 0;
-        pci_find_slot(0, 1);
+        dev = pci_get_bus_and_slot(0, 1);
         pci_read_config_dword(dev, 0x7C, &sim_data.memory_type);
+        pci_dev_put(dev);
         sim_data.memory_type = (sim_data.memory_type >> 12) & 1;
         sim_data.memory_width = 64;
 
-        dev = pci_find_slot(0, 3);
+        dev = pci_get_bus_and_slot(0, 3);
         pci_read_config_dword(dev, 0, &memctrl);
+        pci_dev_put(dev);
         memctrl >>= 16;
 
         if ((memctrl == 0x1A9) || (memctrl == 0x1AB) || (memctrl == 0x1ED)) {
                 int dimm[3];
 
-                pci_find_slot(0, 2);
+                dev = pci_get_bus_and_slot(0, 2);
                 pci_read_config_dword(dev, 0x40, &dimm[0]);
                 dimm[0] = (dimm[0] >> 8) & 0x4f;
                 pci_read_config_dword(dev, 0x44, &dimm[1]);
@@ -731,6 +733,7 @@ static void nForceUpdateArbitrationSettings(unsigned VClk,
                         printk("nvidiafb: your nForce DIMMs are not arranged "
                                "in optimal banks!\n");
                 }
+                pci_dev_put(dev);
         }
 
         sim_data.mem_latency = 3;
diff --git a/drivers/video/nvidia/nv_i2c.c b/drivers/video/nvidia/nv_i2c.c
index b8588973e400..afe4567e1ff4 100644
--- a/drivers/video/nvidia/nv_i2c.c
+++ b/drivers/video/nvidia/nv_i2c.c
@@ -30,16 +30,14 @@ static void nvidia_gpio_setscl(void *data, int state)
         struct nvidia_par *par = chan->par;
         u32 val;
 
-        VGA_WR08(par->PCIO, 0x3d4, chan->ddc_base + 1);
-        val = VGA_RD08(par->PCIO, 0x3d5) & 0xf0;
+        val = NVReadCrtc(par, chan->ddc_base + 1) & 0xf0;
 
         if (state)
                 val |= 0x20;
         else
                 val &= ~0x20;
 
-        VGA_WR08(par->PCIO, 0x3d4, chan->ddc_base + 1);
-        VGA_WR08(par->PCIO, 0x3d5, val | 0x1);
+        NVWriteCrtc(par, chan->ddc_base + 1, val | 0x01);
 }
 
 static void nvidia_gpio_setsda(void *data, int state)
@@ -48,16 +46,14 @@ static void nvidia_gpio_setsda(void *data, int state)
         struct nvidia_par *par = chan->par;
         u32 val;
 
-        VGA_WR08(par->PCIO, 0x3d4, chan->ddc_base + 1);
-        val = VGA_RD08(par->PCIO, 0x3d5) & 0xf0;
+        val = NVReadCrtc(par, chan->ddc_base + 1) & 0xf0;
 
         if (state)
                 val |= 0x10;
         else
                 val &= ~0x10;
 
-        VGA_WR08(par->PCIO, 0x3d4, chan->ddc_base + 1);
-        VGA_WR08(par->PCIO, 0x3d5, val | 0x1);
+        NVWriteCrtc(par, chan->ddc_base + 1, val | 0x01);
 }
 
 static int nvidia_gpio_getscl(void *data)
@@ -66,12 +62,9 @@ static int nvidia_gpio_getscl(void *data)
         struct nvidia_par *par = chan->par;
         u32 val = 0;
 
-        VGA_WR08(par->PCIO, 0x3d4, chan->ddc_base);
-        if (VGA_RD08(par->PCIO, 0x3d5) & 0x04)
+        if (NVReadCrtc(par, chan->ddc_base) & 0x04)
                 val = 1;
 
-        val = VGA_RD08(par->PCIO, 0x3d5);
-
         return val;
 }
 
@@ -81,20 +74,21 @@ static int nvidia_gpio_getsda(void *data)
         struct nvidia_par *par = chan->par;
         u32 val = 0;
 
-        VGA_WR08(par->PCIO, 0x3d4, chan->ddc_base);
-        if (VGA_RD08(par->PCIO, 0x3d5) & 0x08)
+        if (NVReadCrtc(par, chan->ddc_base) & 0x08)
                 val = 1;
 
         return val;
 }
 
-static int nvidia_setup_i2c_bus(struct nvidia_i2c_chan *chan, const char *name)
+static int nvidia_setup_i2c_bus(struct nvidia_i2c_chan *chan, const char *name,
+                                unsigned int i2c_class)
 {
         int rc;
 
         strcpy(chan->adapter.name, name);
         chan->adapter.owner = THIS_MODULE;
         chan->adapter.id = I2C_HW_B_NVIDIA;
+        chan->adapter.class = i2c_class;
         chan->adapter.algo_data = &chan->algo;
         chan->adapter.dev.parent = &chan->par->pci_dev->dev;
         chan->algo.setsda = nvidia_gpio_setsda;
@@ -127,83 +121,39 @@ static int nvidia_setup_i2c_bus(struct nvidia_i2c_chan *chan, const char *name)
 
 void nvidia_create_i2c_busses(struct nvidia_par *par)
 {
-        par->bus = 3;
-
         par->chan[0].par = par;
         par->chan[1].par = par;
         par->chan[2].par = par;
 
-        par->chan[0].ddc_base = 0x3e;
-        nvidia_setup_i2c_bus(&par->chan[0], "nvidia #0");
+        par->chan[0].ddc_base = 0x36;
+        nvidia_setup_i2c_bus(&par->chan[0], "nvidia #0", I2C_CLASS_HWMON);
 
-        par->chan[1].ddc_base = 0x36;
-        nvidia_setup_i2c_bus(&par->chan[1], "nvidia #1");
+        par->chan[1].ddc_base = 0x3e;
+        nvidia_setup_i2c_bus(&par->chan[1], "nvidia #1", 0);
 
         par->chan[2].ddc_base = 0x50;
-        nvidia_setup_i2c_bus(&par->chan[2], "nvidia #2");
+        nvidia_setup_i2c_bus(&par->chan[2], "nvidia #2", 0);
 }
 
 void nvidia_delete_i2c_busses(struct nvidia_par *par)
 {
-        if (par->chan[0].par)
-                i2c_del_adapter(&par->chan[0].adapter);
-        par->chan[0].par = NULL;
-
-        if (par->chan[1].par)
-                i2c_del_adapter(&par->chan[1].adapter);
-        par->chan[1].par = NULL;
-
-        if (par->chan[2].par)
-                i2c_del_adapter(&par->chan[2].adapter);
-        par->chan[2].par = NULL;
-
-}
+        int i;
 
-static u8 *nvidia_do_probe_i2c_edid(struct nvidia_i2c_chan *chan)
-{
-        u8 start = 0x0;
-        struct i2c_msg msgs[] = {
-                {
-                 .addr = 0x50,
-                 .len = 1,
-                 .buf = &start,
-                 }, {
-                     .addr = 0x50,
-                     .flags = I2C_M_RD,
-                     .len = EDID_LENGTH,
-                     },
-        };
-        u8 *buf;
-
-        if (!chan->par)
-                return NULL;
-
-        buf = kmalloc(EDID_LENGTH, GFP_KERNEL);
-        if (!buf) {
-                dev_warn(&chan->par->pci_dev->dev, "Out of memory!\n");
-                return NULL;
+        for (i = 0; i < 3; i++) {
+                if (!par->chan[i].par)
+                        continue;
+                i2c_del_adapter(&par->chan[i].adapter);
+                par->chan[i].par = NULL;
         }
-        msgs[1].buf = buf;
-
-        if (i2c_transfer(&chan->adapter, msgs, 2) == 2)
-                return buf;
-        dev_dbg(&chan->par->pci_dev->dev, "Unable to read EDID block.\n");
-        kfree(buf);
-        return NULL;
 }
 
 int nvidia_probe_i2c_connector(struct fb_info *info, int conn, u8 **out_edid)
 {
         struct nvidia_par *par = info->par;
         u8 *edid = NULL;
-        int i;
 
-        for (i = 0; i < 3; i++) {
-                /* Do the real work */
-                edid = nvidia_do_probe_i2c_edid(&par->chan[conn - 1]);
-                if (edid)
-                        break;
-        }
+        if (par->chan[conn - 1].par)
+                edid = fb_ddc_read(&par->chan[conn - 1].adapter);
 
         if (!edid && conn == 1) {
                 /* try to get from firmware */
diff --git a/drivers/video/nvidia/nv_local.h b/drivers/video/nvidia/nv_local.h
index e009d242ea10..68e508daa417 100644
--- a/drivers/video/nvidia/nv_local.h
+++ b/drivers/video/nvidia/nv_local.h
@@ -73,9 +73,9 @@
 #define NVDmaNext(par, data) \
      NV_WR32(&(par)->dmaBase[(par)->dmaCurrent++], 0, (data))
 
-#define NVDmaStart(par, tag, size) {          \
+#define NVDmaStart(info, par, tag, size) {    \
      if((par)->dmaFree <= (size))             \
-        NVDmaWait(par, size);                 \
+        NVDmaWait(info, size);                \
      NVDmaNext(par, ((size) << 18) | (tag));  \
      (par)->dmaFree -= ((size) + 1);          \
 }
diff --git a/drivers/video/nvidia/nv_setup.c b/drivers/video/nvidia/nv_setup.c
index eab3e282a4de..707e2c8a13ed 100644
--- a/drivers/video/nvidia/nv_setup.c
+++ b/drivers/video/nvidia/nv_setup.c
@@ -261,7 +261,7 @@ static void nv10GetConfig(struct nvidia_par *par)
         }
 #endif
 
-        dev = pci_find_slot(0, 1);
+        dev = pci_get_bus_and_slot(0, 1);
         if ((par->Chipset & 0xffff) == 0x01a0) {
                 int amt = 0;
 
@@ -276,6 +276,7 @@ static void nv10GetConfig(struct nvidia_par *par)
                 par->RamAmountKBytes =
                     (NV_RD32(par->PFB, 0x020C) & 0xFFF00000) >> 10;
         }
+        pci_dev_put(dev);
 
         par->CrystalFreqKHz = (NV_RD32(par->PEXTDEV, 0x0000) & (1 << 6)) ?
             14318 : 13500;
@@ -656,7 +657,7 @@ int NVCommonSetup(struct fb_info *info)
         par->LVDS = 0;
         if (par->FlatPanel && par->twoHeads) {
                 NV_WR32(par->PRAMDAC0, 0x08B0, 0x00010004);
-                if (par->PRAMDAC0[0x08b4] & 1)
+                if (NV_RD32(par->PRAMDAC0, 0x08b4) & 1)
                         par->LVDS = 1;
                 printk("nvidiafb: Panel is %s\n", par->LVDS ? "LVDS" : "TMDS");
         }
diff --git a/drivers/video/nvidia/nv_type.h b/drivers/video/nvidia/nv_type.h
index 86e65dea60d3..38f7cc0a2331 100644
--- a/drivers/video/nvidia/nv_type.h
+++ b/drivers/video/nvidia/nv_type.h
@@ -4,8 +4,9 @@
 #include <linux/fb.h>
 #include <linux/types.h>
 #include <linux/i2c.h>
-#include <linux/i2c-id.h>
 #include <linux/i2c-algo-bit.h>
+#include <linux/mutex.h>
+#include <video/vga.h>
 
 #define NV_ARCH_04  0x04
 #define NV_ARCH_10  0x10
@@ -94,13 +95,15 @@ struct riva_regs {
 struct nvidia_par {
         RIVA_HW_STATE SavedReg;
         RIVA_HW_STATE ModeReg;
+        RIVA_HW_STATE initial_state;
         RIVA_HW_STATE *CurrentState;
+        struct vgastate vgastate;
+        struct mutex open_lock;
         u32 pseudo_palette[16];
         struct pci_dev *pci_dev;
         u32 Architecture;
         u32 CursorStart;
         int Chipset;
-        int bus;
         unsigned long FbAddress;
         u8 __iomem *FbStart;
         u32 FbMapSize;
@@ -143,6 +146,7 @@ struct nvidia_par {
         int BlendingPossible;
         u32 paletteEnabled;
         u32 forceCRTC;
+        u32 open_count;
         u8 DDCBase;
 #ifdef CONFIG_MTRR
         struct {
diff --git a/drivers/video/nvidia/nvidia.c b/drivers/video/nvidia/nvidia.c
index b97ec6901263..7c36b5fe582e 100644
--- a/drivers/video/nvidia/nvidia.c
+++ b/drivers/video/nvidia/nvidia.c
@@ -200,7 +200,7 @@ static int nvidia_panel_tweak(struct nvidia_par *par,
    return tweak;
 }
 
-static void nvidia_vga_protect(struct nvidia_par *par, int on)
+static void nvidia_screen_off(struct nvidia_par *par, int on)
 {
         unsigned char tmp;
 
@@ -649,7 +649,7 @@ static int nvidiafb_set_par(struct fb_info *info)
                 NVLockUnlock(par, 0);
         }
 
-        nvidia_vga_protect(par, 1);
+        nvidia_screen_off(par, 1);
 
         nvidia_write_regs(par, &par->ModeReg);
         NVSetStartAddress(par, 0);
@@ -687,7 +687,7 @@ static int nvidiafb_set_par(struct fb_info *info)
 
         par->cursor_reset = 1;
 
-        nvidia_vga_protect(par, 0);
+        nvidia_screen_off(par, 0);
 
 #ifdef CONFIG_BOOTX_TEXT
         /* Update debug text engine */
@@ -696,6 +696,7 @@ static int nvidiafb_set_par(struct fb_info *info)
                              info->var.bits_per_pixel, info->fix.line_length);
 #endif
 
+        NVLockUnlock(par, 0);
         NVTRACE_LEAVE();
         return 0;
 }
@@ -948,8 +949,80 @@ static int nvidiafb_blank(int blank, struct fb_info *info)
         return 0;
 }
 
+/*
+ * Because the VGA registers are not mapped linearly in its MMIO space,
+ * restrict VGA register saving and restore to x86 only, where legacy VGA IO
+ * access is legal. Consequently, we must also check if the device is the
+ * primary display.
+ */
+#ifdef CONFIG_X86
+static void save_vga_x86(struct nvidia_par *par)
+{
+        struct resource *res= &par->pci_dev->resource[PCI_ROM_RESOURCE];
+
+        if (res && res->flags & IORESOURCE_ROM_SHADOW) {
+                memset(&par->vgastate, 0, sizeof(par->vgastate));
+                par->vgastate.flags = VGA_SAVE_MODE | VGA_SAVE_FONTS |
+                        VGA_SAVE_CMAP;
+                save_vga(&par->vgastate);
+        }
+}
+
+static void restore_vga_x86(struct nvidia_par *par)
+{
+        struct resource *res= &par->pci_dev->resource[PCI_ROM_RESOURCE];
+
+        if (res && res->flags & IORESOURCE_ROM_SHADOW)
+                restore_vga(&par->vgastate);
+}
+#else
+#define save_vga_x86(x) do {} while (0)
+#define restore_vga_x86(x) do {} while (0)
+#endif /* X86 */
+
+static int nvidiafb_open(struct fb_info *info, int user)
+{
+        struct nvidia_par *par = info->par;
+
+        mutex_lock(&par->open_lock);
+
+        if (!par->open_count) {
+                save_vga_x86(par);
+                nvidia_save_vga(par, &par->initial_state);
+        }
+
+        par->open_count++;
+        mutex_unlock(&par->open_lock);
+        return 0;
+}
+
+static int nvidiafb_release(struct fb_info *info, int user)
+{
+        struct nvidia_par *par = info->par;
+        int err = 0;
+
+        mutex_lock(&par->open_lock);
+
+        if (!par->open_count) {
+                err = -EINVAL;
+                goto done;
+        }
+
+        if (par->open_count == 1) {
+                nvidia_write_regs(par, &par->initial_state);
+                restore_vga_x86(par);
+        }
+
+        par->open_count--;
+done:
+        mutex_unlock(&par->open_lock);
+        return err;
+}
+
 static struct fb_ops nvidia_fb_ops = {
         .owner          = THIS_MODULE,
+        .fb_open        = nvidiafb_open,
+        .fb_release     = nvidiafb_release,
         .fb_check_var   = nvidiafb_check_var,
         .fb_set_par     = nvidiafb_set_par,
         .fb_setcolreg   = nvidiafb_setcolreg,
@@ -1207,7 +1280,7 @@ static int __devinit nvidiafb_probe(struct pci_dev *pd,
 
         par = info->par;
         par->pci_dev = pd;
-
+        mutex_init(&par->open_lock);
         info->pixmap.addr = kzalloc(8 * 1024, GFP_KERNEL);
 
         if (info->pixmap.addr == NULL)
diff --git a/drivers/video/pm2fb.c b/drivers/video/pm2fb.c
index a560a2223825..1ac5264bb2c1 100644
--- a/drivers/video/pm2fb.c
+++ b/drivers/video/pm2fb.c
@@ -81,8 +81,6 @@ static int lowvsync;
 struct pm2fb_par
 {
         pm2type_t       type;           /* Board type */
-        u32             fb_size;        /* framebuffer memory size */
-        unsigned char   __iomem *v_fb;  /* virtual address of frame buffer */
         unsigned char   __iomem *v_regs;/* virtual address of p_regs */
         u32             memclock;       /* memclock */
         u32             video;          /* video flags before blanking */
@@ -103,7 +101,7 @@ static struct fb_fix_screeninfo pm2fb_fix __devinitdata = {
         .xpanstep =     1,
         .ypanstep =     1,
         .ywrapstep =    0, 
-        .accel =        FB_ACCEL_NONE,
+        .accel =        FB_ACCEL_3DLABS_PERMEDIA2,
 };
 
 /*
@@ -206,6 +204,17 @@ static inline void WAIT_FIFO(struct pm2fb_par* p, u32 a)
 }
 #endif
 
+static void wait_pm2(struct pm2fb_par* par) {
+
+        WAIT_FIFO(par, 1);
+        pm2_WR(par, PM2R_SYNC, 0);
+        mb();
+        do {
+                while (pm2_RD(par, PM2R_OUT_FIFO_WORDS) == 0);
+                rmb();
+        } while (pm2_RD(par, PM2R_OUT_FIFO) != PM2TAG(PM2R_SYNC));
+}
+
 /*
  * partial products for the supported horizontal resolutions.
  */
@@ -302,10 +311,10 @@ static void pm2v_mnp(u32 clk, unsigned char* mm, unsigned char* nn,
         s32 delta = 1000;
 
         *mm = *nn = *pp = 0;
-        for (n = 1; n; n++) {
-                for ( m = 1; m; m++) {
+        for ( m = 1; m < 128; m++) {
+                for (n = 2 * m + 1; n; n++) {
                         for ( p = 0; p < 2; p++) {
-                                f = PM2_REFERENCE_CLOCK * n / (m * (1 << (p + 1)));
+                                f = ( PM2_REFERENCE_CLOCK >> ( p + 1 )) * n / m;
                                 if ( clk > f - delta && clk < f + delta ) {
                                         delta = ( clk > f ) ? clk - f : f - clk;
                                         *mm=m;
@@ -462,21 +471,43 @@ static void set_memclock(struct pm2fb_par* par, u32 clk)
         int i;
         unsigned char m, n, p;
 
-        pm2_mnp(clk, &m, &n, &p);
-        WAIT_FIFO(par, 10);
-        pm2_RDAC_WR(par, PM2I_RD_MEMORY_CLOCK_3, 6);
-        wmb();
-        pm2_RDAC_WR(par, PM2I_RD_MEMORY_CLOCK_1, m);
-        pm2_RDAC_WR(par, PM2I_RD_MEMORY_CLOCK_2, n);
-        wmb();
-        pm2_RDAC_WR(par, PM2I_RD_MEMORY_CLOCK_3, 8|p);
-        wmb();
-        pm2_RDAC_RD(par, PM2I_RD_MEMORY_CLOCK_STATUS);
-        rmb();
-        for (i = 256;
-             i && !(pm2_RD(par, PM2R_RD_INDEXED_DATA) & PM2F_PLL_LOCKED);
-             i--)
-                ;
+        switch (par->type) {
+        case PM2_TYPE_PERMEDIA2V:
+                pm2v_mnp(clk/2, &m, &n, &p);
+                WAIT_FIFO(par, 8);
+                pm2_WR(par, PM2VR_RD_INDEX_HIGH, PM2VI_RD_MCLK_CONTROL >> 8);
+                pm2v_RDAC_WR(par, PM2VI_RD_MCLK_CONTROL, 0);
+                wmb();
+                pm2v_RDAC_WR(par, PM2VI_RD_MCLK_PRESCALE, m);
+                pm2v_RDAC_WR(par, PM2VI_RD_MCLK_FEEDBACK, n);
+                pm2v_RDAC_WR(par, PM2VI_RD_MCLK_POSTSCALE, p);
+                wmb();
+                pm2v_RDAC_WR(par, PM2VI_RD_MCLK_CONTROL, 1);
+                rmb();
+                for (i = 256;
+                     i && !(pm2_RDAC_RD(par, PM2VI_RD_MCLK_CONTROL) & 2);
+                     i--)
+                        ;
+                pm2_WR(par, PM2VR_RD_INDEX_HIGH, 0);
+                break;
+        case PM2_TYPE_PERMEDIA2:
+                pm2_mnp(clk, &m, &n, &p);
+                WAIT_FIFO(par, 10);
+                pm2_RDAC_WR(par, PM2I_RD_MEMORY_CLOCK_3, 6);
+                wmb();
+                pm2_RDAC_WR(par, PM2I_RD_MEMORY_CLOCK_1, m);
+                pm2_RDAC_WR(par, PM2I_RD_MEMORY_CLOCK_2, n);
+                wmb();
+                pm2_RDAC_WR(par, PM2I_RD_MEMORY_CLOCK_3, 8|p);
+                wmb();
+                pm2_RDAC_RD(par, PM2I_RD_MEMORY_CLOCK_STATUS);
+                rmb();
+                for (i = 256;
+                     i && !(pm2_RD(par, PM2R_RD_INDEXED_DATA) & PM2F_PLL_LOCKED);
+                     i--)
+                        ;
+                break;
+        }
 }
 
 static void set_pixclock(struct pm2fb_par* par, u32 clk)
@@ -623,6 +654,8 @@ static int pm2fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
                 return -EINVAL;
         }
 
+        var->transp.offset = 0;
+        var->transp.length = 0;
         switch(var->bits_per_pixel) {
         case 8:
                 var->red.length = var->green.length = var->blue.length = 8;
@@ -1017,6 +1050,117 @@ static int pm2fb_blank(int blank_mode, struct fb_info *info)
         return 0;
 }
 
+/*
+ * block operation. copy=0: rectangle fill, copy=1: rectangle copy.
+ */
+static void pm2fb_block_op(struct pm2fb_par* par, int copy,
+                                s32 xsrc, s32 ysrc,
+                                s32 x, s32 y, s32 w, s32 h,
+                                u32 color) {
+
+        if (!w || !h)
+                return;
+        WAIT_FIFO(par, 6);
+        pm2_WR(par, PM2R_CONFIG, PM2F_CONFIG_FB_WRITE_ENABLE |
+                PM2F_CONFIG_FB_READ_SOURCE_ENABLE);
+        pm2_WR(par, PM2R_FB_PIXEL_OFFSET, 0);
+        if (copy)
+                pm2_WR(par, PM2R_FB_SOURCE_DELTA,
+                        ((ysrc-y) & 0xfff) << 16 | ((xsrc-x) & 0xfff));
+        else
+                pm2_WR(par, PM2R_FB_BLOCK_COLOR, color);
+        pm2_WR(par, PM2R_RECTANGLE_ORIGIN, (y << 16) | x);
+        pm2_WR(par, PM2R_RECTANGLE_SIZE, (h << 16) | w);
+        wmb();
+        pm2_WR(par, PM2R_RENDER,PM2F_RENDER_RECTANGLE |
+                                (x<xsrc ? PM2F_INCREASE_X : 0) |
+                                (y<ysrc ? PM2F_INCREASE_Y : 0) |
+                                (copy ? 0 : PM2F_RENDER_FASTFILL));
+        wait_pm2(par);
+}
+
+static void pm2fb_fillrect (struct fb_info *info,
+                                const struct fb_fillrect *region)
+{
+        struct pm2fb_par *par = info->par;
+        struct fb_fillrect modded;
+        int vxres, vyres;
+        u32 color = (info->fix.visual == FB_VISUAL_TRUECOLOR) ?
+                ((u32*)info->pseudo_palette)[region->color] : region->color;
+
+        if (info->state != FBINFO_STATE_RUNNING)
+                return;
+        if ((info->flags & FBINFO_HWACCEL_DISABLED) ||
+                region->rop != ROP_COPY ) {
+                cfb_fillrect(info, region);
+                return;
+        }
+
+        vxres = info->var.xres_virtual;
+        vyres = info->var.yres_virtual;
+
+        memcpy(&modded, region, sizeof(struct fb_fillrect));
+
+        if(!modded.width || !modded.height ||
+           modded.dx >= vxres || modded.dy >= vyres)
+                return;
+
+        if(modded.dx + modded.width  > vxres)
+                modded.width  = vxres - modded.dx;
+        if(modded.dy + modded.height > vyres)
+                modded.height = vyres - modded.dy;
+
+        if(info->var.bits_per_pixel == 8)
+                color |= color << 8;
+        if(info->var.bits_per_pixel <= 16)
+                color |= color << 16;
+
+        if(info->var.bits_per_pixel != 24)
+                pm2fb_block_op(par, 0, 0, 0,
+                                modded.dx, modded.dy,
+                                modded.width, modded.height, color);
+        else
+                cfb_fillrect(info, region);
+}
+
+static void pm2fb_copyarea(struct fb_info *info,
+                                const struct fb_copyarea *area)
+{
+        struct pm2fb_par *par = info->par;
+        struct fb_copyarea modded;
+        u32 vxres, vyres;
+
+        if (info->state != FBINFO_STATE_RUNNING)
+                return;
+        if (info->flags & FBINFO_HWACCEL_DISABLED) {
+                cfb_copyarea(info, area);
+                return;
+        }
+
+        memcpy(&modded, area, sizeof(struct fb_copyarea));
+
+        vxres = info->var.xres_virtual;
+        vyres = info->var.yres_virtual;
+
+        if(!modded.width || !modded.height ||
+           modded.sx >= vxres || modded.sy >= vyres ||
+           modded.dx >= vxres || modded.dy >= vyres)
+                return;
+
+        if(modded.sx + modded.width > vxres)
+                modded.width = vxres - modded.sx;
+        if(modded.dx + modded.width > vxres)
+                modded.width = vxres - modded.dx;
+        if(modded.sy + modded.height > vyres)
+                modded.height = vyres - modded.sy;
+        if(modded.dy + modded.height > vyres)
+                modded.height = vyres - modded.dy;
+
+        pm2fb_block_op(par, 1, modded.sx, modded.sy,
+                        modded.dx, modded.dy,
+                        modded.width, modded.height, 0);
+}
+
 /* ------------ Hardware Independent Functions ------------ */
 
 /*
@@ -1030,8 +1174,8 @@ static struct fb_ops pm2fb_ops = {
         .fb_setcolreg   = pm2fb_setcolreg,
         .fb_blank       = pm2fb_blank,
         .fb_pan_display = pm2fb_pan_display,
-        .fb_fillrect    = cfb_fillrect,
-        .fb_copyarea    = cfb_copyarea,
+        .fb_fillrect    = pm2fb_fillrect,
+        .fb_copyarea    = pm2fb_copyarea,
         .fb_imageblit   = cfb_imageblit,
 };
 
@@ -1119,38 +1263,47 @@ static int __devinit pm2fb_probe(struct pci_dev *pdev,
 
         if(default_par->mem_control == 0 &&
                 default_par->boot_address == 0x31 &&
-                default_par->mem_config == 0x259fffff &&
-                pdev->subsystem_vendor == 0x1048 &&
-                pdev->subsystem_device == 0x0a31) {
-                DPRINTK("subsystem_vendor: %04x, subsystem_device: %04x\n",
-                        pdev->subsystem_vendor, pdev->subsystem_device);
-                DPRINTK("We have not been initialized by VGA BIOS "
-                        "and are running on an Elsa Winner 2000 Office\n");
-                DPRINTK("Initializing card timings manually...\n");
+                default_par->mem_config == 0x259fffff) {
+                default_par->memclock = CVPPC_MEMCLOCK;
                 default_par->mem_control=0;
                 default_par->boot_address=0x20;
                 default_par->mem_config=0xe6002021;
-                default_par->memclock=100000;
+                if (pdev->subsystem_vendor == 0x1048 &&
+                        pdev->subsystem_device == 0x0a31) {
+                        DPRINTK("subsystem_vendor: %04x, subsystem_device: %04x\n",
+                                pdev->subsystem_vendor, pdev->subsystem_device);
+                        DPRINTK("We have not been initialized by VGA BIOS "
+                                "and are running on an Elsa Winner 2000 Office\n");
+                        DPRINTK("Initializing card timings manually...\n");
+                        default_par->memclock=70000;
+                }
+                if (pdev->subsystem_vendor == 0x3d3d &&
+                        pdev->subsystem_device == 0x0100) {
+                        DPRINTK("subsystem_vendor: %04x, subsystem_device: %04x\n",
+                                pdev->subsystem_vendor, pdev->subsystem_device);
+                        DPRINTK("We have not been initialized by VGA BIOS "
+                                "and are running on an 3dlabs reference board\n");
+                        DPRINTK("Initializing card timings manually...\n");
+                        default_par->memclock=74894;
+                }
         }
 
         /* Now work out how big lfb is going to be. */
         switch(default_par->mem_config & PM2F_MEM_CONFIG_RAM_MASK) {
         case PM2F_MEM_BANKS_1:
-                default_par->fb_size=0x200000;
+                pm2fb_fix.smem_len=0x200000;
                 break;
         case PM2F_MEM_BANKS_2:
-                default_par->fb_size=0x400000;
+                pm2fb_fix.smem_len=0x400000;
                 break;
         case PM2F_MEM_BANKS_3:
-                default_par->fb_size=0x600000;
+                pm2fb_fix.smem_len=0x600000;
                 break;
         case PM2F_MEM_BANKS_4:
-                default_par->fb_size=0x800000;
+                pm2fb_fix.smem_len=0x800000;
                 break;
         }
-        default_par->memclock = CVPPC_MEMCLOCK;
         pm2fb_fix.smem_start = pci_resource_start(pdev, 1);
-        pm2fb_fix.smem_len = default_par->fb_size;
 
         /* Linear frame buffer - request region and map it. */
         if ( !request_mem_region(pm2fb_fix.smem_start, pm2fb_fix.smem_len,
@@ -1158,9 +1311,9 @@ static int __devinit pm2fb_probe(struct pci_dev *pdev,
                 printk(KERN_WARNING "pm2fb: Can't reserve smem.\n");
                 goto err_exit_mmio;
         }
-        info->screen_base = default_par->v_fb =
+        info->screen_base =
                 ioremap_nocache(pm2fb_fix.smem_start, pm2fb_fix.smem_len);
-        if ( !default_par->v_fb ) {
+        if ( !info->screen_base ) {
                 printk(KERN_WARNING "pm2fb: Can't ioremap smem area.\n");
                 release_mem_region(pm2fb_fix.smem_start, pm2fb_fix.smem_len);
                 goto err_exit_mmio;
@@ -1170,7 +1323,9 @@ static int __devinit pm2fb_probe(struct pci_dev *pdev,
         info->fix               = pm2fb_fix;    
         info->pseudo_palette    = default_par->palette;
         info->flags             = FBINFO_DEFAULT |
-                                  FBINFO_HWACCEL_YPAN;
+                                  FBINFO_HWACCEL_YPAN |
+                                  FBINFO_HWACCEL_COPYAREA |
+                                  FBINFO_HWACCEL_FILLRECT;
 
         if (!mode)
                 mode = "640x480@60";
@@ -1180,13 +1335,13 @@ static int __devinit pm2fb_probe(struct pci_dev *pdev,
                 info->var = pm2fb_var;
 
         if (fb_alloc_cmap(&info->cmap, 256, 0) < 0)
-                goto err_exit_all;
+                goto err_exit_both;
 
         if (register_framebuffer(info) < 0)
-                goto err_exit_both;
+                goto err_exit_all;
 
         printk(KERN_INFO "fb%d: %s frame buffer device, memory = %dK.\n",
-               info->node, info->fix.id, default_par->fb_size / 1024);
+               info->node, info->fix.id, pm2fb_fix.smem_len / 1024);
 
         /*
          * Our driver data
@@ -1242,6 +1397,9 @@ static struct pci_device_id pm2fb_id_table[] = {
         { PCI_VENDOR_ID_3DLABS, PCI_DEVICE_ID_3DLABS_PERMEDIA2V,
           PCI_ANY_ID, PCI_ANY_ID, PCI_BASE_CLASS_DISPLAY << 16,
           0xff0000, 0 },
+        { PCI_VENDOR_ID_3DLABS, PCI_DEVICE_ID_3DLABS_PERMEDIA2V,
+          PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NOT_DEFINED_VGA << 8,
+          0xff00, 0 },
         { 0, }
 };
 
diff --git a/drivers/video/pvr2fb.c b/drivers/video/pvr2fb.c
index a93618bc9d27..df2909ae704c 100644
--- a/drivers/video/pvr2fb.c
+++ b/drivers/video/pvr2fb.c
@@ -214,7 +214,7 @@ static int pvr2_init_cable(void);
 static int pvr2_get_param(const struct pvr2_params *p, const char *s,
                             int val, int size);
 #ifdef CONFIG_SH_DMA
-static ssize_t pvr2fb_write(struct file *file, const char *buf,
+static ssize_t pvr2fb_write(struct fb_info *info, const char *buf,
                             size_t count, loff_t *ppos);
 #endif
 
@@ -674,7 +674,7 @@ static int pvr2_init_cable(void)
 }
 
 #ifdef CONFIG_SH_DMA
-static ssize_t pvr2fb_write(struct file *file, const char *buf,
+static ssize_t pvr2fb_write(struct fb_info *info, const char *buf,
                             size_t count, loff_t *ppos)
 {
         unsigned long dst, start, end, len;
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index 0b195f33f84f..81e571d59b50 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -1203,7 +1203,7 @@ static int __init pxafb_parse_options(struct device *dev, char *options)
                                         } else
                                                 goto done;
                                         break;
-                                case '0'...'9':
+                                case '0' ... '9':
                                         break;
                                 default:
                                         goto done;
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index 9c6bd0991852..0fe547842c64 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -317,15 +317,15 @@ static int riva_bl_update_status(struct backlight_device *bd)
         else
                 level = bd->props.brightness;
 
-        tmp_pmc = par->riva.PMC[0x10F0/4] & 0x0000FFFF;
-        tmp_pcrt = par->riva.PCRTC0[0x081C/4] & 0xFFFFFFFC;
+        tmp_pmc = NV_RD32(par->riva.PMC, 0x10F0) & 0x0000FFFF;
+        tmp_pcrt = NV_RD32(par->riva.PCRTC0, 0x081C) & 0xFFFFFFFC;
         if(level > 0) {
                 tmp_pcrt |= 0x1;
                 tmp_pmc |= (1 << 31); /* backlight bit */
                 tmp_pmc |= riva_bl_get_level_brightness(par, level) << 16; /* level */
         }
-        par->riva.PCRTC0[0x081C/4] = tmp_pcrt;
-        par->riva.PMC[0x10F0/4] = tmp_pmc;
+        NV_WR32(par->riva.PCRTC0, 0x081C, tmp_pcrt);
+        NV_WR32(par->riva.PMC, 0x10F0, tmp_pmc);
 
         return 0;
 }
@@ -1788,8 +1788,10 @@ static int __devinit riva_get_EDID_i2c(struct fb_info *info)
 
         NVTRACE_ENTER();
         riva_create_i2c_busses(par);
-        for (i = 0; i < par->bus; i++) {
-                riva_probe_i2c_connector(par, i+1, &par->EDID);
+        for (i = 0; i < 3; i++) {
+                if (!par->chan[i].par)
+                        continue;
+                riva_probe_i2c_connector(par, i, &par->EDID);
                 if (par->EDID && !fb_parse_edid(par->EDID, &var)) {
                         printk(PFX "Found EDID Block from BUS %i\n", i);
                         break;
@@ -2104,7 +2106,7 @@ err_ret:
         return ret;
 }
 
-static void __exit rivafb_remove(struct pci_dev *pd)
+static void __devexit rivafb_remove(struct pci_dev *pd)
 {
         struct fb_info *info = pci_get_drvdata(pd);
         struct riva_par *par = info->par;
@@ -2185,7 +2187,7 @@ static struct pci_driver rivafb_driver = {
         .name           = "rivafb",
         .id_table       = rivafb_pci_tbl,
         .probe          = rivafb_probe,
-        .remove         = __exit_p(rivafb_remove),
+        .remove         = __devexit_p(rivafb_remove),
 };
 
 
diff --git a/drivers/video/riva/nv4ref.h b/drivers/video/riva/nv4ref.h
deleted file mode 100644
index 3b5f9117c37d..000000000000
--- a/drivers/video/riva/nv4ref.h
+++ /dev/null
@@ -1,2445 +0,0 @@
- /***************************************************************************\
-|*                                                                           *|
-|*       Copyright 1993-1998 NVIDIA, Corporation.  All rights reserved.      *|
-|*                                                                           *|
-|*     NOTICE TO USER:   The source code  is copyrighted under  U.S. and     *|
-|*     international laws.  Users and possessors of this source code are     *|
-|*     hereby granted a nonexclusive,  royalty-free copyright license to     *|
-|*     use this code in individual and commercial software.                  *|
-|*                                                                           *|
-|*     Any use of this source code must include,  in the user documenta-     *|
-|*     tion and  internal comments to the code,  notices to the end user     *|
-|*     as follows:                                                           *|
-|*                                                                           *|
-|*       Copyright 1993-1998 NVIDIA, Corporation.  All rights reserved.      *|
-|*                                                                           *|
-|*     NVIDIA, CORPORATION MAKES NO REPRESENTATION ABOUT THE SUITABILITY     *|
-|*     OF  THIS SOURCE  CODE  FOR ANY PURPOSE.  IT IS  PROVIDED  "AS IS"     *|
-|*     WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.  NVIDIA, CORPOR-     *|
-|*     ATION DISCLAIMS ALL WARRANTIES  WITH REGARD  TO THIS SOURCE CODE,     *|
-|*     INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGE-     *|
-|*     MENT,  AND FITNESS  FOR A PARTICULAR PURPOSE.   IN NO EVENT SHALL     *|
-|*     NVIDIA, CORPORATION  BE LIABLE FOR ANY SPECIAL,  INDIRECT,  INCI-     *|
-|*     DENTAL, OR CONSEQUENTIAL DAMAGES,  OR ANY DAMAGES  WHATSOEVER RE-     *|
-|*     SULTING FROM LOSS OF USE,  DATA OR PROFITS,  WHETHER IN AN ACTION     *|
-|*     OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  ARISING OUT OF     *|
-|*     OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOURCE CODE.     *|
-|*                                                                           *|
-|*     U.S. Government  End  Users.   This source code  is a "commercial     *|
-|*     item,"  as that  term is  defined at  48 C.F.R. 2.101 (OCT 1995),     *|
-|*     consisting  of "commercial  computer  software"  and  "commercial     *|
-|*     computer  software  documentation,"  as such  terms  are  used in     *|
-|*     48 C.F.R. 12.212 (SEPT 1995)  and is provided to the U.S. Govern-     *|
-|*     ment only as  a commercial end item.   Consistent with  48 C.F.R.     *|
-|*     12.212 and  48 C.F.R. 227.7202-1 through  227.7202-4 (JUNE 1995),     *|
-|*     all U.S. Government End Users  acquire the source code  with only     *|
-|*     those rights set forth herein.                                        *|
-|*                                                                           *|
- \***************************************************************************/
-
-/*
- * GPL licensing note -- nVidia is allowing a liberal interpretation of
- * the documentation restriction above, to merely say that this nVidia's
- * copyright and disclaimer should be included with all code derived
- * from this source.  -- Jeff Garzik <jgarzik@pobox.com>, 01/Nov/99 
- */
-
- /***************************************************************************\
-|*            Modified 1999 by Fredrik Reite (fredrik@reite.com)             *|
- \***************************************************************************/
-
-
-#ifndef __NV4REF_H__
-#define __NV4REF_H__
-
-/* Magic values to lock/unlock extended regs */
-#define NV_CIO_SR_LOCK_INDEX                                 0x0000001F /*       */
-#define NV_CIO_SR_UNLOCK_RW_VALUE                            0x00000057 /*       */
-#define NV_CIO_SR_UNLOCK_RO_VALUE                            0x00000075 /*       */
-#define NV_CIO_SR_LOCK_VALUE                                 0x00000099 /*       */
-
-#define UNLOCK_EXT_MAGIC 0x57
-#define LOCK_EXT_MAGIC 0x99 /* Any value other than 0x57 will do */
-
-#define LOCK_EXT_INDEX 0x6
-
-#define NV_PCRTC_HORIZ_TOTAL                                 0x00
-#define NV_PCRTC_HORIZ_DISPLAY_END                           0x01
-#define NV_PCRTC_HORIZ_BLANK_START                           0x02
-
-#define NV_PCRTC_HORIZ_BLANK_END                             0x03
-#define NV_PCRTC_HORIZ_BLANK_END_EVRA                        7:7
-#define NV_PCRTC_HORIZ_BLANK_END_DISPLAY_END_SKEW            6:5
-#define NV_PCRTC_HORIZ_BLANK_END_HORIZ_BLANK_END             4:0
-
-#define NV_PCRTC_HORIZ_RETRACE_START                         0x04
-
-#define NV_PCRTC_HORIZ_RETRACE_END                           0x05
-#define NV_PCRTC_HORIZ_RETRACE_END_HORIZ_BLANK_END_5         7:7
-#define NV_PCRTC_HORIZ_RETRACE_END_HORIZ_RETRACE_SKEW        6:5
-#define NV_PCRTC_HORIZ_RETRACE_END_HORIZ_RETRACE_END         4:0
-
-#define NV_PCRTC_VERT_TOTAL                                  0x06
-
-#define NV_PCRTC_OVERFLOW                                    0x07
-#define NV_PCRTC_OVERFLOW_VERT_RETRACE_START_9               7:7
-#define NV_PCRTC_OVERFLOW_VERT_DISPLAY_END_9                 6:6
-#define NV_PCRTC_OVERFLOW_VERT_TOTAL_9                       5:5
-#define NV_PCRTC_OVERFLOW_LINE_COMPARE_8                     4:4
-#define NV_PCRTC_OVERFLOW_VERT_BLANK_START_8                 3:3
-#define NV_PCRTC_OVERFLOW_VERT_RETRACE_START_8               2:2
-#define NV_PCRTC_OVERFLOW_VERT_DISPLAY_END_8                 1:1
-#define NV_PCRTC_OVERFLOW_VERT_TOTAL_8                       0:0
-
-#define NV_PCRTC_PRESET_ROW_SCAN                             0x08
-
-#define NV_PCRTC_MAX_SCAN_LINE                               0x09
-#define NV_PCRTC_MAX_SCAN_LINE_DOUBLE_SCAN                   7:7
-#define NV_PCRTC_MAX_SCAN_LINE_LINE_COMPARE_9                6:6
-#define NV_PCRTC_MAX_SCAN_LINE_VERT_BLANK_START_9            5:5
-#define NV_PCRTC_MAX_SCAN_LINE_MAX_SCAN_LINE                 4:0
-
-#define NV_PCRTC_CURSOR_START                                0x0A
-#define NV_PCRTC_CURSOR_END                                  0x0B
-#define NV_PCRTC_START_ADDR_HIGH                             0x0C
-#define NV_PCRTC_START_ADDR_LOW                              0x0D
-#define NV_PCRTC_CURSOR_LOCATION_HIGH                        0x0E
-#define NV_PCRTC_CURSOR_LOCATION_LOW                         0x0F
-
-#define NV_PCRTC_VERT_RETRACE_START                          0x10
-#define NV_PCRTC_VERT_RETRACE_END                            0x11
-#define NV_PCRTC_VERT_DISPLAY_END                            0x12
-#define NV_PCRTC_OFFSET                                      0x13
-#define NV_PCRTC_UNDERLINE_LOCATION                          0x14
-#define NV_PCRTC_VERT_BLANK_START                            0x15
-#define NV_PCRTC_VERT_BLANK_END                              0x16
-#define NV_PCRTC_MODE_CONTROL                                0x17
-#define NV_PCRTC_LINE_COMPARE                                0x18
-
-/* Extended offset and start address */
-#define NV_PCRTC_REPAINT0                                    0x19
-#define NV_PCRTC_REPAINT0_OFFSET_10_8                        7:5 
-#define NV_PCRTC_REPAINT0_START_ADDR_20_16                   4:0
-
-/* Horizonal extended bits */
-#define NV_PCRTC_HORIZ_EXTRA                                 0x2d
-#define NV_PCRTC_HORIZ_EXTRA_INTER_HALF_START_8              4:4
-#define NV_PCRTC_HORIZ_EXTRA_HORIZ_RETRACE_START_8           3:3
-#define NV_PCRTC_HORIZ_EXTRA_HORIZ_BLANK_START_8             2:2
-#define NV_PCRTC_HORIZ_EXTRA_DISPLAY_END_8                   1:1
-#define NV_PCRTC_HORIZ_EXTRA_DISPLAY_TOTAL_8                 0:0
-
-/* Assorted extra bits */
-#define NV_PCRTC_EXTRA                                       0x25
-#define NV_PCRTC_EXTRA_OFFSET_11                             5:5
-#define NV_PCRTC_EXTRA_HORIZ_BLANK_END_6                     4:4
-#define NV_PCRTC_EXTRA_VERT_BLANK_START_10                   3:3
-#define NV_PCRTC_EXTRA_VERT_RETRACE_START_10                 2:2
-#define NV_PCRTC_EXTRA_VERT_DISPLAY_END_10                   1:1
-#define NV_PCRTC_EXTRA_VERT_TOTAL_10                         0:0
-
-/* Controls how much data the refresh fifo requests */
-#define NV_PCRTC_FIFO_CONTROL                                0x1b
-#define NV_PCRTC_FIFO_CONTROL_UNDERFLOW_WARN                 7:7
-#define NV_PCRTC_FIFO_CONTROL_BURST_LENGTH                   2:0
-#define NV_PCRTC_FIFO_CONTROL_BURST_LENGTH_8                 0x0
-#define NV_PCRTC_FIFO_CONTROL_BURST_LENGTH_32                0x1
-#define NV_PCRTC_FIFO_CONTROL_BURST_LENGTH_64                0x2
-#define NV_PCRTC_FIFO_CONTROL_BURST_LENGTH_128               0x3
-#define NV_PCRTC_FIFO_CONTROL_BURST_LENGTH_256               0x4
-
-/* When the fifo occupancy falls below *twice* the watermark,
- * the refresh fifo will start to be refilled. If this value is 
- * too low, you will get junk on the screen. Too high, and performance
- * will suffer. Watermark in units of 8 bytes
- */
-#define NV_PCRTC_FIFO                                        0x20
-#define NV_PCRTC_FIFO_RESET                                  7:7
-#define NV_PCRTC_FIFO_WATERMARK                              5:0
-
-/* Various flags */
-#define NV_PCRTC_REPAINT1                                    0x1a
-#define NV_PCRTC_REPAINT1_HSYNC                              7:7
-#define NV_PCRTC_REPAINT1_HYSNC_DISABLE                      0x01
-#define NV_PCRTC_REPAINT1_HYSNC_ENABLE                       0x00
-#define NV_PCRTC_REPAINT1_VSYNC                              6:6
-#define NV_PCRTC_REPAINT1_VYSNC_DISABLE                      0x01
-#define NV_PCRTC_REPAINT1_VYSNC_ENABLE                       0x00
-#define NV_PCRTC_REPAINT1_COMPATIBLE_TEXT                    4:4
-#define NV_PCRTC_REPAINT1_COMPATIBLE_TEXT_ENABLE             0x01
-#define NV_PCRTC_REPAINT1_COMPATIBLE_TEXT_DISABLE            0x00
-#define NV_PCRTC_REPAINT1_LARGE_SCREEN                       2:2 
-#define NV_PCRTC_REPAINT1_LARGE_SCREEN_DISABLE               0x01
-#define NV_PCRTC_REPAINT1_LARGE_SCREEN_ENABLE                0x00 /* >=1280 */
-#define NV_PCRTC_REPAINT1_PALETTE_WIDTH                      1:1
-#define NV_PCRTC_REPAINT1_PALETTE_WIDTH_8BITS                0x00
-#define NV_PCRTC_REPAINT1_PALETTE_WIDTH_6BITS                0x01
-
-#define NV_PCRTC_GRCURSOR0                                   0x30
-#define NV_PCRTC_GRCURSOR0_START_ADDR_21_16                  5:0
-
-#define NV_PCRTC_GRCURSOR1                                   0x31
-#define NV_PCRTC_GRCURSOR1_START_ADDR_15_11                  7:3
-#define NV_PCRTC_GRCURSOR1_SCAN_DBL                          1:1
-#define NV_PCRTC_GRCURSOR1_SCAN_DBL_DISABLE                  0
-#define NV_PCRTC_GRCURSOR1_SCAN_DBL_ENABLE                   1
-#define NV_PCRTC_GRCURSOR1_CURSOR                            0:0
-#define NV_PCRTC_GRCURSOR1_CURSOR_DISABLE                    0 
-#define NV_PCRTC_GRCURSOR1_CURSOR_ENABLE                     1
-
-/* Controls what the format of the framebuffer is */
-#define NV_PCRTC_PIXEL                       0x28
-#define NV_PCRTC_PIXEL_MODE                  7:7
-#define NV_PCRTC_PIXEL_MODE_TV               0x01
-#define NV_PCRTC_PIXEL_MODE_VGA              0x00
-#define NV_PCRTC_PIXEL_TV_MODE               6:6
-#define NV_PCRTC_PIXEL_TV_MODE_NTSC          0x00
-#define NV_PCRTC_PIXEL_TV_MODE_PAL           0x01
-#define NV_PCRTC_PIXEL_TV_HORIZ_ADJUST       5:3
-#define NV_PCRTC_PIXEL_FORMAT                1:0
-#define NV_PCRTC_PIXEL_FORMAT_VGA            0x00
-#define NV_PCRTC_PIXEL_FORMAT_8BPP           0x01
-#define NV_PCRTC_PIXEL_FORMAT_16BPP          0x02
-#define NV_PCRTC_PIXEL_FORMAT_32BPP          0x03
-
-/* RAMDAC registers and fields */
-#define NV_PRAMDAC                            0x00680FFF:0x00680000 /* RW--D */
-#define NV_PRAMDAC_GRCURSOR_START_POS                    0x00680300 /* RW-4R */
-#define NV_PRAMDAC_GRCURSOR_START_POS_X                        11:0 /* RWXSF */
-#define NV_PRAMDAC_GRCURSOR_START_POS_Y                       27:16 /* RWXSF */
-#define NV_PRAMDAC_NVPLL_COEFF                           0x00680500 /* RW-4R */
-#define NV_PRAMDAC_NVPLL_COEFF_MDIV                             7:0 /* RWIUF */
-#define NV_PRAMDAC_NVPLL_COEFF_NDIV                            15:8 /* RWIUF */
-#define NV_PRAMDAC_NVPLL_COEFF_PDIV                           18:16 /* RWIVF */
-#define NV_PRAMDAC_MPLL_COEFF                            0x00680504 /* RW-4R */
-#define NV_PRAMDAC_MPLL_COEFF_MDIV                              7:0 /* RWIUF */
-#define NV_PRAMDAC_MPLL_COEFF_NDIV                             15:8 /* RWIUF */
-#define NV_PRAMDAC_MPLL_COEFF_PDIV                            18:16 /* RWIVF */
-#define NV_PRAMDAC_VPLL_COEFF                            0x00680508 /* RW-4R */
-#define NV_PRAMDAC_VPLL_COEFF_MDIV                              7:0 /* RWIUF */
-#define NV_PRAMDAC_VPLL_COEFF_NDIV                             15:8 /* RWIUF */
-#define NV_PRAMDAC_VPLL_COEFF_PDIV                            18:16 /* RWIVF */
-#define NV_PRAMDAC_PLL_COEFF_SELECT                      0x0068050C /* RW-4R */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_DLL_BYPASS                  4:4 /* RWIVF */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_DLL_BYPASS_FALSE     0x00000000 /* RWI-V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_DLL_BYPASS_TRUE      0x00000001 /* RW--V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_MPLL_SOURCE                 8:8 /* RWIVF */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_MPLL_SOURCE_DEFAULT  0x00000000 /* RWI-V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_MPLL_SOURCE_PROG     0x00000001 /* RW--V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_MPLL_BYPASS               12:12 /* RWIVF */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_MPLL_BYPASS_FALSE    0x00000000 /* RWI-V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_MPLL_BYPASS_TRUE     0x00000001 /* RW--V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_VPLL_SOURCE               16:16 /* RWIVF */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_VPLL_SOURCE_DEFAULT  0x00000000 /* RWI-V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_VPLL_SOURCE_PROG     0x00000001 /* RW--V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_VPLL_BYPASS               20:20 /* RWIVF */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_VPLL_BYPASS_FALSE    0x00000000 /* RWI-V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_VPLL_BYPASS_TRUE     0x00000001 /* RW--V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_PCLK_SOURCE               25:24 /* RWIVF */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_PCLK_SOURCE_VPLL     0x00000000 /* RWI-V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_PCLK_SOURCE_VIP      0x00000001 /* RW--V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_PCLK_SOURCE_XTALOSC  0x00000002 /* RW--V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_VCLK_RATIO                28:28 /* RWIVF */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_VCLK_RATIO_DB1       0x00000000 /* RWI-V */
-#define NV_PRAMDAC_PLL_COEFF_SELECT_VCLK_RATIO_DB2       0x00000001 /* RW--V */
-#define NV_PRAMDAC_GENERAL_CONTROL                       0x00680600 /* RW-4R */
-#define NV_PRAMDAC_GENERAL_CONTROL_FF_COEFF                     1:0 /* RWIVF */
-#define NV_PRAMDAC_GENERAL_CONTROL_FF_COEFF_DEF          0x00000000 /* RWI-V */
-#define NV_PRAMDAC_GENERAL_CONTROL_IDC_MODE                     4:4 /* RWIVF */
-#define NV_PRAMDAC_GENERAL_CONTROL_IDC_MODE_GAMMA        0x00000000 /* RWI-V */
-#define NV_PRAMDAC_GENERAL_CONTROL_IDC_MODE_INDEX        0x00000001 /* RW--V */
-#define NV_PRAMDAC_GENERAL_CONTROL_VGA_STATE                    8:8 /* RWIVF */
-#define NV_PRAMDAC_GENERAL_CONTROL_VGA_STATE_NOTSE       0x00000000 /* RWI-V */
-#define NV_PRAMDAC_GENERAL_CONTROL_VGA_STATE_SEL         0x00000001 /* RW--V */
-#define NV_PRAMDAC_GENERAL_CONTROL_565_MODE                   12:12 /* RWIVF */
-#define NV_PRAMDAC_GENERAL_CONTROL_565_MODE_NOTSEL       0x00000000 /* RWI-V */
-#define NV_PRAMDAC_GENERAL_CONTROL_565_MODE_SEL          0x00000001 /* RW--V */
-#define NV_PRAMDAC_GENERAL_CONTROL_BLK_PEDSTL                 16:16 /* RWIVF */
-#define NV_PRAMDAC_GENERAL_CONTROL_BLK_PEDSTL_OFF        0x00000000 /* RWI-V */
-#define NV_PRAMDAC_GENERAL_CONTROL_BLK_PEDSTL_ON         0x00000001 /* RW--V */
-#define NV_PRAMDAC_GENERAL_CONTROL_TERMINATION                17:17 /* RWIVF */
-#define NV_PRAMDAC_GENERAL_CONTROL_TERMINATION_37OHM     0x00000000 /* RWI-V */
-#define NV_PRAMDAC_GENERAL_CONTROL_TERMINATION_75OHM     0x00000001 /* RW--V */
-#define NV_PRAMDAC_GENERAL_CONTROL_BPC                        20:20 /* RWIVF */
-#define NV_PRAMDAC_GENERAL_CONTROL_BPC_6BITS             0x00000000 /* RWI-V */
-#define NV_PRAMDAC_GENERAL_CONTROL_BPC_8BITS             0x00000001 /* RW--V */
-#define NV_PRAMDAC_GENERAL_CONTROL_DAC_SLEEP                  24:24 /* RWIVF */
-#define NV_PRAMDAC_GENERAL_CONTROL_DAC_SLEEP_DIS         0x00000000 /* RWI-V */
-#define NV_PRAMDAC_GENERAL_CONTROL_DAC_SLEEP_EN          0x00000001 /* RW--V */
-#define NV_PRAMDAC_GENERAL_CONTROL_PALETTE_CLK                28:28 /* RWIVF */
-#define NV_PRAMDAC_GENERAL_CONTROL_PALETTE_CLK_EN        0x00000000 /* RWI-V */
-#define NV_PRAMDAC_GENERAL_CONTROL_PALETTE_CLK_DIS       0x00000001 /* RW--V */
-
-/* Master Control */
-#define NV_PMC                                0x00000FFF:0x00000000 /* RW--D */
-#define NV_PMC_BOOT_0                                    0x00000000 /* R--4R */
-#define NV_PMC_BOOT_0_MINOR_REVISION                            3:0 /* C--VF */
-#define NV_PMC_BOOT_0_MINOR_REVISION_0                   0x00000000 /* C---V */
-#define NV_PMC_BOOT_0_MAJOR_REVISION                            7:4 /* C--VF */
-#define NV_PMC_BOOT_0_MAJOR_REVISION_A                   0x00000000 /* C---V */
-#define NV_PMC_BOOT_0_MAJOR_REVISION_B                   0x00000001 /* ----V */
-#define NV_PMC_BOOT_0_IMPLEMENTATION                           11:8 /* C--VF */
-#define NV_PMC_BOOT_0_IMPLEMENTATION_NV4_0               0x00000000 /* C---V */
-#define NV_PMC_BOOT_0_ARCHITECTURE                            15:12 /* C--VF */
-#define NV_PMC_BOOT_0_ARCHITECTURE_NV0                   0x00000000 /* ----V */
-#define NV_PMC_BOOT_0_ARCHITECTURE_NV1                   0x00000001 /* ----V */
-#define NV_PMC_BOOT_0_ARCHITECTURE_NV2                   0x00000002 /* ----V */
-#define NV_PMC_BOOT_0_ARCHITECTURE_NV3                   0x00000003 /* ----V */
-#define NV_PMC_BOOT_0_ARCHITECTURE_NV4                   0x00000004 /* C---V */
-#define NV_PMC_BOOT_0_FIB_REVISION                            19:16 /* C--VF */
-#define NV_PMC_BOOT_0_FIB_REVISION_0                     0x00000000 /* C---V */
-#define NV_PMC_BOOT_0_MASK_REVISION                           23:20 /* C--VF */
-#define NV_PMC_BOOT_0_MASK_REVISION_A                    0x00000000 /* C---V */
-#define NV_PMC_BOOT_0_MASK_REVISION_B                    0x00000001 /* ----V */
-#define NV_PMC_BOOT_0_MANUFACTURER                            27:24 /* C--UF */
-#define NV_PMC_BOOT_0_MANUFACTURER_NVIDIA                0x00000000 /* C---V */
-#define NV_PMC_BOOT_0_FOUNDRY                                 31:28 /* C--VF */
-#define NV_PMC_BOOT_0_FOUNDRY_SGS                        0x00000000 /* ----V */
-#define NV_PMC_BOOT_0_FOUNDRY_HELIOS                     0x00000001 /* ----V */
-#define NV_PMC_BOOT_0_FOUNDRY_TSMC                       0x00000002 /* C---V */
-#define NV_PMC_INTR_0                                    0x00000100 /* RW-4R */
-#define NV_PMC_INTR_0_PMEDIA                                    4:4 /* R--VF */
-#define NV_PMC_INTR_0_PMEDIA_NOT_PENDING                 0x00000000 /* R---V */
-#define NV_PMC_INTR_0_PMEDIA_PENDING                     0x00000001 /* R---V */
-#define NV_PMC_INTR_0_PFIFO                                     8:8 /* R--VF */
-#define NV_PMC_INTR_0_PFIFO_NOT_PENDING                  0x00000000 /* R---V */
-#define NV_PMC_INTR_0_PFIFO_PENDING                      0x00000001 /* R---V */
-#define NV_PMC_INTR_0_PGRAPH                                  12:12 /* R--VF */
-#define NV_PMC_INTR_0_PGRAPH_NOT_PENDING                 0x00000000 /* R---V */
-#define NV_PMC_INTR_0_PGRAPH_PENDING                     0x00000001 /* R---V */
-#define NV_PMC_INTR_0_PVIDEO                                  16:16 /* R--VF */
-#define NV_PMC_INTR_0_PVIDEO_NOT_PENDING                 0x00000000 /* R---V */
-#define NV_PMC_INTR_0_PVIDEO_PENDING                     0x00000001 /* R---V */
-#define NV_PMC_INTR_0_PTIMER                                  20:20 /* R--VF */
-#define NV_PMC_INTR_0_PTIMER_NOT_PENDING                 0x00000000 /* R---V */
-#define NV_PMC_INTR_0_PTIMER_PENDING                     0x00000001 /* R---V */
-#define NV_PMC_INTR_0_PCRTC                                   24:24 /* R--VF */
-#define NV_PMC_INTR_0_PCRTC_NOT_PENDING                  0x00000000 /* R---V */
-#define NV_PMC_INTR_0_PCRTC_PENDING                      0x00000001 /* R---V */
-#define NV_PMC_INTR_0_PBUS                                    28:28 /* R--VF */
-#define NV_PMC_INTR_0_PBUS_NOT_PENDING                   0x00000000 /* R---V */
-#define NV_PMC_INTR_0_PBUS_PENDING                       0x00000001 /* R---V */
-#define NV_PMC_INTR_0_SOFTWARE                                31:31 /* RWIVF */
-#define NV_PMC_INTR_0_SOFTWARE_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PMC_INTR_0_SOFTWARE_PENDING                   0x00000001 /* RW--V */
-#define NV_PMC_INTR_EN_0                                 0x00000140 /* RW-4R */
-#define NV_PMC_INTR_EN_0_INTA                                   1:0 /* RWIVF */
-#define NV_PMC_INTR_EN_0_INTA_DISABLED                   0x00000000 /* RWI-V */
-#define NV_PMC_INTR_EN_0_INTA_HARDWARE                   0x00000001 /* RW--V */
-#define NV_PMC_INTR_EN_0_INTA_SOFTWARE                   0x00000002 /* RW--V */
-#define NV_PMC_INTR_READ_0                               0x00000160 /* R--4R */
-#define NV_PMC_INTR_READ_0_INTA                                 0:0 /* R--VF */
-#define NV_PMC_INTR_READ_0_INTA_LOW                      0x00000000 /* R---V */
-#define NV_PMC_INTR_READ_0_INTA_HIGH                     0x00000001 /* R---V */
-#define NV_PMC_ENABLE                                    0x00000200 /* RW-4R */
-#define NV_PMC_ENABLE_PMEDIA                                    4:4 /* RWIVF */
-#define NV_PMC_ENABLE_PMEDIA_DISABLED                    0x00000000 /* RWI-V */
-#define NV_PMC_ENABLE_PMEDIA_ENABLED                     0x00000001 /* RW--V */
-#define NV_PMC_ENABLE_PFIFO                                     8:8 /* RWIVF */
-#define NV_PMC_ENABLE_PFIFO_DISABLED                     0x00000000 /* RWI-V */
-#define NV_PMC_ENABLE_PFIFO_ENABLED                      0x00000001 /* RW--V */
-#define NV_PMC_ENABLE_PGRAPH                                  12:12 /* RWIVF */
-#define NV_PMC_ENABLE_PGRAPH_DISABLED                    0x00000000 /* RWI-V */
-#define NV_PMC_ENABLE_PGRAPH_ENABLED                     0x00000001 /* RW--V */
-#define NV_PMC_ENABLE_PPMI                                    16:16 /* RWIVF */
-#define NV_PMC_ENABLE_PPMI_DISABLED                      0x00000000 /* RWI-V */
-#define NV_PMC_ENABLE_PPMI_ENABLED                       0x00000001 /* RW--V */
-#define NV_PMC_ENABLE_PFB                                     20:20 /* RWIVF */
-#define NV_PMC_ENABLE_PFB_DISABLED                       0x00000000 /* RW--V */
-#define NV_PMC_ENABLE_PFB_ENABLED                        0x00000001 /* RWI-V */
-#define NV_PMC_ENABLE_PCRTC                                   24:24 /* RWIVF */
-#define NV_PMC_ENABLE_PCRTC_DISABLED                     0x00000000 /* RW--V */
-#define NV_PMC_ENABLE_PCRTC_ENABLED                      0x00000001 /* RWI-V */
-#define NV_PMC_ENABLE_PVIDEO                                  28:28 /* RWIVF */
-#define NV_PMC_ENABLE_PVIDEO_DISABLED                    0x00000000 /* RWI-V */
-#define NV_PMC_ENABLE_PVIDEO_ENABLED                     0x00000001 /* RW--V */
-
-/* dev_timer.ref */
-#define NV_PTIMER                             0x00009FFF:0x00009000 /* RW--D */
-#define NV_PTIMER_INTR_0                                 0x00009100 /* RW-4R */
-#define NV_PTIMER_INTR_0_ALARM                                  0:0 /* RWXVF */
-#define NV_PTIMER_INTR_0_ALARM_NOT_PENDING               0x00000000 /* R---V */
-#define NV_PTIMER_INTR_0_ALARM_PENDING                   0x00000001 /* R---V */
-#define NV_PTIMER_INTR_0_ALARM_RESET                     0x00000001 /* -W--V */
-#define NV_PTIMER_INTR_EN_0                              0x00009140 /* RW-4R */
-#define NV_PTIMER_INTR_EN_0_ALARM                               0:0 /* RWIVF */
-#define NV_PTIMER_INTR_EN_0_ALARM_DISABLED               0x00000000 /* RWI-V */
-#define NV_PTIMER_INTR_EN_0_ALARM_ENABLED                0x00000001 /* RW--V */
-#define NV_PTIMER_NUMERATOR                              0x00009200 /* RW-4R */
-#define NV_PTIMER_NUMERATOR_VALUE                              15:0 /* RWIUF */
-#define NV_PTIMER_NUMERATOR_VALUE_0                      0x00000000 /* RWI-V */
-#define NV_PTIMER_DENOMINATOR                            0x00009210 /* RW-4R */
-#define NV_PTIMER_DENOMINATOR_VALUE                            15:0 /* RWIUF */
-#define NV_PTIMER_DENOMINATOR_VALUE_0                    0x00000000 /* RWI-V */
-#define NV_PTIMER_TIME_0                                 0x00009400 /* RW-4R */
-#define NV_PTIMER_TIME_0_NSEC                                  31:5 /* RWXUF */
-#define NV_PTIMER_TIME_1                                 0x00009410 /* RW-4R */
-#define NV_PTIMER_TIME_1_NSEC                                  28:0 /* RWXUF */
-#define NV_PTIMER_ALARM_0                                0x00009420 /* RW-4R */
-#define NV_PTIMER_ALARM_0_NSEC                                 31:5 /* RWXUF */
-
-/* dev_fifo.ref */
-#define NV_PFIFO                              0x00003FFF:0x00002000 /* RW--D */
-#define NV_PFIFO_DELAY_0                                 0x00002040 /* RW-4R */
-#define NV_PFIFO_DELAY_0_WAIT_RETRY                             9:0 /* RWIUF */
-#define NV_PFIFO_DELAY_0_WAIT_RETRY_0                    0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_TIMESLICE                           0x00002044 /* RW-4R */
-#define NV_PFIFO_DMA_TIMESLICE_SELECT                          16:0 /* RWIUF */
-#define NV_PFIFO_DMA_TIMESLICE_SELECT_1                  0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_TIMESLICE_SELECT_16K                0x00003fff /* RW--V */
-#define NV_PFIFO_DMA_TIMESLICE_SELECT_32K                0x00007fff /* RW--V */
-#define NV_PFIFO_DMA_TIMESLICE_SELECT_64K                0x0000ffff /* RW--V */
-#define NV_PFIFO_DMA_TIMESLICE_SELECT_128K               0x0001ffff /* RW--V */
-#define NV_PFIFO_DMA_TIMESLICE_TIMEOUT                        24:24 /* RWIUF */
-#define NV_PFIFO_DMA_TIMESLICE_TIMEOUT_DISABLED          0x00000000 /* RW--V */
-#define NV_PFIFO_DMA_TIMESLICE_TIMEOUT_ENABLED           0x00000001 /* RWI-V */
-#define NV_PFIFO_PIO_TIMESLICE                           0x00002048 /* RW-4R */
-#define NV_PFIFO_PIO_TIMESLICE_SELECT                          16:0 /* RWIUF */
-#define NV_PFIFO_PIO_TIMESLICE_SELECT_1                  0x00000000 /* RWI-V */
-#define NV_PFIFO_PIO_TIMESLICE_SELECT_16K                0x00003fff /* RW--V */
-#define NV_PFIFO_PIO_TIMESLICE_SELECT_32K                0x00007fff /* RW--V */
-#define NV_PFIFO_PIO_TIMESLICE_SELECT_64K                0x0000ffff /* RW--V */
-#define NV_PFIFO_PIO_TIMESLICE_SELECT_128K               0x0001ffff /* RW--V */
-#define NV_PFIFO_PIO_TIMESLICE_TIMEOUT                        24:24 /* RWIUF */
-#define NV_PFIFO_PIO_TIMESLICE_TIMEOUT_DISABLED          0x00000000 /* RW--V */
-#define NV_PFIFO_PIO_TIMESLICE_TIMEOUT_ENABLED           0x00000001 /* RWI-V */
-#define NV_PFIFO_TIMESLICE                               0x0000204C /* RW-4R */
-#define NV_PFIFO_TIMESLICE_TIMER                               17:0 /* RWIUF */
-#define NV_PFIFO_TIMESLICE_TIMER_EXPIRED                 0x0003FFFF /* RWI-V */
-#define NV_PFIFO_NEXT_CHANNEL                            0x00002050 /* RW-4R */
-#define NV_PFIFO_NEXT_CHANNEL_CHID                              3:0 /* RWXUF */
-#define NV_PFIFO_NEXT_CHANNEL_MODE                              8:8 /* RWXVF */
-#define NV_PFIFO_NEXT_CHANNEL_MODE_PIO                   0x00000000 /* RW--V */
-#define NV_PFIFO_NEXT_CHANNEL_MODE_DMA                   0x00000001 /* RW--V */
-#define NV_PFIFO_NEXT_CHANNEL_SWITCH                          12:12 /* RWIVF */
-#define NV_PFIFO_NEXT_CHANNEL_SWITCH_NOT_PENDING         0x00000000 /* RWI-V */
-#define NV_PFIFO_NEXT_CHANNEL_SWITCH_PENDING             0x00000001 /* RW--V */
-#define NV_PFIFO_DEBUG_0                                 0x00002080 /* R--4R */
-#define NV_PFIFO_DEBUG_0_CACHE_ERROR0                           0:0 /* R-XVF */
-#define NV_PFIFO_DEBUG_0_CACHE_ERROR0_NOT_PENDING        0x00000000 /* R---V */
-#define NV_PFIFO_DEBUG_0_CACHE_ERROR0_PENDING            0x00000001 /* R---V */
-#define NV_PFIFO_DEBUG_0_CACHE_ERROR1                           4:4 /* R-XVF */
-#define NV_PFIFO_DEBUG_0_CACHE_ERROR1_NOT_PENDING        0x00000000 /* R---V */
-#define NV_PFIFO_DEBUG_0_CACHE_ERROR1_PENDING            0x00000001 /* R---V */
-#define NV_PFIFO_INTR_0                                  0x00002100 /* RW-4R */
-#define NV_PFIFO_INTR_0_CACHE_ERROR                             0:0 /* RWXVF */
-#define NV_PFIFO_INTR_0_CACHE_ERROR_NOT_PENDING          0x00000000 /* R---V */
-#define NV_PFIFO_INTR_0_CACHE_ERROR_PENDING              0x00000001 /* R---V */
-#define NV_PFIFO_INTR_0_CACHE_ERROR_RESET                0x00000001 /* -W--V */
-#define NV_PFIFO_INTR_0_RUNOUT                                  4:4 /* RWXVF */
-#define NV_PFIFO_INTR_0_RUNOUT_NOT_PENDING               0x00000000 /* R---V */
-#define NV_PFIFO_INTR_0_RUNOUT_PENDING                   0x00000001 /* R---V */
-#define NV_PFIFO_INTR_0_RUNOUT_RESET                     0x00000001 /* -W--V */
-#define NV_PFIFO_INTR_0_RUNOUT_OVERFLOW                         8:8 /* RWXVF */
-#define NV_PFIFO_INTR_0_RUNOUT_OVERFLOW_NOT_PENDING      0x00000000 /* R---V */
-#define NV_PFIFO_INTR_0_RUNOUT_OVERFLOW_PENDING          0x00000001 /* R---V */
-#define NV_PFIFO_INTR_0_RUNOUT_OVERFLOW_RESET            0x00000001 /* -W--V */
-#define NV_PFIFO_INTR_0_DMA_PUSHER                            12:12 /* RWXVF */
-#define NV_PFIFO_INTR_0_DMA_PUSHER_NOT_PENDING           0x00000000 /* R---V */
-#define NV_PFIFO_INTR_0_DMA_PUSHER_PENDING               0x00000001 /* R---V */
-#define NV_PFIFO_INTR_0_DMA_PUSHER_RESET                 0x00000001 /* -W--V */
-#define NV_PFIFO_INTR_0_DMA_PT                                16:16 /* RWXVF */
-#define NV_PFIFO_INTR_0_DMA_PT_NOT_PENDING               0x00000000 /* R---V */
-#define NV_PFIFO_INTR_0_DMA_PT_PENDING                   0x00000001 /* R---V */
-#define NV_PFIFO_INTR_0_DMA_PT_RESET                     0x00000001 /* -W--V */
-#define NV_PFIFO_INTR_EN_0                               0x00002140 /* RW-4R */
-#define NV_PFIFO_INTR_EN_0_CACHE_ERROR                          0:0 /* RWIVF */
-#define NV_PFIFO_INTR_EN_0_CACHE_ERROR_DISABLED          0x00000000 /* RWI-V */
-#define NV_PFIFO_INTR_EN_0_CACHE_ERROR_ENABLED           0x00000001 /* RW--V */
-#define NV_PFIFO_INTR_EN_0_RUNOUT                               4:4 /* RWIVF */
-#define NV_PFIFO_INTR_EN_0_RUNOUT_DISABLED               0x00000000 /* RWI-V */
-#define NV_PFIFO_INTR_EN_0_RUNOUT_ENABLED                0x00000001 /* RW--V */
-#define NV_PFIFO_INTR_EN_0_RUNOUT_OVERFLOW                      8:8 /* RWIVF */
-#define NV_PFIFO_INTR_EN_0_RUNOUT_OVERFLOW_DISABLED      0x00000000 /* RWI-V */
-#define NV_PFIFO_INTR_EN_0_RUNOUT_OVERFLOW_ENABLED       0x00000001 /* RW--V */
-#define NV_PFIFO_INTR_EN_0_DMA_PUSHER                         12:12 /* RWIVF */
-#define NV_PFIFO_INTR_EN_0_DMA_PUSHER_DISABLED           0x00000000 /* RWI-V */
-#define NV_PFIFO_INTR_EN_0_DMA_PUSHER_ENABLED            0x00000001 /* RW--V */
-#define NV_PFIFO_INTR_EN_0_DMA_PT                             16:16 /* RWIVF */
-#define NV_PFIFO_INTR_EN_0_DMA_PT_DISABLED               0x00000000 /* RWI-V */
-#define NV_PFIFO_INTR_EN_0_DMA_PT_ENABLED                0x00000001 /* RW--V */
-#define NV_PFIFO_RAMHT                                   0x00002210 /* RW-4R */
-#define NV_PFIFO_RAMHT_BASE_ADDRESS                             8:4 /* RWIUF */
-#define NV_PFIFO_RAMHT_BASE_ADDRESS_10000                0x00000010 /* RWI-V */
-#define NV_PFIFO_RAMHT_SIZE                                   17:16 /* RWIUF */
-#define NV_PFIFO_RAMHT_SIZE_4K                           0x00000000 /* RWI-V */
-#define NV_PFIFO_RAMHT_SIZE_8K                           0x00000001 /* RW--V */
-#define NV_PFIFO_RAMHT_SIZE_16K                          0x00000002 /* RW--V */
-#define NV_PFIFO_RAMHT_SIZE_32K                          0x00000003 /* RW--V */
-#define NV_PFIFO_RAMHT_SEARCH                                 25:24 /* RWIUF */
-#define NV_PFIFO_RAMHT_SEARCH_16                         0x00000000 /* RWI-V */
-#define NV_PFIFO_RAMHT_SEARCH_32                         0x00000001 /* RW--V */
-#define NV_PFIFO_RAMHT_SEARCH_64                         0x00000002 /* RW--V */
-#define NV_PFIFO_RAMHT_SEARCH_128                        0x00000003 /* RW--V */
-#define NV_PFIFO_RAMFC                                   0x00002214 /* RW-4R */
-#define NV_PFIFO_RAMFC_BASE_ADDRESS                             8:1 /* RWIUF */
-#define NV_PFIFO_RAMFC_BASE_ADDRESS_11000                0x00000088 /* RWI-V */
-#define NV_PFIFO_RAMRO                                   0x00002218 /* RW-4R */
-#define NV_PFIFO_RAMRO_BASE_ADDRESS                             8:1 /* RWIUF */
-#define NV_PFIFO_RAMRO_BASE_ADDRESS_11200                0x00000089 /* RWI-V */
-#define NV_PFIFO_RAMRO_BASE_ADDRESS_12000                0x00000090 /* RW--V */
-#define NV_PFIFO_RAMRO_SIZE                                   16:16 /* RWIVF */
-#define NV_PFIFO_RAMRO_SIZE_512                          0x00000000 /* RWI-V */
-#define NV_PFIFO_RAMRO_SIZE_8K                           0x00000001 /* RW--V */
-#define NV_PFIFO_CACHES                                  0x00002500 /* RW-4R */
-#define NV_PFIFO_CACHES_REASSIGN                                0:0 /* RWIVF */
-#define NV_PFIFO_CACHES_REASSIGN_DISABLED                0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHES_REASSIGN_ENABLED                 0x00000001 /* RW--V */
-#define NV_PFIFO_CACHES_DMA_SUSPEND                             4:4 /* R--VF */
-#define NV_PFIFO_CACHES_DMA_SUSPEND_IDLE                 0x00000000 /* R---V */
-#define NV_PFIFO_CACHES_DMA_SUSPEND_BUSY                 0x00000001 /* R---V */
-#define NV_PFIFO_MODE                                    0x00002504 /* RW-4R */
-#define NV_PFIFO_MODE_CHANNEL_0                                 0:0 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_0_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_0_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_1                                 1:1 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_1_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_1_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_2                                 2:2 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_2_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_2_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_3                                 3:3 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_3_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_3_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_4                                 4:4 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_4_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_4_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_5                                 5:5 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_5_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_5_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_6                                 6:6 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_6_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_6_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_7                                 7:7 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_7_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_7_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_8                                 8:8 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_8_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_8_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_9                                 9:9 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_9_PIO                      0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_9_DMA                      0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_10                              10:10 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_10_PIO                     0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_10_DMA                     0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_11                              11:11 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_11_PIO                     0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_11_DMA                     0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_12                              12:12 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_12_PIO                     0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_12_DMA                     0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_13                              13:13 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_13_PIO                     0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_13_DMA                     0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_14                              14:14 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_14_PIO                     0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_14_DMA                     0x00000001 /* RW--V */
-#define NV_PFIFO_MODE_CHANNEL_15                              15:15 /* RWIVF */
-#define NV_PFIFO_MODE_CHANNEL_15_PIO                     0x00000000 /* RWI-V */
-#define NV_PFIFO_MODE_CHANNEL_15_DMA                     0x00000001 /* RW--V */
-#define NV_PFIFO_DMA                                     0x00002508 /* RW-4R */
-#define NV_PFIFO_DMA_CHANNEL_0                                  0:0 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_0_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_0_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_1                                  1:1 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_1_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_1_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_2                                  2:2 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_2_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_2_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_3                                  3:3 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_3_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_3_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_4                                  4:4 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_4_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_4_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_5                                  5:5 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_5_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_5_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_6                                  6:6 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_6_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_6_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_7                                  7:7 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_7_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_7_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_8                                  8:8 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_8_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_8_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_9                                  9:9 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_9_NOT_PENDING               0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_9_PENDING                   0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_10                               10:10 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_10_NOT_PENDING              0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_10_PENDING                  0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_11                               11:11 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_11_NOT_PENDING              0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_11_PENDING                  0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_12                               12:12 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_12_NOT_PENDING              0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_12_PENDING                  0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_13                               13:13 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_13_NOT_PENDING              0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_13_PENDING                  0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_14                               14:14 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_14_NOT_PENDING              0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_14_PENDING                  0x00000001 /* RW--V */
-#define NV_PFIFO_DMA_CHANNEL_15                               15:15 /* RWIVF */
-#define NV_PFIFO_DMA_CHANNEL_15_NOT_PENDING              0x00000000 /* RWI-V */
-#define NV_PFIFO_DMA_CHANNEL_15_PENDING                  0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE                                    0x0000250C /* RW-4R */
-#define NV_PFIFO_SIZE_CHANNEL_0                                 0:0 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_0_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_0_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_1                                 1:1 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_1_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_1_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_2                                 2:2 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_2_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_2_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_3                                 3:3 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_3_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_3_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_4                                 4:4 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_4_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_4_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_5                                 5:5 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_5_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_5_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_6                                 6:6 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_6_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_6_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_7                                 7:7 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_7_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_7_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_8                                 8:8 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_8_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_8_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_9                                 9:9 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_9_124_BYTES                0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_9_512_BYTES                0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_10                              10:10 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_10_124_BYTES               0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_10_512_BYTES               0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_11                              11:11 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_11_124_BYTES               0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_11_512_BYTES               0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_12                              12:12 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_12_124_BYTES               0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_12_512_BYTES               0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_13                              13:13 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_13_124_BYTES               0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_13_512_BYTES               0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_14                              14:14 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_14_124_BYTES               0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_14_512_BYTES               0x00000001 /* RW--V */
-#define NV_PFIFO_SIZE_CHANNEL_15                              15:15 /* RWIVF */
-#define NV_PFIFO_SIZE_CHANNEL_15_124_BYTES               0x00000000 /* RWI-V */
-#define NV_PFIFO_SIZE_CHANNEL_15_512_BYTES               0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_PUSH0                            0x00003000 /* RW-4R */
-#define NV_PFIFO_CACHE0_PUSH0_ACCESS                            0:0 /* RWIVF */
-#define NV_PFIFO_CACHE0_PUSH0_ACCESS_DISABLED            0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE0_PUSH0_ACCESS_ENABLED             0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_PUSH0                            0x00003200 /* RW-4R */
-#define NV_PFIFO_CACHE1_PUSH0_ACCESS                            0:0 /* RWIVF */
-#define NV_PFIFO_CACHE1_PUSH0_ACCESS_DISABLED            0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE1_PUSH0_ACCESS_ENABLED             0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_PUSH1                            0x00003004 /* RW-4R */
-#define NV_PFIFO_CACHE0_PUSH1_CHID                              3:0 /* RWXUF */
-#define NV_PFIFO_CACHE1_PUSH1                            0x00003204 /* RW-4R */
-#define NV_PFIFO_CACHE1_PUSH1_CHID                              3:0 /* RWXUF */
-#define NV_PFIFO_CACHE1_PUSH1_MODE                              8:8 /* RWIVF */
-#define NV_PFIFO_CACHE1_PUSH1_MODE_PIO                   0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE1_PUSH1_MODE_DMA                   0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_PUSH                         0x00003220 /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_PUSH_ACCESS                         0:0 /* RWIVF */
-#define NV_PFIFO_CACHE1_DMA_PUSH_ACCESS_DISABLED         0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE1_DMA_PUSH_ACCESS_ENABLED          0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_PUSH_STATE                          4:4 /* R--VF */
-#define NV_PFIFO_CACHE1_DMA_PUSH_STATE_IDLE              0x00000000 /* R---V */
-#define NV_PFIFO_CACHE1_DMA_PUSH_STATE_BUSY              0x00000001 /* R---V */
-#define NV_PFIFO_CACHE1_DMA_PUSH_BUFFER                         8:8 /* R--VF */
-#define NV_PFIFO_CACHE1_DMA_PUSH_BUFFER_NOT_EMPTY        0x00000000 /* R---V */
-#define NV_PFIFO_CACHE1_DMA_PUSH_BUFFER_EMPTY            0x00000001 /* R---V */
-#define NV_PFIFO_CACHE1_DMA_PUSH_STATUS                       12:12 /* RWIVF */
-#define NV_PFIFO_CACHE1_DMA_PUSH_STATUS_RUNNING          0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE1_DMA_PUSH_STATUS_SUSPENDED        0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH                        0x00003224 /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG                          7:3 /* RWIUF */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_8_BYTES           0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_16_BYTES          0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_24_BYTES          0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_32_BYTES          0x00000003 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_40_BYTES          0x00000004 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_48_BYTES          0x00000005 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_56_BYTES          0x00000006 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_64_BYTES          0x00000007 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_72_BYTES          0x00000008 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_80_BYTES          0x00000009 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_88_BYTES          0x0000000A /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_96_BYTES          0x0000000B /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_104_BYTES         0x0000000C /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_112_BYTES         0x0000000D /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_120_BYTES         0x0000000E /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_128_BYTES         0x0000000F /* RWI-V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_136_BYTES         0x00000010 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_144_BYTES         0x00000011 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_152_BYTES         0x00000012 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_160_BYTES         0x00000013 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_168_BYTES         0x00000014 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_176_BYTES         0x00000015 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_184_BYTES         0x00000016 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_192_BYTES         0x00000017 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_200_BYTES         0x00000018 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_208_BYTES         0x00000019 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_216_BYTES         0x0000001A /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_224_BYTES         0x0000001B /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_232_BYTES         0x0000001C /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_240_BYTES         0x0000001D /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_248_BYTES         0x0000001E /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_TRIG_256_BYTES         0x0000001F /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_SIZE                        15:13 /* RWIUF */
-#define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_32_BYTES          0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_64_BYTES          0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_96_BYTES          0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_128_BYTES         0x00000003 /* RWI-V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_160_BYTES         0x00000004 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_192_BYTES         0x00000005 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_224_BYTES         0x00000006 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_SIZE_256_BYTES         0x00000007 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS                    19:16 /* RWIUF */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_0             0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_1             0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_2             0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_3             0x00000003 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_4             0x00000004 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_5             0x00000005 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_6             0x00000006 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_7             0x00000007 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_8             0x00000008 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_9             0x00000009 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_10            0x0000000A /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_11            0x0000000B /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_12            0x0000000C /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_13            0x0000000D /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_14            0x0000000E /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_FETCH_MAX_REQS_15            0x0000000F /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_PUT                          0x00003240 /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_PUT_OFFSET                         28:2 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_GET                          0x00003244 /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_GET_OFFSET                         28:2 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_STATE                        0x00003228 /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_STATE_METHOD                       12:2 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_STATE_SUBCHANNEL                  15:13 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_STATE_METHOD_COUNT                28:18 /* RWIUF */
-#define NV_PFIFO_CACHE1_DMA_STATE_METHOD_COUNT_0         0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE1_DMA_STATE_ERROR                       31:30 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_STATE_ERROR_NONE             0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_STATE_ERROR_NON_CACHE        0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_STATE_ERROR_RESERVED_CMD     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_STATE_ERROR_PROTECTION       0x00000003 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_INSTANCE                     0x0000322C /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_INSTANCE_ADDRESS                   15:0 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_CTL                          0x00003230 /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_CTL_ADJUST                         11:2 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_CTL_PAGE_TABLE                    12:12 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_CTL_PAGE_TABLE_NOT_PRESENT   0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_CTL_PAGE_TABLE_PRESENT       0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_CTL_PAGE_ENTRY                    13:13 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_CTL_PAGE_ENTRY_NOT_LINEAR    0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_CTL_PAGE_ENTRY_LINEAR        0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_CTL_TARGET_NODE                   17:16 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_CTL_TARGET_NODE_PCI          0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_CTL_TARGET_NODE_AGP          0x00000003 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_CTL_AT_INFO                       31:31 /* RWIUF */
-#define NV_PFIFO_CACHE1_DMA_CTL_AT_INFO_INVALID          0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_CTL_AT_INFO_VALID            0x00000001 /* RWI-V */
-#define NV_PFIFO_CACHE1_DMA_LIMIT                        0x00003234 /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_LIMIT_OFFSET                       28:2 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_TLB_TAG                      0x00003238 /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_TLB_TAG_ADDRESS                   28:12 /* RWXUF */
-#define NV_PFIFO_CACHE1_DMA_TLB_TAG_STATE                       0:0 /* RWIUF */
-#define NV_PFIFO_CACHE1_DMA_TLB_TAG_STATE_INVALID        0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE1_DMA_TLB_TAG_STATE_VALID          0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_DMA_TLB_PTE                      0x0000323C /* RW-4R */
-#define NV_PFIFO_CACHE1_DMA_TLB_PTE_FRAME_ADDRESS             31:12 /* RWXUF */
-#define NV_PFIFO_CACHE0_PULL0                            0x00003050 /* RW-4R */
-#define NV_PFIFO_CACHE0_PULL0_ACCESS                            0:0 /* RWIVF */
-#define NV_PFIFO_CACHE0_PULL0_ACCESS_DISABLED            0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE0_PULL0_ACCESS_ENABLED             0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_PULL0_HASH                              4:4 /* R-XVF */
-#define NV_PFIFO_CACHE0_PULL0_HASH_SUCCEEDED             0x00000000 /* R---V */
-#define NV_PFIFO_CACHE0_PULL0_HASH_FAILED                0x00000001 /* R---V */
-#define NV_PFIFO_CACHE0_PULL0_DEVICE                            8:8 /* R-XVF */
-#define NV_PFIFO_CACHE0_PULL0_DEVICE_HARDWARE            0x00000000 /* R---V */
-#define NV_PFIFO_CACHE0_PULL0_DEVICE_SOFTWARE            0x00000001 /* R---V */
-#define NV_PFIFO_CACHE0_PULL0_HASH_STATE                      12:12 /* R-XVF */
-#define NV_PFIFO_CACHE0_PULL0_HASH_STATE_IDLE            0x00000000 /* R---V */
-#define NV_PFIFO_CACHE0_PULL0_HASH_STATE_BUSY            0x00000001 /* R---V */
-#define NV_PFIFO_CACHE1_PULL0                            0x00003250 /* RW-4R */
-#define NV_PFIFO_CACHE1_PULL0_ACCESS                            0:0 /* RWIVF */
-#define NV_PFIFO_CACHE1_PULL0_ACCESS_DISABLED            0x00000000 /* RWI-V */
-#define NV_PFIFO_CACHE1_PULL0_ACCESS_ENABLED             0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_PULL0_HASH                              4:4 /* R-XVF */
-#define NV_PFIFO_CACHE1_PULL0_HASH_SUCCEEDED             0x00000000 /* R---V */
-#define NV_PFIFO_CACHE1_PULL0_HASH_FAILED                0x00000001 /* R---V */
-#define NV_PFIFO_CACHE1_PULL0_DEVICE                            8:8 /* R-XVF */
-#define NV_PFIFO_CACHE1_PULL0_DEVICE_HARDWARE            0x00000000 /* R---V */
-#define NV_PFIFO_CACHE1_PULL0_DEVICE_SOFTWARE            0x00000001 /* R---V */
-#define NV_PFIFO_CACHE1_PULL0_HASH_STATE                      12:12 /* R-XVF */
-#define NV_PFIFO_CACHE1_PULL0_HASH_STATE_IDLE            0x00000000 /* R---V */
-#define NV_PFIFO_CACHE1_PULL0_HASH_STATE_BUSY            0x00000001 /* R---V */
-#define NV_PFIFO_CACHE0_PULL1                            0x00003054 /* RW-4R */
-#define NV_PFIFO_CACHE0_PULL1_ENGINE                            1:0 /* RWXUF */
-#define NV_PFIFO_CACHE0_PULL1_ENGINE_SW                  0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE0_PULL1_ENGINE_GRAPHICS            0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_PULL1_ENGINE_DVD                 0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_PULL1                            0x00003254 /* RW-4R */
-#define NV_PFIFO_CACHE1_PULL1_ENGINE                            1:0 /* RWXUF */
-#define NV_PFIFO_CACHE1_PULL1_ENGINE_SW                  0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_PULL1_ENGINE_GRAPHICS            0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_PULL1_ENGINE_DVD                 0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE0_HASH                             0x00003058 /* RW-4R */
-#define NV_PFIFO_CACHE0_HASH_INSTANCE                          15:0 /* RWXUF */
-#define NV_PFIFO_CACHE0_HASH_VALID                            16:16 /* RWXVF */
-#define NV_PFIFO_CACHE1_HASH                             0x00003258 /* RW-4R */
-#define NV_PFIFO_CACHE1_HASH_INSTANCE                          15:0 /* RWXUF */
-#define NV_PFIFO_CACHE1_HASH_VALID                            16:16 /* RWXVF */
-#define NV_PFIFO_CACHE0_STATUS                           0x00003014 /* R--4R */
-#define NV_PFIFO_CACHE0_STATUS_LOW_MARK                         4:4 /* R--VF */
-#define NV_PFIFO_CACHE0_STATUS_LOW_MARK_NOT_EMPTY        0x00000000 /* R---V */
-#define NV_PFIFO_CACHE0_STATUS_LOW_MARK_EMPTY            0x00000001 /* R---V */
-#define NV_PFIFO_CACHE0_STATUS_HIGH_MARK                        8:8 /* R--VF */
-#define NV_PFIFO_CACHE0_STATUS_HIGH_MARK_NOT_FULL        0x00000000 /* R---V */
-#define NV_PFIFO_CACHE0_STATUS_HIGH_MARK_FULL            0x00000001 /* R---V */
-#define NV_PFIFO_CACHE1_STATUS                           0x00003214 /* R--4R */
-#define NV_PFIFO_CACHE1_STATUS_LOW_MARK                         4:4 /* R--VF */
-#define NV_PFIFO_CACHE1_STATUS_LOW_MARK_NOT_EMPTY        0x00000000 /* R---V */
-#define NV_PFIFO_CACHE1_STATUS_LOW_MARK_EMPTY            0x00000001 /* R---V */
-#define NV_PFIFO_CACHE1_STATUS_HIGH_MARK                        8:8 /* R--VF */
-#define NV_PFIFO_CACHE1_STATUS_HIGH_MARK_NOT_FULL        0x00000000 /* R---V */
-#define NV_PFIFO_CACHE1_STATUS_HIGH_MARK_FULL            0x00000001 /* R---V */
-#define NV_PFIFO_CACHE1_STATUS1                          0x00003218 /* R--4R */
-#define NV_PFIFO_CACHE1_STATUS1_RANOUT                          0:0 /* R-XVF */
-#define NV_PFIFO_CACHE1_STATUS1_RANOUT_FALSE             0x00000000 /* R---V */
-#define NV_PFIFO_CACHE1_STATUS1_RANOUT_TRUE              0x00000001 /* R---V */
-#define NV_PFIFO_CACHE0_PUT                              0x00003010 /* RW-4R */
-#define NV_PFIFO_CACHE0_PUT_ADDRESS                             2:2 /* RWXUF */
-#define NV_PFIFO_CACHE1_PUT                              0x00003210 /* RW-4R */
-#define NV_PFIFO_CACHE1_PUT_ADDRESS                             9:2 /* RWXUF */
-#define NV_PFIFO_CACHE0_GET                              0x00003070 /* RW-4R */
-#define NV_PFIFO_CACHE0_GET_ADDRESS                             2:2 /* RWXUF */
-#define NV_PFIFO_CACHE1_GET                              0x00003270 /* RW-4R */
-#define NV_PFIFO_CACHE1_GET_ADDRESS                             9:2 /* RWXUF */
-#define NV_PFIFO_CACHE0_ENGINE                           0x00003080 /* RW-4R */
-#define NV_PFIFO_CACHE0_ENGINE_0                                1:0 /* RWXUF */
-#define NV_PFIFO_CACHE0_ENGINE_0_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_0_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_0_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_1                                5:4 /* RWXUF */
-#define NV_PFIFO_CACHE0_ENGINE_1_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_1_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_1_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_2                                9:8 /* RWXUF */
-#define NV_PFIFO_CACHE0_ENGINE_2_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_2_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_2_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_3                              13:12 /* RWXUF */
-#define NV_PFIFO_CACHE0_ENGINE_3_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_3_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_3_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_4                              17:16 /* RWXUF */
-#define NV_PFIFO_CACHE0_ENGINE_4_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_4_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_4_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_5                              21:20 /* RWXUF */
-#define NV_PFIFO_CACHE0_ENGINE_5_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_5_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_5_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_6                              25:24 /* RWXUF */
-#define NV_PFIFO_CACHE0_ENGINE_6_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_6_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_6_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_7                              29:28 /* RWXUF */
-#define NV_PFIFO_CACHE0_ENGINE_7_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_7_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE0_ENGINE_7_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE                           0x00003280 /* RW-4R */
-#define NV_PFIFO_CACHE1_ENGINE_0                                1:0 /* RWXUF */
-#define NV_PFIFO_CACHE1_ENGINE_0_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_0_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_0_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_1                                5:4 /* RWXUF */
-#define NV_PFIFO_CACHE1_ENGINE_1_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_1_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_1_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_2                                9:8 /* RWXUF */
-#define NV_PFIFO_CACHE1_ENGINE_2_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_2_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_2_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_3                              13:12 /* RWXUF */
-#define NV_PFIFO_CACHE1_ENGINE_3_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_3_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_3_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_4                              17:16 /* RWXUF */
-#define NV_PFIFO_CACHE1_ENGINE_4_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_4_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_4_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_5                              21:20 /* RWXUF */
-#define NV_PFIFO_CACHE1_ENGINE_5_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_5_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_5_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_6                              25:24 /* RWXUF */
-#define NV_PFIFO_CACHE1_ENGINE_6_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_6_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_6_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_7                              29:28 /* RWXUF */
-#define NV_PFIFO_CACHE1_ENGINE_7_SW                      0x00000000 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_7_GRAPHICS                0x00000001 /* RW--V */
-#define NV_PFIFO_CACHE1_ENGINE_7_DVD                     0x00000002 /* RW--V */
-#define NV_PFIFO_CACHE0_METHOD(i)                (0x00003100+(i)*8) /* RW-4A */
-#define NV_PFIFO_CACHE0_METHOD__SIZE_1                            1 /*       */
-#define NV_PFIFO_CACHE0_METHOD_ADDRESS                         12:2 /* RWXUF */
-#define NV_PFIFO_CACHE0_METHOD_SUBCHANNEL                     15:13 /* RWXUF */
-#define NV_PFIFO_CACHE1_METHOD(i)                (0x00003800+(i)*8) /* RW-4A */
-#define NV_PFIFO_CACHE1_METHOD__SIZE_1                          128 /*       */
-#define NV_PFIFO_CACHE1_METHOD_ADDRESS                         12:2 /* RWXUF */
-#define NV_PFIFO_CACHE1_METHOD_SUBCHANNEL                     15:13 /* RWXUF */
-#define NV_PFIFO_CACHE1_METHOD_ALIAS(i)          (0x00003C00+(i)*8) /* RW-4A */
-#define NV_PFIFO_CACHE1_METHOD_ALIAS__SIZE_1                    128 /*       */
-#define NV_PFIFO_CACHE0_DATA(i)                  (0x00003104+(i)*8) /* RW-4A */
-#define NV_PFIFO_CACHE0_DATA__SIZE_1                              1 /*       */
-#define NV_PFIFO_CACHE0_DATA_VALUE                             31:0 /* RWXVF */
-#define NV_PFIFO_CACHE1_DATA(i)                  (0x00003804+(i)*8) /* RW-4A */
-#define NV_PFIFO_CACHE1_DATA__SIZE_1                            128 /*       */
-#define NV_PFIFO_CACHE1_DATA_VALUE                             31:0 /* RWXVF */
-#define NV_PFIFO_CACHE1_DATA_ALIAS(i)            (0x00003C04+(i)*8) /* RW-4A */
-#define NV_PFIFO_CACHE1_DATA_ALIAS__SIZE_1                      128 /*       */
-#define NV_PFIFO_DEVICE(i)                       (0x00002800+(i)*4) /* R--4A */
-#define NV_PFIFO_DEVICE__SIZE_1                                 128 /*       */
-#define NV_PFIFO_DEVICE_CHID                                    3:0 /* R--UF */
-#define NV_PFIFO_DEVICE_SWITCH                                24:24 /* R--VF */
-#define NV_PFIFO_DEVICE_SWITCH_UNAVAILABLE               0x00000000 /* R---V */
-#define NV_PFIFO_DEVICE_SWITCH_AVAILABLE                 0x00000001 /* R---V */
-#define NV_PFIFO_RUNOUT_STATUS                           0x00002400 /* R--4R */
-#define NV_PFIFO_RUNOUT_STATUS_RANOUT                           0:0 /* R--VF */
-#define NV_PFIFO_RUNOUT_STATUS_RANOUT_FALSE              0x00000000 /* R---V */
-#define NV_PFIFO_RUNOUT_STATUS_RANOUT_TRUE               0x00000001 /* R---V */
-#define NV_PFIFO_RUNOUT_STATUS_LOW_MARK                         4:4 /* R--VF */
-#define NV_PFIFO_RUNOUT_STATUS_LOW_MARK_NOT_EMPTY        0x00000000 /* R---V */
-#define NV_PFIFO_RUNOUT_STATUS_LOW_MARK_EMPTY            0x00000001 /* R---V */
-#define NV_PFIFO_RUNOUT_STATUS_HIGH_MARK                        8:8 /* R--VF */
-#define NV_PFIFO_RUNOUT_STATUS_HIGH_MARK_NOT_FULL        0x00000000 /* R---V */
-#define NV_PFIFO_RUNOUT_STATUS_HIGH_MARK_FULL            0x00000001 /* R---V */
-#define NV_PFIFO_RUNOUT_PUT                              0x00002410 /* RW-4R */
-#define NV_PFIFO_RUNOUT_PUT_ADDRESS                            12:3 /* RWXUF */
-#define NV_PFIFO_RUNOUT_PUT_ADDRESS__SIZE_0                     8:3 /* RWXUF */
-#define NV_PFIFO_RUNOUT_PUT_ADDRESS__SIZE_1                    12:3 /* RWXUF */
-#define NV_PFIFO_RUNOUT_GET                              0x00002420 /* RW-4R */
-#define NV_PFIFO_RUNOUT_GET_ADDRESS                            13:3 /* RWXUF */
-/* dev_graphics.ref */
-#define NV_PGRAPH                             0x00401FFF:0x00400000 /* RW--D */
-#define NV_PGRAPH_DEBUG_0                                0x00400080 /* RW-4R */
-#define NV_PGRAPH_DEBUG_1                                0x00400084 /* RW-4R */
-#define NV_PGRAPH_DEBUG_2                                0x00400088 /* RW-4R */
-#define NV_PGRAPH_DEBUG_3                                0x0040008C /* RW-4R */
-#define NV_PGRAPH_INTR                                   0x00400100 /* RW-4R */
-#define NV_PGRAPH_INTR_NOTIFY                                   0:0 /* RWIVF */
-#define NV_PGRAPH_INTR_NOTIFY_NOT_PENDING                0x00000000 /* R-I-V */
-#define NV_PGRAPH_INTR_NOTIFY_PENDING                    0x00000001 /* R---V */
-#define NV_PGRAPH_INTR_NOTIFY_RESET                      0x00000001 /* -W--C */
-#define NV_PGRAPH_INTR_MISSING_HW                               4:4 /* RWIVF */
-#define NV_PGRAPH_INTR_MISSING_HW_NOT_PENDING            0x00000000 /* R-I-V */
-#define NV_PGRAPH_INTR_MISSING_HW_PENDING                0x00000001 /* R---V */
-#define NV_PGRAPH_INTR_MISSING_HW_RESET                  0x00000001 /* -W--C */
-#define NV_PGRAPH_INTR_TLB_PRESENT_A                            8:8 /* RWIVF */
-#define NV_PGRAPH_INTR_TLB_PRESENT_A_NOT_PENDING         0x00000000 /* R-I-V */
-#define NV_PGRAPH_INTR_TLB_PRESENT_A_PENDING             0x00000001 /* R---V */
-#define NV_PGRAPH_INTR_TLB_PRESENT_A_RESET               0x00000001 /* -W--C */
-#define NV_PGRAPH_INTR_TLB_PRESENT_B                            9:9 /* RWIVF */
-#define NV_PGRAPH_INTR_TLB_PRESENT_B_NOT_PENDING         0x00000000 /* R-I-V */
-#define NV_PGRAPH_INTR_TLB_PRESENT_B_PENDING             0x00000001 /* R---V */
-#define NV_PGRAPH_INTR_TLB_PRESENT_B_RESET               0x00000001 /* -W--C */
-#define NV_PGRAPH_INTR_CONTEXT_SWITCH                         12:12 /* RWIVF */
-#define NV_PGRAPH_INTR_CONTEXT_SWITCH_NOT_PENDING        0x00000000 /* R-I-V */
-#define NV_PGRAPH_INTR_CONTEXT_SWITCH_PENDING            0x00000001 /* R---V */
-#define NV_PGRAPH_INTR_CONTEXT_SWITCH_RESET              0x00000001 /* -W--C */
-#define NV_PGRAPH_INTR_BUFFER_NOTIFY                          16:16 /* RWIVF */
-#define NV_PGRAPH_INTR_BUFFER_NOTIFY_NOT_PENDING         0x00000000 /* R-I-V */
-#define NV_PGRAPH_INTR_BUFFER_NOTIFY_PENDING             0x00000001 /* R---V */
-#define NV_PGRAPH_INTR_BUFFER_NOTIFY_RESET               0x00000001 /* -W--C */
-#define NV_PGRAPH_NSTATUS                                0x00400104 /* RW-4R */
-#define NV_PGRAPH_NSTATUS_STATE_IN_USE                        11:11 /* RWIVF */
-#define NV_PGRAPH_NSTATUS_STATE_IN_USE_NOT_PENDING       0x00000000 /* RWI-V */
-#define NV_PGRAPH_NSTATUS_STATE_IN_USE_PENDING           0x00000001 /* RW--V */
-#define NV_PGRAPH_NSTATUS_INVALID_STATE                       12:12 /* RWIVF */
-#define NV_PGRAPH_NSTATUS_INVALID_STATE_NOT_PENDING      0x00000000 /* RWI-V */
-#define NV_PGRAPH_NSTATUS_INVALID_STATE_PENDING          0x00000001 /* RW--V */
-#define NV_PGRAPH_NSTATUS_BAD_ARGUMENT                        13:13 /* RWIVF */
-#define NV_PGRAPH_NSTATUS_BAD_ARGUMENT_NOT_PENDING       0x00000000 /* RWI-V */
-#define NV_PGRAPH_NSTATUS_BAD_ARGUMENT_PENDING           0x00000001 /* RW--V */
-#define NV_PGRAPH_NSTATUS_PROTECTION_FAULT                    14:14 /* RWIVF */
-#define NV_PGRAPH_NSTATUS_PROTECTION_FAULT_NOT_PENDING   0x00000000 /* RWI-V */
-#define NV_PGRAPH_NSTATUS_PROTECTION_FAULT_PENDING       0x00000001 /* RW--V */
-#define NV_PGRAPH_NSOURCE                                0x00400108 /* R--4R */
-#define NV_PGRAPH_NSOURCE_NOTIFICATION                          0:0 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_NOTIFICATION_NOT_PENDING       0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_NOTIFICATION_PENDING           0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_DATA_ERROR                            1:1 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_DATA_ERROR_NOT_PENDING         0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_DATA_ERROR_PENDING             0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_PROTECTION_ERROR                      2:2 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_PROTECTION_ERROR_NOT_PENDING   0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_PROTECTION_ERROR_PENDING       0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_RANGE_EXCEPTION                       3:3 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_RANGE_EXCEPTION_NOT_PENDING    0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_RANGE_EXCEPTION_PENDING        0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_LIMIT_COLOR                           4:4 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_LIMIT_COLOR_NOT_PENDING        0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_LIMIT_COLOR_PENDING            0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_LIMIT_ZETA_                           5:5 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_LIMIT_ZETA_NOT_PENDING         0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_LIMIT_ZETA_PENDING             0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_ILLEGAL_MTHD                          6:6 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_ILLEGAL_MTHD_NOT_PENDING       0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_ILLEGAL_MTHD_PENDING           0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_DMA_R_PROTECTION                      7:7 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_DMA_R_PROTECTION_NOT_PENDING   0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_DMA_R_PROTECTION_PENDING       0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_DMA_W_PROTECTION                      8:8 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_DMA_W_PROTECTION_NOT_PENDING   0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_DMA_W_PROTECTION_PENDING       0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_FORMAT_EXCEPTION                      9:9 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_FORMAT_EXCEPTION_NOT_PENDING   0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_FORMAT_EXCEPTION_PENDING       0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_PATCH_EXCEPTION                     10:10 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_PATCH_EXCEPTION_NOT_PENDING    0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_PATCH_EXCEPTION_PENDING        0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_STATE_INVALID                       11:11 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_STATE_INVALID_NOT_PENDING      0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_STATE_INVALID_PENDING          0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_DOUBLE_NOTIFY                       12:12 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_DOUBLE_NOTIFY_NOT_PENDING      0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_DOUBLE_NOTIFY_PENDING          0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_NOTIFY_IN_USE                       13:13 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_NOTIFY_IN_USE_NOT_PENDING      0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_NOTIFY_IN_USE_PENDING          0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_METHOD_CNT                          14:14 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_METHOD_CNT_NOT_PENDING         0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_METHOD_CNT_PENDING             0x00000001 /* R---V */
-#define NV_PGRAPH_NSOURCE_BFR_NOTIFICATION                    15:15 /* R-IVF */
-#define NV_PGRAPH_NSOURCE_BFR_NOTIFICATION_NOT_PENDING   0x00000000 /* R-I-V */
-#define NV_PGRAPH_NSOURCE_BFR_NOTIFICATION_PENDING       0x00000001 /* R---V */
-#define NV_PGRAPH_INTR_EN                                0x00400140 /* RW-4R */
-#define NV_PGRAPH_INTR_EN_NOTIFY                                0:0 /* RWIVF */
-#define NV_PGRAPH_INTR_EN_NOTIFY_DISABLED                0x00000000 /* RWI-V */
-#define NV_PGRAPH_INTR_EN_NOTIFY_ENABLED                 0x00000001 /* RW--V */
-#define NV_PGRAPH_INTR_EN_MISSING_HW                            4:4 /* RWIVF */
-#define NV_PGRAPH_INTR_EN_MISSING_HW_DISABLED            0x00000000 /* RWI-V */
-#define NV_PGRAPH_INTR_EN_MISSING_HW_ENABLED             0x00000001 /* RW--V */
-#define NV_PGRAPH_INTR_EN_TLB_PRESENT_A                         8:8 /* RWIVF */
-#define NV_PGRAPH_INTR_EN_TLB_PRESENT_A_DISABLED         0x00000000 /* RWI-V */
-#define NV_PGRAPH_INTR_EN_TLB_PRESENT_A_ENABLED          0x00000001 /* RW--V */
-#define NV_PGRAPH_INTR_EN_TLB_PRESENT_B                         9:9 /* RWIVF */
-#define NV_PGRAPH_INTR_EN_TLB_PRESENT_B_DISABLED         0x00000000 /* RWI-V */
-#define NV_PGRAPH_INTR_EN_TLB_PRESENT_B_ENABLED          0x00000001 /* RW--V */
-#define NV_PGRAPH_INTR_EN_CONTEXT_SWITCH                      12:12 /* RWIVF */
-#define NV_PGRAPH_INTR_EN_CONTEXT_SWITCH_DISABLED        0x00000000 /* RWI-V */
-#define NV_PGRAPH_INTR_EN_CONTEXT_SWITCH_ENABLED         0x00000001 /* RW--V */
-#define NV_PGRAPH_INTR_EN_BUFFER_NOTIFY                       16:16 /* RWIVF */
-#define NV_PGRAPH_INTR_EN_BUFFER_NOTIFY_DISABLED         0x00000000 /* RWI-V */
-#define NV_PGRAPH_INTR_EN_BUFFER_NOTIFY_ENABLED          0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1                            0x00400160 /* RW-4R */
-#define NV_PGRAPH_CTX_SWITCH1_GRCLASS                           7:0 /* RWXVF */
-#define NV_PGRAPH_CTX_SWITCH1_CHROMA_KEY                      12:12 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH1_CHROMA_KEY_DISABLE         0x00000000 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_CHROMA_KEY_ENABLE          0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_USER_CLIP                       13:13 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH1_USER_CLIP_DISABLE          0x00000000 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_USER_CLIP_ENABLE           0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_SWIZZLE                         14:14 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH1_SWIZZLE_DISABLE            0x00000000 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_SWIZZLE_ENABLE             0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_CONFIG                    17:15 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_CONFIG_SRCCOPY_AND   0x00000000 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_CONFIG_ROP_AND       0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_CONFIG_BLEND_AND     0x00000002 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_CONFIG_SRCCOPY       0x00000003 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_CONFIG_SRCCOPY_PRE   0x00000004 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_CONFIG_BLEND_PRE     0x00000005 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_STATUS                    24:24 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_STATUS_INVALID       0x00000000 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_PATCH_STATUS_VALID         0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_CONTEXT_SURFACE                 25:25 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH1_CONTEXT_SURFACE_INVALID    0x00000000 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_CONTEXT_SURFACE_VALID      0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH1_VOLATILE_RESET                  31:31 /* CWIVF */
-#define NV_PGRAPH_CTX_SWITCH1_VOLATILE_RESET_IGNORE      0x00000000 /* CWI-V */
-#define NV_PGRAPH_CTX_SWITCH1_VOLATILE_RESET_ENABLED     0x00000001 /* -W--T */
-#define NV_PGRAPH_CTX_SWITCH2                            0x00400164 /* RW-4R */
-#define NV_PGRAPH_CTX_SWITCH2_MONO_FORMAT                       1:0 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH2_MONO_FORMAT_INVALID              0x00 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_MONO_FORMAT_CGA6_M1              0x01 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_MONO_FORMAT_LE_M1                0x02 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT                     13:8 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_INVALID             0x00 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_Y8               0x01 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_X16A8Y8          0x02 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_X24Y8            0x03 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_A1R5G5B5         0x06 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_X1R5G5B5         0x07 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_X16A1R5G5B5      0x08 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_X17R5G5B5        0x09 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_R5G6B5           0x0A /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_A16R5G6B5        0x0B /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_X16R5G6B5        0x0C /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_A8R8G8B8         0x0D /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_X8R8G8B8         0x0E /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_Y16              0x0F /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_A16Y16           0x10 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_X16Y16           0x11 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_V8YB8U8YA8       0x12 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_YB8V8YA8U8       0x13 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_COLOR_FORMAT_LE_Y32              0x14 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH2_NOTIFY_INSTANCE                 31:16 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH2_NOTIFY_INSTANCE_INVALID        0x0000 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH3                            0x00400168 /* RW-4R */
-#define NV_PGRAPH_CTX_SWITCH3_DMA_INSTANCE_0                   15:0 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH3_DMA_INSTANCE_0_INVALID         0x0000 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH3_DMA_INSTANCE_1                  31:16 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH3_DMA_INSTANCE_1_INVALID         0x0000 /* RW--V */
-#define NV_PGRAPH_CTX_SWITCH4                            0x0040016C /* RW-4R */
-#define NV_PGRAPH_CTX_SWITCH4_USER_INSTANCE                    15:0 /* RWXUF */
-#define NV_PGRAPH_CTX_SWITCH4_USER_INSTANCE_INVALID          0x0000 /* RW--V */
-#define NV_PGRAPH_CTX_CACHE1(i)                  (0x00400180+(i)*4) /* RW-4A */
-#define NV_PGRAPH_CTX_CACHE1__SIZE_1                              8 /*       */
-#define NV_PGRAPH_CTX_CACHE1_GRCLASS                            7:0 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE1_CHROMA_KEY                       12:12 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE1_USER_CLIP                        13:13 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE1_SWIZZLE                          14:14 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE1_PATCH_CONFIG                     19:15 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE1_SPARE1                           20:20 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE1_PATCH_STATUS                     24:24 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE1_CONTEXT_SURFACE                  25:25 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE2(i)                  (0x004001a0+(i)*4) /* RW-4A */
-#define NV_PGRAPH_CTX_CACHE2__SIZE_1                              8 /*       */
-#define NV_PGRAPH_CTX_CACHE2_MONO_FORMAT                        1:0 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE2_COLOR_FORMAT                      13:8 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE2_NOTIFY_INSTANCE                  31:16 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE3(i)                  (0x004001c0+(i)*4) /* RW-4A */
-#define NV_PGRAPH_CTX_CACHE3__SIZE_1                              8 /*       */
-#define NV_PGRAPH_CTX_CACHE3_DMA_INSTANCE_0                    15:0 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE3_DMA_INSTANCE_1                   31:16 /* RWXVF */
-#define NV_PGRAPH_CTX_CACHE4(i)                  (0x004001e0+(i)*4) /* RW-4A */
-#define NV_PGRAPH_CTX_CACHE4__SIZE_1                              8 /*       */
-#define NV_PGRAPH_CTX_CACHE4_USER_INSTANCE                     15:0 /* RWXVF */
-#define NV_PGRAPH_CTX_CONTROL                            0x00400170 /* RW-4R */
-#define NV_PGRAPH_CTX_CONTROL_MINIMUM_TIME                      1:0 /* RWIVF */
-#define NV_PGRAPH_CTX_CONTROL_MINIMUM_TIME_33US          0x00000000 /* RWI-V */
-#define NV_PGRAPH_CTX_CONTROL_MINIMUM_TIME_262US         0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_CONTROL_MINIMUM_TIME_2MS           0x00000002 /* RW--V */
-#define NV_PGRAPH_CTX_CONTROL_MINIMUM_TIME_17MS          0x00000003 /* RW--V */
-#define NV_PGRAPH_CTX_CONTROL_TIME                              8:8 /* RWIVF */
-#define NV_PGRAPH_CTX_CONTROL_TIME_EXPIRED               0x00000000 /* RWI-V */
-#define NV_PGRAPH_CTX_CONTROL_TIME_NOT_EXPIRED           0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_CONTROL_CHID                            16:16 /* RWIVF */
-#define NV_PGRAPH_CTX_CONTROL_CHID_INVALID               0x00000000 /* RWI-V */
-#define NV_PGRAPH_CTX_CONTROL_CHID_VALID                 0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_CONTROL_CHANGE                          20:20 /* R--VF */
-#define NV_PGRAPH_CTX_CONTROL_CHANGE_UNAVAILABLE         0x00000000 /* R---V */
-#define NV_PGRAPH_CTX_CONTROL_CHANGE_AVAILABLE           0x00000001 /* R---V */
-#define NV_PGRAPH_CTX_CONTROL_SWITCHING                       24:24 /* RWIVF */
-#define NV_PGRAPH_CTX_CONTROL_SWITCHING_IDLE             0x00000000 /* RWI-V */
-#define NV_PGRAPH_CTX_CONTROL_SWITCHING_BUSY             0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_CONTROL_DEVICE                          28:28 /* RWIVF */
-#define NV_PGRAPH_CTX_CONTROL_DEVICE_DISABLED            0x00000000 /* RWI-V */
-#define NV_PGRAPH_CTX_CONTROL_DEVICE_ENABLED             0x00000001 /* RW--V */
-#define NV_PGRAPH_CTX_USER                               0x00400174 /* RW-4R */
-#define NV_PGRAPH_CTX_USER_SUBCH                              15:13 /* RWIVF */
-#define NV_PGRAPH_CTX_USER_SUBCH_0                       0x00000000 /* RWI-V */
-#define NV_PGRAPH_CTX_USER_CHID                               27:24 /* RWIVF */
-#define NV_PGRAPH_CTX_USER_CHID_0                        0x00000000 /* RWI-V */
-#define NV_PGRAPH_FIFO                                   0x00400720 /* RW-4R */
-#define NV_PGRAPH_FIFO_ACCESS                                   0:0 /* RWIVF */
-#define NV_PGRAPH_FIFO_ACCESS_DISABLED                   0x00000000 /* RW--V */
-#define NV_PGRAPH_FIFO_ACCESS_ENABLED                    0x00000001 /* RWI-V */
-#define NV_PGRAPH_FFINTFC_FIFO_0(i)              (0x00400730+(i)*4) /* RW-4A */
-#define NV_PGRAPH_FFINTFC_FIFO_0__SIZE_1                          4 /*       */
-#define NV_PGRAPH_FFINTFC_FIFO_0_TAG                            0:0 /* RWXVF */
-#define NV_PGRAPH_FFINTFC_FIFO_0_TAG_MTHD                0x00000000 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_TAG_CHSW                0x00000001 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_SUBCH                          3:1 /* RWXVF */
-#define NV_PGRAPH_FFINTFC_FIFO_0_SUBCH_0                 0x00000000 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_SUBCH_1                 0x00000001 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_SUBCH_2                 0x00000002 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_SUBCH_3                 0x00000003 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_SUBCH_4                 0x00000004 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_SUBCH_5                 0x00000005 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_SUBCH_6                 0x00000006 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_SUBCH_7                 0x00000007 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_0_MTHD                          14:4 /* RWXVF */
-#define NV_PGRAPH_FFINTFC_FIFO_0_MTHD_CTX_SWITCH         0x00000000 /* RW--V */
-#define NV_PGRAPH_FFINTFC_FIFO_1(i)              (0x00400740+(i)*4) /* RW-4A */
-#define NV_PGRAPH_FFINTFC_FIFO_1__SIZE_1                          4 /*       */
-#define NV_PGRAPH_FFINTFC_FIFO_1_ARGUMENT                      31:0 /* RWXVF */
-#define NV_PGRAPH_FFINTFC_FIFO_PTR                       0x00400750 /* RW-4R */
-#define NV_PGRAPH_FFINTFC_FIFO_PTR_WRITE                        2:0 /* RWIVF */
-#define NV_PGRAPH_FFINTFC_FIFO_PTR_WRITE_0               0x00000000 /* RWI-V */
-#define NV_PGRAPH_FFINTFC_FIFO_PTR_READ                         6:4 /* RWIVF */
-#define NV_PGRAPH_FFINTFC_FIFO_PTR_READ_0                0x00000000 /* RWI-V */
-#define NV_PGRAPH_FFINTFC_ST2                            0x00400754 /* RW-4R */
-#define NV_PGRAPH_FFINTFC_ST2_STATUS                            0:0 /* RWIVF */
-#define NV_PGRAPH_FFINTFC_ST2_STATUS_INVALID             0x00000000 /* RWI-V */
-#define NV_PGRAPH_FFINTFC_ST2_STATUS_VALID               0x00000001 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_MTHD                             11:1 /* RWIVF */
-#define NV_PGRAPH_FFINTFC_ST2_MTHD_CTX_SWITCH            0x00000000 /* RWI-V */
-#define NV_PGRAPH_FFINTFC_ST2_SUBCH                           14:12 /* RWIVF */
-#define NV_PGRAPH_FFINTFC_ST2_SUBCH_0                    0x00000000 /* RWI-V */
-#define NV_PGRAPH_FFINTFC_ST2_SUBCH_1                    0x00000001 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_SUBCH_2                    0x00000002 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_SUBCH_3                    0x00000003 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_SUBCH_4                    0x00000004 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_SUBCH_5                    0x00000005 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_SUBCH_6                    0x00000006 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_SUBCH_7                    0x00000007 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID                            18:15 /* RWIVF */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_1                     0x00000001 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_2                     0x00000002 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_3                     0x00000003 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_4                     0x00000004 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_5                     0x00000005 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_6                     0x00000006 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_7                     0x00000007 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_8                     0x00000008 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_9                     0x00000009 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_10                    0x0000000A /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_11                    0x0000000B /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_12                    0x0000000C /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_13                    0x0000000D /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_14                    0x0000000E /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_15                    0x0000000F /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_STATUS                     19:19 /* RWIVF */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_STATUS_INVALID        0x00000000 /* RWI-V */
-#define NV_PGRAPH_FFINTFC_ST2_CHID_STATUS_VALID          0x00000001 /* RW--V */
-#define NV_PGRAPH_FFINTFC_ST2_D                          0x00400758 /* RW-4R */
-#define NV_PGRAPH_FFINTFC_ST2_D_ARGUMENT                       31:0 /* RWIVF */
-#define NV_PGRAPH_FFINTFC_ST2_D_ARGUMENT_0               0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATUS                                 0x00400700 /* R--4R */
-#define NV_PGRAPH_STATUS_STATE                                  0:0 /* R-IVF */
-#define NV_PGRAPH_STATUS_STATE_IDLE                      0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_STATE_BUSY                      0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_XY_LOGIC                               4:4 /* R-IVF */
-#define NV_PGRAPH_STATUS_XY_LOGIC_IDLE                   0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_XY_LOGIC_BUSY                   0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_FE                                     5:5 /* R-IVF */
-#define NV_PGRAPH_STATUS_FE_IDLE                         0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_FE_BUSY                         0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_RASTERIZER                             6:6 /* R-IVF */
-#define NV_PGRAPH_STATUS_RASTERIZER_IDLE                 0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_RASTERIZER_BUSY                 0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_PORT_NOTIFY                            8:8 /* R-IVF */
-#define NV_PGRAPH_STATUS_PORT_NOTIFY_IDLE                0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_PORT_NOTIFY_BUSY                0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_PORT_REGISTER                        12:12 /* R-IVF */
-#define NV_PGRAPH_STATUS_PORT_REGISTER_IDLE              0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_PORT_REGISTER_BUSY              0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_PORT_DMA                             16:16 /* R-IVF */
-#define NV_PGRAPH_STATUS_PORT_DMA_IDLE                   0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_PORT_DMA_BUSY                   0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_DMA_ENGINE                           17:17 /* R-IVF */
-#define NV_PGRAPH_STATUS_DMA_ENGINE_IDLE                 0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_DMA_ENGINE_BUSY                 0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_DMA_NOTIFY                           20:20 /* R-IVF */
-#define NV_PGRAPH_STATUS_DMA_NOTIFY_IDLE                 0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_DMA_NOTIFY_BUSY                 0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_DMA_BUFFER_NOTIFY                    21:21 /* R-IVF */
-#define NV_PGRAPH_STATUS_DMA_BUFFER_NOTIFY_IDLE          0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_DMA_BUFFER_NOTIFY_BUSY          0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_D3D                                  24:24 /* R-IVF */
-#define NV_PGRAPH_STATUS_D3D_IDLE                        0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_D3D_BUSY                        0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_CACHE                                25:25 /* R-IVF */
-#define NV_PGRAPH_STATUS_CACHE_IDLE                      0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_CACHE_BUSY                      0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_LIGHTING                             26:26 /* R-IVF */
-#define NV_PGRAPH_STATUS_LIGHTING_IDLE                   0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_LIGHTING_BUSY                   0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_PREROP                               27:27 /* R-IVF */
-#define NV_PGRAPH_STATUS_PREROP_IDLE                     0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_PREROP_BUSY                     0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_ROP                                  28:28 /* R-IVF */
-#define NV_PGRAPH_STATUS_ROP_IDLE                        0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_ROP_BUSY                        0x00000001 /* R---V */
-#define NV_PGRAPH_STATUS_PORT_USER                            29:29 /* R-IVF */
-#define NV_PGRAPH_STATUS_PORT_USER_IDLE                  0x00000000 /* R-I-V */
-#define NV_PGRAPH_STATUS_PORT_USER_BUSY                  0x00000001 /* R---V */
-#define NV_PGRAPH_TRAPPED_ADDR                           0x00400704 /* R--4R */
-#define NV_PGRAPH_TRAPPED_ADDR_MTHD                            12:2 /* R-XUF */
-#define NV_PGRAPH_TRAPPED_ADDR_SUBCH                          15:13 /* R-XUF */
-#define NV_PGRAPH_TRAPPED_ADDR_CHID                           27:24 /* R-XUF */
-#define NV_PGRAPH_TRAPPED_DATA                           0x00400708 /* R--4R */
-#define NV_PGRAPH_TRAPPED_DATA_VALUE                           31:0 /* R-XVF */
-#define NV_PGRAPH_SURFACE                                0x0040070C /* RW-4R */
-#define NV_PGRAPH_SURFACE_TYPE                                  1:0 /* RWIVF */
-#define NV_PGRAPH_SURFACE_TYPE_INVALID                   0x00000000 /* RWI-V */
-#define NV_PGRAPH_SURFACE_TYPE_NON_SWIZZLE               0x00000001 /* RW--V */
-#define NV_PGRAPH_SURFACE_TYPE_SWIZZLE                   0x00000002 /* RW--V */
-#define NV_PGRAPH_NOTIFY                                 0x00400714 /* RW-4R */
-#define NV_PGRAPH_NOTIFY_BUFFER_REQ                             0:0 /* RWIVF */
-#define NV_PGRAPH_NOTIFY_BUFFER_REQ_NOT_PENDING          0x00000000 /* RWI-V */
-#define NV_PGRAPH_NOTIFY_BUFFER_REQ_PENDING              0x00000001 /* RW--V */
-#define NV_PGRAPH_NOTIFY_BUFFER_STYLE                           8:8 /* RWIVF */
-#define NV_PGRAPH_NOTIFY_BUFFER_STYLE_WRITE_ONLY         0x00000000 /* RWI-V */
-#define NV_PGRAPH_NOTIFY_BUFFER_STYLE_WRITE_THEN_AWAKEN  0x00000001 /* RW--V */
-#define NV_PGRAPH_NOTIFY_REQ                                  16:16 /* RWIVF */
-#define NV_PGRAPH_NOTIFY_REQ_NOT_PENDING                 0x00000000 /* RWI-V */
-#define NV_PGRAPH_NOTIFY_REQ_PENDING                     0x00000001 /* RW--V */
-#define NV_PGRAPH_NOTIFY_STYLE                                20:20 /* RWIVF */
-#define NV_PGRAPH_NOTIFY_STYLE_WRITE_ONLY                0x00000000 /* RWI-V */
-#define NV_PGRAPH_NOTIFY_STYLE_WRITE_THEN_AWAKEN         0x00000001 /* RW--V */
-#define NV_PGRAPH_BOFFSET(i)                     (0x00400640+(i)*4) /* RW-4A */
-#define NV_PGRAPH_BOFFSET__SIZE_1                                 6 /*       */
-#define NV_PGRAPH_BOFFSET_LINADRS                              23:0 /* RWIUF */
-#define NV_PGRAPH_BOFFSET_LINADRS_0                      0x00000000 /* RWI-V */
-#define NV_PGRAPH_BOFFSET0                               0x00400640 /* RW-4R */
-#define NV_PGRAPH_BOFFSET0__ALIAS_1            NV_PGRAPH_BOFFSET(0) /*       */
-#define NV_PGRAPH_BOFFSET0_LINADRS                             23:0 /* RWIUF */
-#define NV_PGRAPH_BOFFSET0_LINADRS_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_BOFFSET1                               0x00400644 /* RW-4R */
-#define NV_PGRAPH_BOFFSET1__ALIAS_1            NV_PGRAPH_BOFFSET(1) /*       */
-#define NV_PGRAPH_BOFFSET1_LINADRS                             23:0 /* RWIUF */
-#define NV_PGRAPH_BOFFSET1_LINADRS_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_BOFFSET2                               0x00400648 /* RW-4R */
-#define NV_PGRAPH_BOFFSET2__ALIAS_1            NV_PGRAPH_BOFFSET(2) /*       */
-#define NV_PGRAPH_BOFFSET2_LINADRS                             23:0 /* RWIUF */
-#define NV_PGRAPH_BOFFSET2_LINADRS_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_BOFFSET3                               0x0040064C /* RW-4R */
-#define NV_PGRAPH_BOFFSET3__ALIAS_1            NV_PGRAPH_BOFFSET(3) /*       */
-#define NV_PGRAPH_BOFFSET3_LINADRS                             23:0 /* RWIUF */
-#define NV_PGRAPH_BOFFSET3_LINADRS_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_BOFFSET4                               0x00400650 /* RW-4R */
-#define NV_PGRAPH_BOFFSET4__ALIAS_1            NV_PGRAPH_BOFFSET(4) /*       */
-#define NV_PGRAPH_BOFFSET4_LINADRS                             23:0 /* RWIUF */
-#define NV_PGRAPH_BOFFSET4_LINADRS_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_BOFFSET5                               0x00400654 /* RW-4R */
-#define NV_PGRAPH_BOFFSET5__ALIAS_1            NV_PGRAPH_BOFFSET(5) /*       */
-#define NV_PGRAPH_BOFFSET5_LINADRS                             23:0 /* RWIUF */
-#define NV_PGRAPH_BOFFSET5_LINADRS_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_BBASE(i)                       (0x00400658+(i)*4) /* RW-4A */
-#define NV_PGRAPH_BBASE__SIZE_1                                   6 /*       */
-#define NV_PGRAPH_BBASE_LINADRS                                23:0 /* RWIUF */
-#define NV_PGRAPH_BBASE_LINADRS_0                        0x00000000 /* RWI-V */
-#define NV_PGRAPH_BBASE0                                 0x00400658 /* RW-4R */
-#define NV_PGRAPH_BBASE0__ALIAS_1                NV_PGRAPH_BBASE(0) /*       */
-#define NV_PGRAPH_BBASE0_LINADRS                               23:0 /* RWIUF */
-#define NV_PGRAPH_BBASE0_LINADRS_0                       0x00000000 /* RWI-V */
-#define NV_PGRAPH_BBASE1                                 0x0040065c /* RW-4R */
-#define NV_PGRAPH_BBASE1__ALIAS_1                NV_PGRAPH_BBASE(1) /*       */
-#define NV_PGRAPH_BBASE1_LINADRS                               23:0 /* RWIUF */
-#define NV_PGRAPH_BBASE1_LINADRS_0                       0x00000000 /* RWI-V */
-#define NV_PGRAPH_BBASE2                                 0x00400660 /* RW-4R */
-#define NV_PGRAPH_BBASE2__ALIAS_1                NV_PGRAPH_BBASE(2) /*       */
-#define NV_PGRAPH_BBASE2_LINADRS                               23:0 /* RWIUF */
-#define NV_PGRAPH_BBASE2_LINADRS_0                       0x00000000 /* RWI-V */
-#define NV_PGRAPH_BBASE3                                 0x00400664 /* RW-4R */
-#define NV_PGRAPH_BBASE3__ALIAS_1                NV_PGRAPH_BBASE(3) /*       */
-#define NV_PGRAPH_BBASE3_LINADRS                               23:0 /* RWIUF */
-#define NV_PGRAPH_BBASE3_LINADRS_0                       0x00000000 /* RWI-V */
-#define NV_PGRAPH_BBASE4                                 0x00400668 /* RW-4R */
-#define NV_PGRAPH_BBASE4__ALIAS_1                NV_PGRAPH_BBASE(4) /*       */
-#define NV_PGRAPH_BBASE4_LINADRS                               23:0 /* RWIUF */
-#define NV_PGRAPH_BBASE4_LINADRS_0                       0x00000000 /* RWI-V */
-#define NV_PGRAPH_BBASE5                                 0x0040066C /* RW-4R */
-#define NV_PGRAPH_BBASE5__ALIAS_1                NV_PGRAPH_BBASE(5) /*       */
-#define NV_PGRAPH_BBASE5_LINADRS                               23:0 /* RWIUF */
-#define NV_PGRAPH_BBASE5_LINADRS_0                       0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPITCH(i)                      (0x00400670+(i)*4) /* RW-4A */
-#define NV_PGRAPH_BPITCH__SIZE_1                                  5 /*       */
-#define NV_PGRAPH_BPITCH_VALUE                                 12:0 /* RWIUF */
-#define NV_PGRAPH_BPITCH_VALUE_0                         0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPITCH0                                0x00400670 /* RW-4R */
-#define NV_PGRAPH_BPITCH0__ALIAS_1              NV_PGRAPH_BPITCH(0) /*       */
-#define NV_PGRAPH_BPITCH0_VALUE                                12:0 /* RWIUF */
-#define NV_PGRAPH_BPITCH0_VALUE_0                        0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPITCH1                                0x00400674 /* RW-4R */
-#define NV_PGRAPH_BPITCH1__ALIAS_1              NV_PGRAPH_BPITCH(1) /*       */
-#define NV_PGRAPH_BPITCH1_VALUE                                12:0 /* RWIUF */
-#define NV_PGRAPH_BPITCH1_VALUE_0                        0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPITCH2                                0x00400678 /* RW-4R */
-#define NV_PGRAPH_BPITCH2__ALIAS_1              NV_PGRAPH_BPITCH(2) /*       */
-#define NV_PGRAPH_BPITCH2_VALUE                                12:0 /* RWIUF */
-#define NV_PGRAPH_BPITCH2_VALUE_0                        0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPITCH3                                0x0040067C /* RW-4R */
-#define NV_PGRAPH_BPITCH3__ALIAS_1              NV_PGRAPH_BPITCH(3) /*       */
-#define NV_PGRAPH_BPITCH3_VALUE                                12:0 /* RWIUF */
-#define NV_PGRAPH_BPITCH3_VALUE_0                        0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPITCH4                                0x00400680 /* RW-4R */
-#define NV_PGRAPH_BPITCH4__ALIAS_1              NV_PGRAPH_BPITCH(4) /*       */
-#define NV_PGRAPH_BPITCH4_VALUE                                12:0 /* RWIUF */
-#define NV_PGRAPH_BPITCH4_VALUE_0                        0x00000000 /* RWI-V */
-#define NV_PGRAPH_BLIMIT(i)                      (0x00400684+(i)*4) /* RW-4A */
-#define NV_PGRAPH_BLIMIT__SIZE_1                                  6 /*       */
-#define NV_PGRAPH_BLIMIT_VALUE                                 23:0 /* RWXUF */
-#define NV_PGRAPH_BLIMIT_TYPE                                 31:31 /* RWIVF */
-#define NV_PGRAPH_BLIMIT_TYPE_IN_MEMORY                  0x00000000 /* RW--V */
-#define NV_PGRAPH_BLIMIT_TYPE_NULL                       0x00000001 /* RWI-V */
-#define NV_PGRAPH_BLIMIT0                                0x00400684 /* RW-4R */
-#define NV_PGRAPH_BLIMIT0__ALIAS_1              NV_PGRAPH_BLIMIT(0) /*       */
-#define NV_PGRAPH_BLIMIT0_VALUE                                23:0 /* RWXUF */
-#define NV_PGRAPH_BLIMIT0_TYPE                                31:31 /* RWIVF */
-#define NV_PGRAPH_BLIMIT0_TYPE_IN_MEMORY                 0x00000000 /* RW--V */
-#define NV_PGRAPH_BLIMIT0_TYPE_NULL                      0x00000001 /* RWI-V */
-#define NV_PGRAPH_BLIMIT1                                0x00400688 /* RW-4R */
-#define NV_PGRAPH_BLIMIT1__ALIAS_1              NV_PGRAPH_BLIMIT(1) /*       */
-#define NV_PGRAPH_BLIMIT1_VALUE                                23:0 /* RWXUF */
-#define NV_PGRAPH_BLIMIT1_TYPE                                31:31 /* RWIVF */
-#define NV_PGRAPH_BLIMIT1_TYPE_IN_MEMORY                 0x00000000 /* RW--V */
-#define NV_PGRAPH_BLIMIT1_TYPE_NULL                      0x00000001 /* RWI-V */
-#define NV_PGRAPH_BLIMIT2                                0x0040068c /* RW-4R */
-#define NV_PGRAPH_BLIMIT2__ALIAS_1              NV_PGRAPH_BLIMIT(2) /*       */
-#define NV_PGRAPH_BLIMIT2_VALUE                                23:0 /* RWXUF */
-#define NV_PGRAPH_BLIMIT2_TYPE                                31:31 /* RWIVF */
-#define NV_PGRAPH_BLIMIT2_TYPE_IN_MEMORY                 0x00000000 /* RW--V */
-#define NV_PGRAPH_BLIMIT2_TYPE_NULL                      0x00000001 /* RWI-V */
-#define NV_PGRAPH_BLIMIT3                                0x00400690 /* RW-4R */
-#define NV_PGRAPH_BLIMIT3__ALIAS_1              NV_PGRAPH_BLIMIT(3) /*       */
-#define NV_PGRAPH_BLIMIT3_VALUE                                23:0 /* RWXUF */
-#define NV_PGRAPH_BLIMIT3_TYPE                                31:31 /* RWIVF */
-#define NV_PGRAPH_BLIMIT3_TYPE_IN_MEMORY                 0x00000000 /* RW--V */
-#define NV_PGRAPH_BLIMIT3_TYPE_NULL                      0x00000001 /* RWI-V */
-#define NV_PGRAPH_BLIMIT4                                0x00400694 /* RW-4R */
-#define NV_PGRAPH_BLIMIT4__ALIAS_1              NV_PGRAPH_BLIMIT(4) /*       */
-#define NV_PGRAPH_BLIMIT4_VALUE                                23:0 /* RWXUF */
-#define NV_PGRAPH_BLIMIT4_TYPE                                31:31 /* RWIVF */
-#define NV_PGRAPH_BLIMIT4_TYPE_IN_MEMORY                 0x00000000 /* RW--V */
-#define NV_PGRAPH_BLIMIT4_TYPE_NULL                      0x00000001 /* RWI-V */
-#define NV_PGRAPH_BLIMIT5                                0x00400698 /* RW-4R */
-#define NV_PGRAPH_BLIMIT5__ALIAS_1              NV_PGRAPH_BLIMIT(5) /*       */
-#define NV_PGRAPH_BLIMIT5_VALUE                                23:0 /* RWXUF */
-#define NV_PGRAPH_BLIMIT5_TYPE                                31:31 /* RWIVF */
-#define NV_PGRAPH_BLIMIT5_TYPE_IN_MEMORY                 0x00000000 /* RW--V */
-#define NV_PGRAPH_BLIMIT5_TYPE_NULL                      0x00000001 /* RWI-V */
-#define NV_PGRAPH_BSWIZZLE2                              0x0040069c /* RW-4R */
-#define NV_PGRAPH_BSWIZZLE2_WIDTH                             19:16 /* RWIUF */
-#define NV_PGRAPH_BSWIZZLE2_WIDTH_0                      0x00000000 /* RWI-V */
-#define NV_PGRAPH_BSWIZZLE2_HEIGHT                            27:24 /* RWIUF */
-#define NV_PGRAPH_BSWIZZLE2_HEIGHT_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_BSWIZZLE5                              0x004006a0 /* RW-4R */
-#define NV_PGRAPH_BSWIZZLE5_WIDTH                             19:16 /* RWIUF */
-#define NV_PGRAPH_BSWIZZLE5_WIDTH_0                      0x00000000 /* RWI-V */
-#define NV_PGRAPH_BSWIZZLE5_HEIGHT                            27:24 /* RWIUF */
-#define NV_PGRAPH_BSWIZZLE5_HEIGHT_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPIXEL                                 0x00400724 /* RW-4R */
-#define NV_PGRAPH_BPIXEL_DEPTH0                                 3:0 /* RWIVF */
-#define NV_PGRAPH_BPIXEL_DEPTH0_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_Y8                       0x00000001 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_X1R5G5B5_Z1R5G5B5        0x00000002 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_X1R5G5B5_O1R5G5B5        0x00000003 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_A1R5G5B5                 0x00000004 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_R5G6B5                   0x00000005 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_Y16                      0x00000006 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_X8R8G8B8_Z8R8G8B8        0x00000007 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_X8R8G8B8_O1Z7R8G8B8      0x00000008 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_X1A7R8G8B8_Z1A7R8G8B8    0x00000009 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_X1A7R8G8B8_O1A7R8G8B8    0x0000000a /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_X8R8G8B8_O8R8G8B8        0x0000000b /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_A8R8G8B8                 0x0000000c /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_Y32                      0x0000000d /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_V8YB8U8YA8               0x0000000e /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH0_YB8V8YA8U8               0x0000000f /* RW--V */ 
-#define NV_PGRAPH_BPIXEL_DEPTH1                                 7:4 /* RWIVF */
-#define NV_PGRAPH_BPIXEL_DEPTH1_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_Y8                       0x00000001 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_X1R5G5B5_Z1R5G5B5        0x00000002 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_X1R5G5B5_O1R5G5B5        0x00000003 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_A1R5G5B5                 0x00000004 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_R5G6B5                   0x00000005 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_Y16                      0x00000006 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_X8R8G8B8_Z8R8G8B8        0x00000007 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_X8R8G8B8_O1Z7R8G8B8      0x00000008 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_X1A7R8G8B8_Z1A7R8G8B8    0x00000009 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_X1A7R8G8B8_O1A7R8G8B8    0x0000000a /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_X8R8G8B8_O8R8G8B8        0x0000000b /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_A8R8G8B8                 0x0000000c /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_Y32                      0x0000000d /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_V8YB8U8YA8               0x0000000e /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH1_YB8V8YA8U8               0x0000000f /* RW--V */ 
-#define NV_PGRAPH_BPIXEL_DEPTH2                                11:8 /* RWIVF */
-#define NV_PGRAPH_BPIXEL_DEPTH2_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_Y8                       0x00000001 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_X1R5G5B5_Z1R5G5B5        0x00000002 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_X1R5G5B5_O1R5G5B5        0x00000003 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_A1R5G5B5                 0x00000004 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_R5G6B5                   0x00000005 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_Y16                      0x00000006 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_X8R8G8B8_Z8R8G8B8        0x00000007 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_X8R8G8B8_O1Z7R8G8B8      0x00000008 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_X1A7R8G8B8_Z1A7R8G8B8    0x00000009 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_X1A7R8G8B8_O1A7R8G8B8    0x0000000a /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_X8R8G8B8_O8R8G8B8        0x0000000b /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_A8R8G8B8                 0x0000000c /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_Y32                      0x0000000d /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_V8YB8U8YA8               0x0000000e /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH2_YB8V8YA8U8               0x0000000f /* RW--V */ 
-#define NV_PGRAPH_BPIXEL_DEPTH3                               15:12 /* RWIVF */
-#define NV_PGRAPH_BPIXEL_DEPTH3_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_Y8                       0x00000001 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_X1R5G5B5_Z1R5G5B5        0x00000002 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_X1R5G5B5_O1R5G5B5        0x00000003 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_A1R5G5B5                 0x00000004 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_R5G6B5                   0x00000005 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_Y16                      0x00000006 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_X8R8G8B8_Z8R8G8B8        0x00000007 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_X8R8G8B8_O1Z7R8G8B8      0x00000008 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_X1A7R8G8B8_Z1A7R8G8B8    0x00000009 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_X1A7R8G8B8_O1A7R8G8B8    0x0000000a /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_X8R8G8B8_O8R8G8B8        0x0000000b /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_A8R8G8B8                 0x0000000c /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_Y32                      0x0000000d /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_V8YB8U8YA8               0x0000000e /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH3_YB8V8YA8U8               0x0000000f /* RW--V */ 
-#define NV_PGRAPH_BPIXEL_DEPTH4                               19:16 /* RWIVF */
-#define NV_PGRAPH_BPIXEL_DEPTH4_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_Y8                       0x00000001 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_X1R5G5B5_Z1R5G5B5        0x00000002 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_X1R5G5B5_O1R5G5B5        0x00000003 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_A1R5G5B5                 0x00000004 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_R5G6B5                   0x00000005 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_Y16                      0x00000006 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_X8R8G8B8_Z8R8G8B8        0x00000007 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_X8R8G8B8_O1Z7R8G8B8      0x00000008 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_X1A7R8G8B8_Z1A7R8G8B8    0x00000009 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_X1A7R8G8B8_O1A7R8G8B8    0x0000000a /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_X8R8G8B8_O8R8G8B8        0x0000000b /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_A8R8G8B8                 0x0000000c /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_Y32                      0x0000000d /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_V8YB8U8YA8               0x0000000e /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH4_YB8V8YA8U8               0x0000000f /* RW--V */ 
-#define NV_PGRAPH_BPIXEL_DEPTH5                               23:20 /* RWIVF */
-#define NV_PGRAPH_BPIXEL_DEPTH5_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_Y8                       0x00000001 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_X1R5G5B5_Z1R5G5B5        0x00000002 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_X1R5G5B5_O1R5G5B5        0x00000003 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_A1R5G5B5                 0x00000004 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_R5G6B5                   0x00000005 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_Y16                      0x00000006 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_X8R8G8B8_Z8R8G8B8        0x00000007 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_X8R8G8B8_O1Z7R8G8B8      0x00000008 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_X1A7R8G8B8_Z1A7R8G8B8    0x00000009 /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_X1A7R8G8B8_O1A7R8G8B8    0x0000000a /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_X8R8G8B8_O8R8G8B8        0x0000000b /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_A8R8G8B8                 0x0000000c /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_Y32                      0x0000000d /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_V8YB8U8YA8               0x0000000e /* RW--V */
-#define NV_PGRAPH_BPIXEL_DEPTH5_YB8V8YA8U8               0x0000000f /* RW--V */ 
-#define NV_PGRAPH_LIMIT_VIOL_PIX                         0x00400610 /* RW-4R */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_ADRS                          23:0 /* RWIVF */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_ADRS_0                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_BLIT                         29:29 /* RWIVF */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_BLIT_NO_VIOL            0x00000000 /* RWI-V */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_BLIT_VIOL               0x00000001 /* RW--V */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_LIMIT                        30:30 /* RWIVF */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_LIMIT_NO_VIOL           0x00000000 /* RWI-V */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_LIMIT_VIOL              0x00000001 /* RW--V */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_OVRFLW                       31:31 /* RWIVF */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_OVRFLW_NO_VIOL          0x00000000 /* RWI-V */
-#define NV_PGRAPH_LIMIT_VIOL_PIX_OVRFLW_VIOL             0x00000001 /* RW--V */
-#define NV_PGRAPH_LIMIT_VIOL_Z                           0x00400614 /* RW-4R */
-#define NV_PGRAPH_LIMIT_VIOL_Z_ADRS                            23:0 /* RWIVF */
-#define NV_PGRAPH_LIMIT_VIOL_Z_ADRS_0                    0x00000000 /* RWI-V */
-#define NV_PGRAPH_LIMIT_VIOL_Z_LIMIT                          30:30 /* RWIVF */
-#define NV_PGRAPH_LIMIT_VIOL_Z_LIMIT_NO_VIOL             0x00000000 /* RWI-V */
-#define NV_PGRAPH_LIMIT_VIOL_Z_LIMIT_VIOL                0x00000001 /* RW--V */
-#define NV_PGRAPH_LIMIT_VIOL_Z_OVRFLW                         31:31 /* RWIVF */
-#define NV_PGRAPH_LIMIT_VIOL_Z_OVRFLW_NO_VIOL            0x00000000 /* RWI-V */
-#define NV_PGRAPH_LIMIT_VIOL_Z_OVRFLW_VIOL               0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE                                  0x00400710 /* RW-4R */
-#define NV_PGRAPH_STATE_BUFFER_0                                0:0 /* RWIVF */
-#define NV_PGRAPH_STATE_BUFFER_0_INVALID                 0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_BUFFER_0_VALID                   0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_BUFFER_1                                1:1 /* RWIVF */
-#define NV_PGRAPH_STATE_BUFFER_1_INVALID                 0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_BUFFER_1_VALID                   0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_BUFFER_2                                2:2 /* RWIVF */
-#define NV_PGRAPH_STATE_BUFFER_2_INVALID                 0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_BUFFER_2_VALID                   0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_BUFFER_3                                3:3 /* RWIVF */
-#define NV_PGRAPH_STATE_BUFFER_3_INVALID                 0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_BUFFER_3_VALID                   0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_BUFFER_4                                4:4 /* RWIVF */
-#define NV_PGRAPH_STATE_BUFFER_4_INVALID                 0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_BUFFER_4_VALID                   0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_BUFFER_5                                5:5 /* RWIVF */
-#define NV_PGRAPH_STATE_BUFFER_5_INVALID                 0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_BUFFER_5_VALID                   0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_PITCH_0                                 8:8 /* RWIVF */
-#define NV_PGRAPH_STATE_PITCH_0_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_PITCH_0_VALID                    0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_PITCH_1                                 9:9 /* RWIVF */
-#define NV_PGRAPH_STATE_PITCH_1_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_PITCH_1_VALID                    0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_PITCH_2                               10:10 /* RWIVF */
-#define NV_PGRAPH_STATE_PITCH_2_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_PITCH_2_VALID                    0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_PITCH_3                               11:11 /* RWIVF */
-#define NV_PGRAPH_STATE_PITCH_3_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_PITCH_3_VALID                    0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_PITCH_4                               12:12 /* RWIVF */
-#define NV_PGRAPH_STATE_PITCH_4_INVALID                  0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_PITCH_4_VALID                    0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_CHROMA_COLOR                          16:16 /* RWIVF */
-#define NV_PGRAPH_STATE_CHROMA_COLOR_INVALID             0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_CHROMA_COLOR_VALID               0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_CHROMA_COLORFMT                       17:17 /* RWIVF */
-#define NV_PGRAPH_STATE_CHROMA_COLORFMT_INVALID          0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_CHROMA_COLORFMT_VALID            0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_CPATTERN_COLORFMT                     20:20 /* RWIVF */
-#define NV_PGRAPH_STATE_CPATTERN_COLORFMT_INVALID        0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_CPATTERN_COLORFMT_VALID          0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_CPATTERN_MONOFMT                      21:21 /* RWIVF */
-#define NV_PGRAPH_STATE_CPATTERN_MONOFMT_INVALID         0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_CPATTERN_MONOFMT_VALID           0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_CPATTERN_SELECT                       22:22 /* RWIVF */
-#define NV_PGRAPH_STATE_CPATTERN_SELECT_INVALID          0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_CPATTERN_SELECT_VALID            0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_PATTERN_COLOR0                        24:24 /* RWIVF */
-#define NV_PGRAPH_STATE_PATTERN_COLOR0_INVALID           0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_PATTERN_COLOR0_VALID             0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_PATTERN_COLOR1                        25:25 /* RWIVF */
-#define NV_PGRAPH_STATE_PATTERN_COLOR1_INVALID           0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_PATTERN_COLOR1_VALID             0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_PATTERN_PATT0                         26:26 /* RWIVF */
-#define NV_PGRAPH_STATE_PATTERN_PATT0_INVALID            0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_PATTERN_PATT0_VALID              0x00000001 /* RW--V */
-#define NV_PGRAPH_STATE_PATTERN_PATT1                         27:27 /* RWIVF */
-#define NV_PGRAPH_STATE_PATTERN_PATT1_INVALID            0x00000000 /* RWI-V */
-#define NV_PGRAPH_STATE_PATTERN_PATT1_VALID              0x00000001 /* RW--V */
-#define NV_PGRAPH_CACHE_INDEX                            0x00400728 /* RW-4R */
-#define NV_PGRAPH_CACHE_INDEX_BANK                              2:2 /* RWXVF */
-#define NV_PGRAPH_CACHE_INDEX_BANK_10                    0x00000000 /* RW--V */
-#define NV_PGRAPH_CACHE_INDEX_BANK_32                    0x00000001 /* RW--V */
-#define NV_PGRAPH_CACHE_INDEX_ADRS                             12:3 /* RWXVF */
-#define NV_PGRAPH_CACHE_INDEX_ADRS_0                     0x00000000 /* RW--V */
-#define NV_PGRAPH_CACHE_INDEX_ADRS_1024                  0x00000400 /* RW--V */
-#define NV_PGRAPH_CACHE_INDEX_OP                              14:13 /* RWXVF */
-#define NV_PGRAPH_CACHE_INDEX_OP_WR_CACHE                0x00000000 /* RW--V */
-#define NV_PGRAPH_CACHE_INDEX_OP_RD_CACHE                0x00000001 /* RW--V */
-#define NV_PGRAPH_CACHE_INDEX_OP_RD_INDEX                0x00000002 /* RW--V */
-#define NV_PGRAPH_CACHE_RAM                              0x0040072c /* RW-4R */
-#define NV_PGRAPH_CACHE_RAM_VALUE                              31:0 /* RWXVF */
-#define NV_PGRAPH_DMA_PITCH                              0x00400760 /* RW-4R */
-#define NV_PGRAPH_DMA_PITCH_S0                                 15:0 /* RWXSF */
-#define NV_PGRAPH_DMA_PITCH_S1                                31:16 /* RWXSF */
-#define NV_PGRAPH_DVD_COLORFMT                           0x00400764 /* RW-4R */
-#define NV_PGRAPH_DVD_COLORFMT_IMAGE                            5:0 /* RWNVF */
-#define NV_PGRAPH_DVD_COLORFMT_IMAGE_FORMAT_INVALID            0x00 /* RWN-V */
-#define NV_PGRAPH_DVD_COLORFMT_IMAGE_FORMAT_LE_V8YB8U8YA8      0x12 /* RW--V */
-#define NV_PGRAPH_DVD_COLORFMT_IMAGE_FORMAT_LE_YB8V8YA8U8      0x13 /* RW--V */
-#define NV_PGRAPH_DVD_COLORFMT_OVLY                             9:8 /* RWNVF */
-#define NV_PGRAPH_DVD_COLORFMT_OVLY_FORMAT_INVALID             0x00 /* RWN-V */
-#define NV_PGRAPH_DVD_COLORFMT_OVLY_FORMAT_LE_A8Y8U8V8         0x01 /* RW--V */
-#define NV_PGRAPH_DVD_COLORFMT_OVLY_FORMAT_LE_A4V6YB6A4U6YA6   0x02 /* RW--V */
-#define NV_PGRAPH_DVD_COLORFMT_OVLY_FORMAT_TRANSPARENT         0x03 /* RW--V */
-#define NV_PGRAPH_SCALED_FORMAT                          0x00400768 /* RW-4R */
-#define NV_PGRAPH_SCALED_FORMAT_ORIGIN                        17:16 /* RWIVF */
-#define NV_PGRAPH_SCALED_FORMAT_ORIGIN_INVALID           0x00000000 /* RWI-V */
-#define NV_PGRAPH_SCALED_FORMAT_ORIGIN_CENTER            0x00000001 /* RW--V */
-#define NV_PGRAPH_SCALED_FORMAT_ORIGIN_CORNER            0x00000002 /* RW--V */
-#define NV_PGRAPH_SCALED_FORMAT_INTERPOLATOR                  24:24 /* RWIVF */
-#define NV_PGRAPH_SCALED_FORMAT_INTERPOLATOR_ZOH         0x00000000 /* RWI-V */
-#define NV_PGRAPH_SCALED_FORMAT_INTERPOLATOR_FOH         0x00000001 /* RW--V */
-#define NV_PGRAPH_PATT_COLOR0                            0x00400800 /* RW-4R */
-#define NV_PGRAPH_PATT_COLOR0_VALUE                            31:0 /* RWXUF */
-#define NV_PGRAPH_PATT_COLOR1                            0x00400804 /* RW-4R */
-#define NV_PGRAPH_PATT_COLOR1_VALUE                            31:0 /* RWXUF */
-#define NV_PGRAPH_PATT_COLORRAM(i)               (0x00400900+(i)*4) /* R--4A */
-#define NV_PGRAPH_PATT_COLORRAM__SIZE_1                          64 /*       */
-#define NV_PGRAPH_PATT_COLORRAM_VALUE                          23:0 /* R--UF */
-#define NV_PGRAPH_PATTERN(i)                     (0x00400808+(i)*4) /* RW-4A */
-#define NV_PGRAPH_PATTERN__SIZE_1                                 2 /*       */
-#define NV_PGRAPH_PATTERN_BITMAP                               31:0 /* RWXVF */
-#define NV_PGRAPH_PATTERN_SHAPE                          0x00400810 /* RW-4R */
-#define NV_PGRAPH_PATTERN_SHAPE_VALUE                           1:0 /* RWXVF */
-#define NV_PGRAPH_PATTERN_SHAPE_VALUE_8X_8Y              0x00000000 /* RW--V */
-#define NV_PGRAPH_PATTERN_SHAPE_VALUE_64X_1Y             0x00000001 /* RW--V */
-#define NV_PGRAPH_PATTERN_SHAPE_VALUE_1X_64Y             0x00000002 /* RW--V */
-#define NV_PGRAPH_PATTERN_SHAPE_SELECT                          4:4 /* RWXVF */
-#define NV_PGRAPH_PATTERN_SHAPE_SELECT_2COLOR            0x00000000 /* RW--V */
-#define NV_PGRAPH_PATTERN_SHAPE_SELECT_FULLCOLOR         0x00000001 /* RW--V */
-#define NV_PGRAPH_MONO_COLOR0                            0x00400600 /* RW-4R */
-#define NV_PGRAPH_MONO_COLOR0_VALUE                            31:0 /* RWXUF */
-#define NV_PGRAPH_ROP3                                   0x00400604 /* RW-4R */
-#define NV_PGRAPH_ROP3_VALUE                                    7:0 /* RWXVF */
-#define NV_PGRAPH_CHROMA                                 0x00400814 /* RW-4R */
-#define NV_PGRAPH_CHROMA_VALUE                                 31:0 /* RWXUF */
-#define NV_PGRAPH_BETA_AND                               0x00400608 /* RW-4R */
-#define NV_PGRAPH_BETA_AND_VALUE_FRACTION                     30:23 /* RWXUF */
-#define NV_PGRAPH_BETA_PREMULT                           0x0040060c /* RW-4R */
-#define NV_PGRAPH_BETA_PREMULT_VALUE                           31:0 /* RWXUF */
-#define NV_PGRAPH_CONTROL0                               0x00400818 /* RW-4R */
-#define NV_PGRAPH_CONTROL1                               0x0040081c /* RW-4R */
-#define NV_PGRAPH_CONTROL2                               0x00400820 /* RW-4R */
-#define NV_PGRAPH_BLEND                                  0x00400824 /* RW-4R */
-#define NV_PGRAPH_DPRAM_INDEX                            0x00400828 /* RW-4R */
-#define NV_PGRAPH_DPRAM_INDEX_ADRS                              6:0 /* RWIVF */
-#define NV_PGRAPH_DPRAM_INDEX_ADRS_0                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_DPRAM_INDEX_SELECT                           10:8 /* RWIVF */
-#define NV_PGRAPH_DPRAM_INDEX_SELECT_ADRS_0              0x00000000 /* RWI-V */
-#define NV_PGRAPH_DPRAM_INDEX_SELECT_ADRS_1              0x00000001 /* RW--V */
-#define NV_PGRAPH_DPRAM_INDEX_SELECT_DATA_0              0x00000002 /* RW--V */
-#define NV_PGRAPH_DPRAM_INDEX_SELECT_DATA_1              0x00000003 /* RW--V */
-#define NV_PGRAPH_DPRAM_INDEX_SELECT_WE_0                0x00000004 /* RW--V */
-#define NV_PGRAPH_DPRAM_INDEX_SELECT_WE_1                0x00000005 /* RW--V */
-#define NV_PGRAPH_DPRAM_INDEX_SELECT_ALPHA_0             0x00000006 /* RW--V */
-#define NV_PGRAPH_DPRAM_INDEX_SELECT_ALPHA_1             0x00000007 /* RW--V */
-#define NV_PGRAPH_DPRAM_DATA                             0x0040082c /* RW-4R */
-#define NV_PGRAPH_DPRAM_DATA_VALUE                             31:0 /* RWXVF */
-#define NV_PGRAPH_DPRAM_ADRS_0                           0x0040082c /* RW-4R */
-#define NV_PGRAPH_DPRAM_ADRS_0__ALIAS_1        NV_PGRAPH_DPRAM_DATA /*       */
-#define NV_PGRAPH_DPRAM_ADRS_0_VALUE                           19:0 /* RWXVF */
-#define NV_PGRAPH_DPRAM_ADRS_1                           0x0040082c /* RW-4R */
-#define NV_PGRAPH_DPRAM_ADRS_1__ALIAS_1        NV_PGRAPH_DPRAM_DATA /*       */
-#define NV_PGRAPH_DPRAM_ADRS_1_VALUE                           19:0 /* RWXVF */
-#define NV_PGRAPH_DPRAM_DATA_0                           0x0040082c /* RW-4R */
-#define NV_PGRAPH_DPRAM_DATA_0__ALIAS_1        NV_PGRAPH_DPRAM_DATA /*       */
-#define NV_PGRAPH_DPRAM_DATA_0_VALUE                           31:0 /* RWXVF */
-#define NV_PGRAPH_DPRAM_DATA_1                           0x0040082c /* RW-4R */
-#define NV_PGRAPH_DPRAM_DATA_1__ALIAS_1        NV_PGRAPH_DPRAM_DATA /*       */
-#define NV_PGRAPH_DPRAM_DATA_1_VALUE                           31:0 /* RWXVF */
-#define NV_PGRAPH_DPRAM_WE_0                             0x0040082c /* RW-4R */
-#define NV_PGRAPH_DPRAM_WE_0__ALIAS_1          NV_PGRAPH_DPRAM_DATA /*       */
-#define NV_PGRAPH_DPRAM_WE_0_VALUE                             23:0 /* RWXVF */
-#define NV_PGRAPH_DPRAM_WE_1                             0x0040082c /* RW-4R */
-#define NV_PGRAPH_DPRAM_WE_1__ALIAS_1          NV_PGRAPH_DPRAM_DATA /*       */
-#define NV_PGRAPH_DPRAM_WE_1_VALUE                             23:0 /* RWXVF */
-#define NV_PGRAPH_DPRAM_ALPHA_0                          0x0040082c /* RW-4R */
-#define NV_PGRAPH_DPRAM_ALPHA_0__ALIAS_1       NV_PGRAPH_DPRAM_DATA /*       */
-#define NV_PGRAPH_DPRAM_ALPHA_0_VALUE                          31:0 /* RWXVF */
-#define NV_PGRAPH_DPRAM_ALPHA_1                          0x0040082c /* RW-4R */
-#define NV_PGRAPH_DPRAM_ALPHA_1__ALIAS_1       NV_PGRAPH_DPRAM_DATA /*       */
-#define NV_PGRAPH_DPRAM_ALPHA_1_VALUE                          31:0 /* RWXVF */
-#define NV_PGRAPH_STORED_FMT                             0x00400830 /* RW-4R */
-#define NV_PGRAPH_STORED_FMT_MONO0                              5:0 /* RWXVF */
-#define NV_PGRAPH_STORED_FMT_PATT0                             13:8 /* RWXVF */
-#define NV_PGRAPH_STORED_FMT_PATT1                            21:16 /* RWXVF */
-#define NV_PGRAPH_STORED_FMT_CHROMA                           29:24 /* RWXVF */
-#define NV_PGRAPH_FORMATS                                0x00400618 /* RW-4R */
-#define NV_PGRAPH_FORMATS_ROP                                   2:0 /* R-XVF */
-#define NV_PGRAPH_FORMATS_ROP_Y8                         0x00000000 /* -W--V */
-#define NV_PGRAPH_FORMATS_ROP_RGB15                      0x00000001 /* -W--V */
-#define NV_PGRAPH_FORMATS_ROP_RGB16                      0x00000002 /* -W--V */
-#define NV_PGRAPH_FORMATS_ROP_Y16                        0x00000003 /* -W--V */
-#define NV_PGRAPH_FORMATS_ROP_INVALID                    0x00000004 /* -W--V */
-#define NV_PGRAPH_FORMATS_ROP_RGB24                      0x00000005 /* -W--V */
-#define NV_PGRAPH_FORMATS_ROP_RGB30                      0x00000006 /* -W--V */
-#define NV_PGRAPH_FORMATS_ROP_Y32                        0x00000007 /* -W--V */
-#define NV_PGRAPH_FORMATS_SRC                                   9:4 /* R-XVF */
-#define NV_PGRAPH_FORMATS_SRC_INVALID                    0x00000000 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_Y8                      0x00000001 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_X16A8Y8                 0x00000002 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_X24Y8                   0x00000003 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_A1R5G5B5                0x00000006 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_X1R5G5B5                0x00000007 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_X16A1R5G5B5             0x00000008 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_X17R5G5B5               0x00000009 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_R5G6B5                  0x0000000A /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_A16R5G6B5               0x0000000B /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_X16R5G6B5               0x0000000C /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_A8R8G8B8                0x0000000D /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_X8R8G8B8                0x0000000E /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_Y16                     0x0000000F /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_A16Y16                  0x00000010 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_X16Y16                  0x00000011 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_V8YB8U8YA8              0x00000012 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_YB8V8YA8U8              0x00000013 /* RW--V */
-#define NV_PGRAPH_FORMATS_SRC_LE_Y32                     0x00000014 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB                                  15:12 /* R-XVF */
-#define NV_PGRAPH_FORMATS_FB_INVALID                     0x00000000 /* RWI-V */
-#define NV_PGRAPH_FORMATS_FB_Y8                          0x00000001 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_X1R5G5B5_Z1R5G5B5           0x00000002 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_X1R5G5B5_O1R5G5B5           0x00000003 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_A1R5G5B5                    0x00000004 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_R5G6B5                      0x00000005 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_Y16                         0x00000006 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_X8R8G8B8_Z8R8G8B8           0x00000007 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_X8R8G8B8_O1Z7R8G8B8         0x00000008 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_X1A7R8G8B8_Z1A7R8G8B8       0x00000009 /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_X1A7R8G8B8_O1A7R8G8B8       0x0000000a /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_X8R8G8B8_O8R8G8B8           0x0000000b /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_A8R8G8B8                    0x0000000c /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_Y32                         0x0000000d /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_V8YB8U8YA8                  0x0000000e /* RW--V */
-#define NV_PGRAPH_FORMATS_FB_YB8V8YA8U8                  0x0000000f /* RW--V */ 
-#define NV_PGRAPH_ABS_X_RAM(i)                   (0x00400400+(i)*4) /* RW-4A */
-#define NV_PGRAPH_ABS_X_RAM__SIZE_1                              32 /*       */
-#define NV_PGRAPH_ABS_X_RAM_VALUE                              31:0 /* RWXUF */
-#define NV_PGRAPH_X_RAM_BPORT(i)                 (0x00400c00+(i)*4) /* R--4A */
-#define NV_PGRAPH_X_RAM_BPORT__SIZE_1                            32 /*       */
-#define NV_PGRAPH_X_RAM_BPORT_VALUE                            31:0 /* R--UF */
-#define NV_PGRAPH_ABS_Y_RAM(i)                   (0x00400480+(i)*4) /* RW-4A */
-#define NV_PGRAPH_ABS_Y_RAM__SIZE_1                              32 /*       */
-#define NV_PGRAPH_ABS_Y_RAM_VALUE                              31:0 /* RWXUF */
-#define NV_PGRAPH_Y_RAM_BPORT(i)                 (0x00400c80+(i)*4) /* R--4A */
-#define NV_PGRAPH_Y_RAM_BPORT__SIZE_1                            32 /*       */
-#define NV_PGRAPH_Y_RAM_BPORT_VALUE                            31:0 /* R--UF */
-#define NV_PGRAPH_XY_LOGIC_MISC0                         0x00400514 /* RW-4R */
-#define NV_PGRAPH_XY_LOGIC_MISC0_COUNTER                       17:0 /* RWBUF */
-#define NV_PGRAPH_XY_LOGIC_MISC0_COUNTER_0               0x00000000 /* RWB-V */
-#define NV_PGRAPH_XY_LOGIC_MISC0_DIMENSION                    20:20 /* RWVVF */
-#define NV_PGRAPH_XY_LOGIC_MISC0_DIMENSION_NONZERO       0x00000000 /* RWV-V */
-#define NV_PGRAPH_XY_LOGIC_MISC0_DIMENSION_ZERO          0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC0_INDEX                        31:28 /* RWBUF */
-#define NV_PGRAPH_XY_LOGIC_MISC0_INDEX_0                 0x00000000 /* RWB-V */
-#define NV_PGRAPH_XY_LOGIC_MISC1                         0x00400518 /* RW-4R */
-#define NV_PGRAPH_XY_LOGIC_MISC1_INITIAL                        0:0 /* RWNVF */
-#define NV_PGRAPH_XY_LOGIC_MISC1_INITIAL_NEEDED          0x00000000 /* RWN-V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_INITIAL_DONE            0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_XTRACLIPX                      4:4 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC1_XTRACLIPX_NOTNULL       0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_XTRACLIPX_NULL          0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_XTRACLIPY                      5:5 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC1_XTRACLIPY_NOTNULL       0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_XTRACLIPY_NULL          0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_SEL_XIMAX                    12:12 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC1_SEL_XIMAX_UUMAX         0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_SEL_XIMAX_IMAGEMAX      0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_SEL_YIMAX                    16:16 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC1_SEL_YIMAX_UUMAX         0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_SEL_YIMAX_IMAGEMAX      0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_SEL_XXTRA                    20:20 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC1_SEL_XXTRA_CLIPMAX       0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC1_SEL_XXTRA_IMAGEMAX      0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC2                         0x0040051C /* RW-4R */
-#define NV_PGRAPH_XY_LOGIC_MISC2_HANDOFF                        0:0 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC2_HANDOFF_DISABLE         0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_HANDOFF_ENABLE          0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_XTRACLIPX                      4:4 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC2_XTRACLIPX_NOTNULL       0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_XTRACLIPX_NULL          0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_XTRACLIPY                      5:5 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC2_XTRACLIPY_NOTNULL       0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_XTRACLIPY_NULL          0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_SEL_XIMAX                    12:12 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC2_SEL_XIMAX_UCMAX         0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_SEL_XIMAX_IMAGEMAX      0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_SEL_YIMAX                    16:16 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC2_SEL_YIMAX_UCMAX         0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_SEL_YIMAX_IMAGEMAX      0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_SEL_XXTRA                    20:20 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC2_SEL_XXTRA_CLIPMAX       0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC2_SEL_XXTRA_IMAGEMAX      0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC3                         0x00400520 /* RW-4R */
-#define NV_PGRAPH_XY_LOGIC_MISC3_WDIMY_EQ_0                     0:0 /* RWXVF */
-#define NV_PGRAPH_XY_LOGIC_MISC3_WDIMY_EQ_0_NULL         0x00000000 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC3_WDIMY_EQ_0_TRUE         0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC3_RELOAD_WDIMY                   4:4 /* RWXVF */
-#define NV_PGRAPH_XY_LOGIC_MISC3_RELOAD_WDIMY_NULL       0x00000000 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC3_RELOAD_WDIMY_TRUE       0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC3_RELOAD_WX                      8:8 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC3_RELOAD_WX_NULL          0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC3_RELOAD_WX_TRUE          0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC3_TEXT_ALG                     12:12 /* RWIVF */
-#define NV_PGRAPH_XY_LOGIC_MISC3_TEXT_ALG_NULL           0x00000000 /* RWI-V */
-#define NV_PGRAPH_XY_LOGIC_MISC3_TEXT_ALG_TRUE           0x00000001 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC3_TEXT_DIMX                    22:16 /* RWXUF */
-#define NV_PGRAPH_XY_LOGIC_MISC3_TEXT_DIMX_0             0x00000000 /* RW--V */
-#define NV_PGRAPH_XY_LOGIC_MISC3_TEXT_WDIMX                   30:24 /* RWXUF */
-#define NV_PGRAPH_XY_LOGIC_MISC3_TEXT_WDIMX_0            0x00000000 /* RW--V */
-#define NV_PGRAPH_X_MISC                                 0x00400500 /* RW-4R */
-#define NV_PGRAPH_X_MISC_BIT33_0                                0:0 /* RWNVF */
-#define NV_PGRAPH_X_MISC_BIT33_0_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_X_MISC_BIT33_1                                1:1 /* RWNVF */
-#define NV_PGRAPH_X_MISC_BIT33_1_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_X_MISC_BIT33_2                                2:2 /* RWNVF */
-#define NV_PGRAPH_X_MISC_BIT33_2_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_X_MISC_BIT33_3                                3:3 /* RWNVF */
-#define NV_PGRAPH_X_MISC_BIT33_3_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_X_MISC_RANGE_0                                4:4 /* RWNVF */
-#define NV_PGRAPH_X_MISC_RANGE_0_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_X_MISC_RANGE_1                                5:5 /* RWNVF */
-#define NV_PGRAPH_X_MISC_RANGE_1_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_X_MISC_RANGE_2                                6:6 /* RWNVF */
-#define NV_PGRAPH_X_MISC_RANGE_2_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_X_MISC_RANGE_3                                7:7 /* RWNVF */
-#define NV_PGRAPH_X_MISC_RANGE_3_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_X_MISC_ADDER_OUTPUT                         29:28 /* RWXVF */
-#define NV_PGRAPH_X_MISC_ADDER_OUTPUT_EQ_0               0x00000000 /* RW--V */
-#define NV_PGRAPH_X_MISC_ADDER_OUTPUT_LT_0               0x00000001 /* RW--V */
-#define NV_PGRAPH_X_MISC_ADDER_OUTPUT_GT_0               0x00000002 /* RW--V */
-#define NV_PGRAPH_Y_MISC                                 0x00400504 /* RW-4R */
-#define NV_PGRAPH_Y_MISC_BIT33_0                                0:0 /* RWNVF */
-#define NV_PGRAPH_Y_MISC_BIT33_0_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_Y_MISC_BIT33_1                                1:1 /* RWNVF */
-#define NV_PGRAPH_Y_MISC_BIT33_1_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_Y_MISC_BIT33_2                                2:2 /* RWNVF */
-#define NV_PGRAPH_Y_MISC_BIT33_2_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_Y_MISC_BIT33_3                                3:3 /* RWNVF */
-#define NV_PGRAPH_Y_MISC_BIT33_3_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_Y_MISC_RANGE_0                                4:4 /* RWNVF */
-#define NV_PGRAPH_Y_MISC_RANGE_0_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_Y_MISC_RANGE_1                                5:5 /* RWNVF */
-#define NV_PGRAPH_Y_MISC_RANGE_1_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_Y_MISC_RANGE_2                                6:6 /* RWNVF */
-#define NV_PGRAPH_Y_MISC_RANGE_2_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_Y_MISC_RANGE_3                                7:7 /* RWNVF */
-#define NV_PGRAPH_Y_MISC_RANGE_3_0                       0x00000000 /* RWN-V */
-#define NV_PGRAPH_Y_MISC_ADDER_OUTPUT                         29:28 /* RWXVF */
-#define NV_PGRAPH_Y_MISC_ADDER_OUTPUT_EQ_0               0x00000000 /* RW--V */
-#define NV_PGRAPH_Y_MISC_ADDER_OUTPUT_LT_0               0x00000001 /* RW--V */
-#define NV_PGRAPH_Y_MISC_ADDER_OUTPUT_GT_0               0x00000002 /* RW--V */
-#define NV_PGRAPH_ABS_UCLIP_XMIN                         0x0040053C /* RW-4R */
-#define NV_PGRAPH_ABS_UCLIP_XMIN_VALUE                         15:0 /* RWXSF */
-#define NV_PGRAPH_ABS_UCLIP_XMAX                         0x00400544 /* RW-4R */
-#define NV_PGRAPH_ABS_UCLIP_XMAX_VALUE                         17:0 /* RWXSF */
-#define NV_PGRAPH_ABS_UCLIP_YMIN                         0x00400540 /* RW-4R */
-#define NV_PGRAPH_ABS_UCLIP_YMIN_VALUE                         15:0 /* RWXSF */
-#define NV_PGRAPH_ABS_UCLIP_YMAX                         0x00400548 /* RW-4R */
-#define NV_PGRAPH_ABS_UCLIP_YMAX_VALUE                         17:0 /* RWXSF */
-#define NV_PGRAPH_ABS_UCLIPA_XMIN                        0x00400560 /* RW-4R */
-#define NV_PGRAPH_ABS_UCLIPA_XMIN_VALUE                        15:0 /* RWXSF */
-#define NV_PGRAPH_ABS_UCLIPA_XMAX                        0x00400568 /* RW-4R */
-#define NV_PGRAPH_ABS_UCLIPA_XMAX_VALUE                        17:0 /* RWXSF */
-#define NV_PGRAPH_ABS_UCLIPA_YMIN                        0x00400564 /* RW-4R */
-#define NV_PGRAPH_ABS_UCLIPA_YMIN_VALUE                        15:0 /* RWXSF */
-#define NV_PGRAPH_ABS_UCLIPA_YMAX                        0x0040056C /* RW-4R */
-#define NV_PGRAPH_ABS_UCLIPA_YMAX_VALUE                        17:0 /* RWXSF */
-#define NV_PGRAPH_SOURCE_COLOR                           0x0040050C /* RW-4R */
-#define NV_PGRAPH_SOURCE_COLOR_VALUE                           31:0 /* RWNVF */
-#define NV_PGRAPH_SOURCE_COLOR_VALUE_0                   0x00000000 /* RWN-V */
-#define NV_PGRAPH_VALID1                                 0x00400508 /* RW-4R */
-#define NV_PGRAPH_VALID1_VLD                                   22:0 /* RWNVF */
-#define NV_PGRAPH_VALID1_VLD_0                           0x00000000 /* RWN-V */
-#define NV_PGRAPH_VALID1_CLIP_MIN                             28:28 /* RWIVF */
-#define NV_PGRAPH_VALID1_CLIP_MIN_NO_ERROR               0x00000000 /* RWI-V */
-#define NV_PGRAPH_VALID1_CLIP_MIN_ONLY                   0x00000001 /* RW--V */
-#define NV_PGRAPH_VALID1_CLIPA_MIN                            29:29 /* RWIVF */
-#define NV_PGRAPH_VALID1_CLIPA_MIN_NO_ERROR              0x00000000 /* RWI-V */
-#define NV_PGRAPH_VALID1_CLIPA_MIN_ONLY                  0x00000001 /* RW--V */
-#define NV_PGRAPH_VALID1_CLIP_MAX                             30:30 /* RWIVF */
-#define NV_PGRAPH_VALID1_CLIP_MAX_NO_ERROR               0x00000000 /* RWI-V */
-#define NV_PGRAPH_VALID1_CLIP_MAX_ONLY                   0x00000001 /* RW--V */
-#define NV_PGRAPH_VALID1_CLIPA_MAX                            31:31 /* RWIVF */
-#define NV_PGRAPH_VALID1_CLIPA_MAX_NO_ERROR              0x00000000 /* RWI-V */
-#define NV_PGRAPH_VALID1_CLIPA_MAX_ONLY                  0x00000001 /* RW--V */
-#define NV_PGRAPH_VALID2                                 0x00400578 /* RW-4R */
-#define NV_PGRAPH_VALID2_VLD2                                  28:0 /* RWNVF */
-#define NV_PGRAPH_VALID2_VLD2_0                          0x00000000 /* RWN-V */
-#define NV_PGRAPH_ABS_ICLIP_XMAX                         0x00400534 /* RW-4R */
-#define NV_PGRAPH_ABS_ICLIP_XMAX_VALUE                         17:0 /* RWXSF */
-#define NV_PGRAPH_ABS_ICLIP_YMAX                         0x00400538 /* RW-4R */
-#define NV_PGRAPH_ABS_ICLIP_YMAX_VALUE                         17:0 /* RWXSF */
-#define NV_PGRAPH_CLIPX_0                                0x00400524 /* RW-4R */
-#define NV_PGRAPH_CLIPX_0_CLIP0_MIN                             1:0 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP0_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP0_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP0_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP0_MAX                             3:2 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP0_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP0_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP0_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP1_MIN                             5:4 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP1_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP1_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP1_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP1_MAX                             7:6 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP1_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP1_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP1_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP2_MIN                             9:8 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP2_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP2_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP2_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP2_MAX                           11:10 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP2_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP2_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP2_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP3_MIN                           13:12 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP3_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP3_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP3_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP3_MAX                           15:14 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP3_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP3_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP3_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP4_MIN                           17:16 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP4_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP4_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP4_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP4_MAX                           19:18 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP4_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP4_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP4_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP5_MIN                           21:20 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP5_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP5_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP5_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP5_MAX                           23:22 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP5_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP5_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP5_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP6_MIN                           25:24 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP6_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP6_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP6_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP6_MAX                           27:26 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP6_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP6_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP6_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP7_MIN                           29:28 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP7_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP7_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP7_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP7_MAX                           31:30 /* RWNVF */
-#define NV_PGRAPH_CLIPX_0_CLIP7_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_0_CLIP7_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_0_CLIP7_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1                                0x00400528 /* RW-4R */
-#define NV_PGRAPH_CLIPX_1_CLIP8_MIN                             1:0 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP8_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP8_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP8_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP8_MAX                             3:2 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP8_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP8_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP8_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP9_MIN                             5:4 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP9_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP9_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP9_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP9_MAX                             7:6 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP9_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP9_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP9_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP10_MIN                            9:8 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP10_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP10_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP10_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP10_MAX                          11:10 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP10_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP10_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP10_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP11_MIN                          13:12 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP11_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP11_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP11MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP11_MAX                          15:14 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP11_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP11_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP11_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP12_MIN                          17:16 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP12_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP12_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP12_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP12_MAX                          19:18 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP12_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP12_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP12_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP13_MIN                          21:20 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP13_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP13_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP13_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP13_MAX                          23:22 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP13_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP13_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP13_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP14_MIN                          25:24 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP14_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP14_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP14_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP14_MAX                          27:26 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP14_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP14_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP14_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP15_MIN                          29:28 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP15_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP15_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP15_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP15_MAX                          31:30 /* RWNVF */
-#define NV_PGRAPH_CLIPX_1_CLIP15_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPX_1_CLIP15_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPX_1_CLIP15_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0                                0x0040052c /* RW-4R */
-#define NV_PGRAPH_CLIPY_0_CLIP0_MIN                             1:0 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP0_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP0_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP0_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP0_MAX                             3:2 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP0_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP0_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP0_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP1_MIN                             5:4 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP1_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP1_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP1_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP1_MAX                             7:6 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP1_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP1_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP1_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP2_MIN                             9:8 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP2_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP2_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP2_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP2_MAX                           11:10 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP2_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP2_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP2_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP3_MIN                           13:12 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP3_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP3_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP3_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP3_MAX                           15:14 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP3_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP3_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP3_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP4_MIN                           17:16 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP4_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP4_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP4_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP4_MAX                           19:18 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP4_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP4_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP4_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP5_MIN                           21:20 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP5_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP5_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP5_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP5_MAX                           23:22 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP5_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP5_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP5_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP6_MIN                           25:24 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP6_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP6_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP6_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP6_MAX                           27:26 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP6_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP6_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP6_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP7_MIN                           29:28 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP7_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP7_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP7_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP7_MAX                           31:30 /* RWNVF */
-#define NV_PGRAPH_CLIPY_0_CLIP7_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_0_CLIP7_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_0_CLIP7_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1                                0x00400530 /* RW-4R */
-#define NV_PGRAPH_CLIPY_1_CLIP8_MIN                             1:0 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP8_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP8_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP8_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP8_MAX                             3:2 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP8_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP8_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP8_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP9_MIN                             5:4 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP9_MIN_GT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP9_MIN_LT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP9_MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP9_MAX                             7:6 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP9_MAX_LT                   0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP9_MAX_GT                   0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP9_MAX_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP10_MIN                            9:8 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP10_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP10_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP10_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP10_MAX                          11:10 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP10_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP10_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP10_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP11_MIN                          13:12 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP11_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP11_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP11MIN_EQ                   0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP11_MAX                          15:14 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP11_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP11_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP11_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP12_MIN                          17:16 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP12_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP12_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP12_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP12_MAX                          19:18 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP12_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP12_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP12_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP13_MIN                          21:20 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP13_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP13_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP13_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP13_MAX                          23:22 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP13_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP13_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP13_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP14_MIN                          25:24 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP14_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP14_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP14_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP14_MAX                          27:26 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP14_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP14_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP14_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP15_MIN                          29:28 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP15_MIN_GT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP15_MIN_LT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP15_MIN_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP15_MAX                          31:30 /* RWNVF */
-#define NV_PGRAPH_CLIPY_1_CLIP15_MAX_LT                  0x00000000 /* RW--V */
-#define NV_PGRAPH_CLIPY_1_CLIP15_MAX_GT                  0x00000001 /* RWN-V */
-#define NV_PGRAPH_CLIPY_1_CLIP15_MAX_EQ                  0x00000002 /* RW--V */
-#define NV_PGRAPH_MISC24_0                               0x00400510 /* RW-4R */
-#define NV_PGRAPH_MISC24_0_VALUE                               23:0 /* RWXUF */
-#define NV_PGRAPH_MISC24_1                               0x00400570 /* RW-4R */
-#define NV_PGRAPH_MISC24_1_VALUE                               23:0 /* RWXUF */
-#define NV_PGRAPH_MISC24_2                               0x00400574 /* RW-4R */
-#define NV_PGRAPH_MISC24_2_VALUE                               23:0 /* RWXUF */
-#define NV_PGRAPH_PASSTHRU_0                             0x0040057C /* RW-4R */
-#define NV_PGRAPH_PASSTHRU_0_VALUE                             31:0 /* RWXUF */
-#define NV_PGRAPH_PASSTHRU_1                             0x00400580 /* RW-4R */
-#define NV_PGRAPH_PASSTHRU_1_VALUE                             31:0 /* RWXUF */
-#define NV_PGRAPH_PASSTHRU_2                             0x00400584 /* RW-4R */
-#define NV_PGRAPH_PASSTHRU_2_VALUE                             31:0 /* RWXUF */
-#define NV_PGRAPH_U_RAM(i)                       (0x00400d00+(i)*4) /* RW-4A */
-#define NV_PGRAPH_U_RAM__SIZE_1                                  16 /*       */
-#define NV_PGRAPH_U_RAM_VALUE                                  31:6 /* RWXFF */
-#define NV_PGRAPH_V_RAM(i)                       (0x00400d40+(i)*4) /* RW-4A */
-#define NV_PGRAPH_V_RAM__SIZE_1                                  16 /*       */
-#define NV_PGRAPH_V_RAM_VALUE                                  31:6 /* RWXFF */
-#define NV_PGRAPH_M_RAM(i)                       (0x00400d80+(i)*4) /* RW-4A */
-#define NV_PGRAPH_M_RAM__SIZE_1                                  16 /*       */
-#define NV_PGRAPH_M_RAM_VALUE                                  31:6 /* RWXFF */
-#define NV_PGRAPH_DMA_START_0                            0x00401000 /* RW-4R */
-#define NV_PGRAPH_DMA_START_0_VALUE                            31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_START_1                            0x00401004 /* RW-4R */
-#define NV_PGRAPH_DMA_START_1_VALUE                            31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_LENGTH                             0x00401008 /* RW-4R */
-#define NV_PGRAPH_DMA_LENGTH_VALUE                             21:0 /* RWXUF */
-#define NV_PGRAPH_DMA_MISC                               0x0040100C /* RW-4R */
-#define NV_PGRAPH_DMA_MISC_COUNT                               15:0 /* RWXUF */
-#define NV_PGRAPH_DMA_MISC_FMT_SRC                            18:16 /* RWXVF */
-#define NV_PGRAPH_DMA_MISC_FMT_DST                            22:20 /* RWXVF */
-#define NV_PGRAPH_DMA_DATA_0                             0x00401020 /* RW-4R */
-#define NV_PGRAPH_DMA_DATA_0_VALUE                             31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_DATA_1                             0x00401024 /* RW-4R */
-#define NV_PGRAPH_DMA_DATA_1_VALUE                             31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_RM                                 0x00401030 /* RW-4R */
-#define NV_PGRAPH_DMA_RM_ASSIST_A                               0:0 /* RWIVF */
-#define NV_PGRAPH_DMA_RM_ASSIST_A_NOT_PENDING            0x00000000 /* R-I-V */
-#define NV_PGRAPH_DMA_RM_ASSIST_A_PENDING                0x00000001 /* R---V */
-#define NV_PGRAPH_DMA_RM_ASSIST_A_RESET                  0x00000001 /* -W--C */
-#define NV_PGRAPH_DMA_RM_ASSIST_B                               1:1 /* RWIVF */
-#define NV_PGRAPH_DMA_RM_ASSIST_B_NOT_PENDING            0x00000000 /* R-I-V */
-#define NV_PGRAPH_DMA_RM_ASSIST_B_PENDING                0x00000001 /* R---V */
-#define NV_PGRAPH_DMA_RM_ASSIST_B_RESET                  0x00000001 /* -W--C */
-#define NV_PGRAPH_DMA_RM_WRITE_REQ                              4:4 /* CWIVF */
-#define NV_PGRAPH_DMA_RM_WRITE_REQ_NOT_PENDING           0x00000000 /* CWI-V */
-#define NV_PGRAPH_DMA_RM_WRITE_REQ_PENDING               0x00000001 /* -W--T */
-#define NV_PGRAPH_DMA_A_XLATE_INST                       0x00401040 /* RW-4R */
-#define NV_PGRAPH_DMA_A_XLATE_INST_VALUE                       15:0 /* RWXUF */
-#define NV_PGRAPH_DMA_A_CONTROL                          0x00401044 /* RW-4R */
-#define NV_PGRAPH_DMA_A_CONTROL_PAGE_TABLE                    12:12 /* RWIVF */
-#define NV_PGRAPH_DMA_A_CONTROL_PAGE_TABLE_NOT_PRESENT   0x00000000 /* RWI-V */
-#define NV_PGRAPH_DMA_A_CONTROL_PAGE_TABLE_PRESENT       0x00000001 /* RW--V */
-#define NV_PGRAPH_DMA_A_CONTROL_PAGE_ENTRY                    13:13 /* RWXVF */
-#define NV_PGRAPH_DMA_A_CONTROL_PAGE_ENTRY_NOT_LINEAR    0x00000000 /* RW--V */
-#define NV_PGRAPH_DMA_A_CONTROL_PAGE_ENTRY_LINEAR        0x00000001 /* RW--V */
-#define NV_PGRAPH_DMA_A_CONTROL_TARGET_NODE                   17:16 /* RWXUF */
-#define NV_PGRAPH_DMA_A_CONTROL_TARGET_NODE_NVM          0x00000000 /* RW--V */
-#define NV_PGRAPH_DMA_A_CONTROL_TARGET_NODE_PCI          0x00000002 /* RW--V */
-#define NV_PGRAPH_DMA_A_CONTROL_TARGET_NODE_AGP          0x00000003 /* RW--V */
-#define NV_PGRAPH_DMA_A_CONTROL_ADJUST                        31:20 /* RWXUF */
-#define NV_PGRAPH_DMA_A_LIMIT                            0x00401048 /* RW-4R */
-#define NV_PGRAPH_DMA_A_LIMIT_OFFSET                           31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_A_TLB_PTE                          0x0040104C /* RW-4R */
-#define NV_PGRAPH_DMA_A_TLB_PTE_ACCESS                          1:1 /* RWXVF */
-#define NV_PGRAPH_DMA_A_TLB_PTE_ACCESS_READ_ONLY         0x00000000 /* RW--V */
-#define NV_PGRAPH_DMA_A_TLB_PTE_ACCESS_READ_WRITE        0x00000001 /* RW--V */
-#define NV_PGRAPH_DMA_A_TLB_PTE_FRAME_ADDRESS                 31:12 /* RWXUF */
-#define NV_PGRAPH_DMA_A_TLB_TAG                          0x00401050 /* RW-4R */
-#define NV_PGRAPH_DMA_A_TLB_TAG_ADDRESS                       31:12 /* RWXUF */
-#define NV_PGRAPH_DMA_A_ADJ_OFFSET                       0x00401054 /* RW-4R */
-#define NV_PGRAPH_DMA_A_ADJ_OFFSET_VALUE                       31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_A_OFFSET                           0x00401058 /* RW-4R */
-#define NV_PGRAPH_DMA_A_OFFSET_VALUE                           31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_A_SIZE                             0x0040105C /* RW-4R */
-#define NV_PGRAPH_DMA_A_SIZE_VALUE                             24:0 /* RWXUF */
-#define NV_PGRAPH_DMA_A_Y_SIZE                           0x00401060 /* RW-4R */
-#define NV_PGRAPH_DMA_A_Y_SIZE_VALUE                           10:0 /* RWXUF */
-#define NV_PGRAPH_DMA_B_XLATE_INST                       0x00401080 /* RW-4R */
-#define NV_PGRAPH_DMA_B_XLATE_INST_VALUE                       15:0 /* RWXUF */
-#define NV_PGRAPH_DMA_B_CONTROL                          0x00401084 /* RW-4R */
-#define NV_PGRAPH_DMA_B_CONTROL_PAGE_TABLE                    12:12 /* RWIVF */
-#define NV_PGRAPH_DMA_B_CONTROL_PAGE_TABLE_NOT_PRESENT   0x00000000 /* RWI-V */
-#define NV_PGRAPH_DMA_B_CONTROL_PAGE_TABLE_PRESENT       0x00000001 /* RW--V */
-#define NV_PGRAPH_DMA_B_CONTROL_PAGE_ENTRY                    13:13 /* RWXVF */
-#define NV_PGRAPH_DMA_B_CONTROL_PAGE_ENTRY_NOT_LINEAR    0x00000000 /* RW--V */
-#define NV_PGRAPH_DMA_B_CONTROL_PAGE_ENTRY_LINEAR        0x00000001 /* RW--V */
-#define NV_PGRAPH_DMA_B_CONTROL_TARGET_NODE                   17:16 /* RWXUF */
-#define NV_PGRAPH_DMA_B_CONTROL_TARGET_NODE_NVM          0x00000000 /* RW--V */
-#define NV_PGRAPH_DMA_B_CONTROL_TARGET_NODE_PCI          0x00000002 /* RW--V */
-#define NV_PGRAPH_DMA_B_CONTROL_TARGET_NODE_AGP          0x00000003 /* RW--V */
-#define NV_PGRAPH_DMA_B_CONTROL_ADJUST                        31:20 /* RWXUF */
-#define NV_PGRAPH_DMA_B_LIMIT                            0x00401088 /* RW-4R */
-#define NV_PGRAPH_DMA_B_LIMIT_OFFSET                           31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_B_TLB_PTE                          0x0040108C /* RW-4R */
-#define NV_PGRAPH_DMA_B_TLB_PTE_ACCESS                          1:1 /* RWXVF */
-#define NV_PGRAPH_DMA_B_TLB_PTE_ACCESS_READ_ONLY         0x00000000 /* RW--V */
-#define NV_PGRAPH_DMA_B_TLB_PTE_ACCESS_READ_WRITE        0x00000001 /* RW--V */
-#define NV_PGRAPH_DMA_B_TLB_PTE_FRAME_ADDRESS                 31:12 /* RWXUF */
-#define NV_PGRAPH_DMA_B_TLB_TAG                          0x00401090 /* RW-4R */
-#define NV_PGRAPH_DMA_B_TLB_TAG_ADDRESS                       31:12 /* RWXUF */
-#define NV_PGRAPH_DMA_B_ADJ_OFFSET                       0x00401094 /* RW-4R */
-#define NV_PGRAPH_DMA_B_ADJ_OFFSET_VALUE                       31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_B_OFFSET                           0x00401098 /* RW-4R */
-#define NV_PGRAPH_DMA_B_OFFSET_VALUE                           31:0 /* RWXUF */
-#define NV_PGRAPH_DMA_B_SIZE                             0x0040109C /* RW-4R */
-#define NV_PGRAPH_DMA_B_SIZE_VALUE                             24:0 /* RWXUF */
-#define NV_PGRAPH_DMA_B_Y_SIZE                           0x004010A0 /* RW-4R */
-#define NV_PGRAPH_DMA_B_Y_SIZE_VALUE                           10:0 /* RWXUF */
-
-/* Framebuffer registers */
-#define NV_PFB                                0x00100FFF:0x00100000 /* RW--D */
-#define NV_PFB_BOOT_0                                    0x00100000 /* RW-4R */
-#define NV_PFB_BOOT_0_RAM_AMOUNT                                1:0 /* RW-VF */
-#define NV_PFB_BOOT_0_RAM_AMOUNT_32MB                    0x00000000 /* RW--V */
-#define NV_PFB_BOOT_0_RAM_AMOUNT_4MB                     0x00000001 /* RW--V */
-#define NV_PFB_BOOT_0_RAM_AMOUNT_8MB                     0x00000002 /* RW--V */
-#define NV_PFB_BOOT_0_RAM_AMOUNT_16MB                    0x00000003 /* RW--V */
-#define NV_PFB_BOOT_0_RAM_WIDTH_128                             2:2 /* RW-VF */
-#define NV_PFB_BOOT_0_RAM_WIDTH_128_OFF                  0x00000000 /* RW--V */
-#define NV_PFB_BOOT_0_RAM_WIDTH_128_ON                   0x00000001 /* RW--V */
-#define NV_PFB_BOOT_0_RAM_TYPE                                  4:3 /* RW-VF */
-#define NV_PFB_BOOT_0_RAM_TYPE_256K                      0x00000000 /* RW--V */
-#define NV_PFB_BOOT_0_RAM_TYPE_512K_2BANK                0x00000001 /* RW--V */
-#define NV_PFB_BOOT_0_RAM_TYPE_512K_4BANK                0x00000002 /* RW--V */
-#define NV_PFB_BOOT_0_RAM_TYPE_1024K_2BANK               0x00000003 /* RW--V */
-#define NV_PFB_CONFIG_0                                  0x00100200 /* RW-4R */
-#define NV_PFB_CONFIG_0_TYPE                                   14:0 /* RWIVF */
-#define NV_PFB_CONFIG_0_TYPE_OLD1024_FIXED_8BPP          0x00000120 /* RW--V */
-#define NV_PFB_CONFIG_0_TYPE_OLD1024_FIXED_16BPP         0x00000220 /* RW--V */
-#define NV_PFB_CONFIG_0_TYPE_OLD1024_FIXED_32BPP         0x00000320 /* RW--V */
-#define NV_PFB_CONFIG_0_TYPE_OLD1024_VAR_8BPP            0x00004120 /* RW--V */
-#define NV_PFB_CONFIG_0_TYPE_OLD1024_VAR_16BPP           0x00004220 /* RW--V */
-#define NV_PFB_CONFIG_0_TYPE_OLD1024_VAR_32BPP           0x00004320 /* RW--V */
-#define NV_PFB_CONFIG_0_TYPE_TETRIS                      0x00002000 /* RW--V */
-#define NV_PFB_CONFIG_0_TYPE_NOTILING                    0x00001114 /* RWI-V */
-#define NV_PFB_CONFIG_0_TETRIS_MODE                           17:15 /* RWI-F */
-#define NV_PFB_CONFIG_0_TETRIS_MODE_PASS                 0x00000000 /* RWI-V */
-#define NV_PFB_CONFIG_0_TETRIS_MODE_1                    0x00000001 /* RW--V */
-#define NV_PFB_CONFIG_0_TETRIS_MODE_2                    0x00000002 /* RW--V */
-#define NV_PFB_CONFIG_0_TETRIS_MODE_3                    0x00000003 /* RW--V */
-#define NV_PFB_CONFIG_0_TETRIS_MODE_4                    0x00000004 /* RW--V */
-#define NV_PFB_CONFIG_0_TETRIS_MODE_5                    0x00000005 /* RW--V */
-#define NV_PFB_CONFIG_0_TETRIS_MODE_6                    0x00000006 /* RW--V */
-#define NV_PFB_CONFIG_0_TETRIS_MODE_7                    0x00000007 /* RW--V */
-#define NV_PFB_CONFIG_0_TETRIS_SHIFT                          19:18 /* RWI-F */
-#define NV_PFB_CONFIG_0_TETRIS_SHIFT_0                   0x00000000 /* RWI-V */
-#define NV_PFB_CONFIG_0_TETRIS_SHIFT_1                   0x00000001 /* RW--V */
-#define NV_PFB_CONFIG_0_TETRIS_SHIFT_2                   0x00000002 /* RW--V */
-#define NV_PFB_CONFIG_0_BANK_SWAP                             22:20 /* RWI-F */
-#define NV_PFB_CONFIG_0_BANK_SWAP_OFF                    0x00000000 /* RWI-V */
-#define NV_PFB_CONFIG_0_BANK_SWAP_1M                     0x00000001 /* RW--V */
-#define NV_PFB_CONFIG_0_BANK_SWAP_2M                     0x00000005 /* RW--V */
-#define NV_PFB_CONFIG_0_BANK_SWAP_4M                     0x00000007 /* RW--V */
-#define NV_PFB_CONFIG_0_UNUSED                                23:23 /* RW-VF */
-#define NV_PFB_CONFIG_0_SCRAMBLE_EN                           29:29 /* RWIVF */
-#define NV_PFB_CONFIG_0_SCRAMBLE_EN_INIT                 0x00000000 /* RW--V */
-#define NV_PFB_CONFIG_0_SCRAMBLE_ACTIVE                  0x00000001 /* RW--V */
-#define NV_PFB_CONFIG_0_PRAMIN_WR                             28:28 /* RWIVF */
-#define NV_PFB_CONFIG_0_PRAMIN_WR_INIT                   0x00000000 /* RW--V */
-#define NV_PFB_CONFIG_0_PRAMIN_WR_DISABLED               0x00000001 /* RW--V */
-#define NV_PFB_CONFIG_0_PRAMIN_WR_MASK                        27:24 /* RWIVF */
-#define NV_PFB_CONFIG_0_PRAMIN_WR_MASK_INIT              0x00000000 /* RWI-V */
-#define NV_PFB_CONFIG_0_PRAMIN_WR_MASK_CLEAR             0x0000000f /* RWI-V */
-#define NV_PFB_CONFIG_1                                  0x00100204 /* RW-4R */
-#define NV_PFB_RTL                                       0x00100300 /* RW-4R */
-#define NV_PFB_RTL_H                                            0:0 /* RWIUF */
-#define NV_PFB_RTL_H_DEFAULT                             0x00000000 /* RWI-V */
-#define NV_PFB_RTL_MC                                           1:1 /* RWIUF */
-#define NV_PFB_RTL_MC_DEFAULT                            0x00000000 /* RWI-V */
-#define NV_PFB_RTL_V                                            2:2 /* RWIUF */
-#define NV_PFB_RTL_V_DEFAULT                             0x00000000 /* RWI-V */
-#define NV_PFB_RTL_G                                            3:3 /* RWIUF */
-#define NV_PFB_RTL_G_DEFAULT                             0x00000000 /* RWI-V */
-#define NV_PFB_RTL_GB                                           4:4 /* RWIUF */
-#define NV_PFB_RTL_GB_DEFAULT                            0x00000000 /* RWI-V */
-#define NV_PFB_CONFIG_0_RESOLUTION                              5:0 /* RWIVF */
-#define NV_PFB_CONFIG_0_RESOLUTION_320_PIXELS            0x0000000a /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_400_PIXELS            0x0000000d /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_480_PIXELS            0x0000000f /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_512_PIXELS            0x00000010 /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_640_PIXELS            0x00000014 /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_800_PIXELS            0x00000019 /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_960_PIXELS            0x0000001e /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_1024_PIXELS           0x00000020 /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_1152_PIXELS           0x00000024 /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_1280_PIXELS           0x00000028 /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_1600_PIXELS           0x00000032 /* RW--V */
-#define NV_PFB_CONFIG_0_RESOLUTION_DEFAULT               0x00000014 /* RWI-V */
-#define NV_PFB_CONFIG_0_PIXEL_DEPTH                             9:8 /* RWIVF */
-#define NV_PFB_CONFIG_0_PIXEL_DEPTH_8_BITS               0x00000001 /* RW--V */
-#define NV_PFB_CONFIG_0_PIXEL_DEPTH_16_BITS              0x00000002 /* RW--V */
-#define NV_PFB_CONFIG_0_PIXEL_DEPTH_32_BITS              0x00000003 /* RW--V */
-#define NV_PFB_CONFIG_0_PIXEL_DEPTH_DEFAULT              0x00000001 /* RWI-V */
-#define NV_PFB_CONFIG_0_TILING                                12:12 /* RWIVF */
-#define NV_PFB_CONFIG_0_TILING_ENABLED                   0x00000000 /* RW--V */
-#define NV_PFB_CONFIG_0_TILING_DISABLED                  0x00000001 /* RWI-V */
-#define NV_PFB_CONFIG_1_SGRAM100                                3:3 /* RWIVF */
-#define NV_PFB_CONFIG_1_SGRAM100_ENABLED                 0x00000000 /* RWI-V */
-#define NV_PFB_CONFIG_1_SGRAM100_DISABLED                0x00000001 /* RW--V */
-#define NV_PFB_DEBUG_0_CKE_ALWAYSON                           29:29 /* RWIVF */
-#define NV_PFB_DEBUG_0_CKE_ALWAYSON_OFF                  0x00000000 /* RW--V */
-#define NV_PFB_DEBUG_0_CKE_ALWAYSON_ON                   0x00000001 /* RWI-V */
-
-#define NV_PEXTDEV                            0x00101FFF:0x00101000 /* RW--D */
-#define NV_PEXTDEV_BOOT_0                                0x00101000 /* R--4R */
-#define NV_PEXTDEV_BOOT_0_STRAP_BUS_SPEED                       0:0 /* R-XVF */
-#define NV_PEXTDEV_BOOT_0_STRAP_BUS_SPEED_33MHZ          0x00000000 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_BUS_SPEED_66MHZ          0x00000001 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_SUB_VENDOR                      1:1 /* R-XVF */
-#define NV_PEXTDEV_BOOT_0_STRAP_SUB_VENDOR_NO_BIOS       0x00000000 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_SUB_VENDOR_BIOS          0x00000001 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_RAM_TYPE                        3:2 /* R-XVF */
-#define NV_PEXTDEV_BOOT_0_STRAP_RAM_TYPE_SGRAM_256K      0x00000000 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_RAM_TYPE_SGRAM_512K_2BANK 0x00000001 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_RAM_TYPE_SGRAM_512K_4BANK 0x00000002 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_RAM_TYPE_1024K_2BANK     0x00000003 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_RAM_WIDTH                       4:4 /* R-XVF */
-#define NV_PEXTDEV_BOOT_0_STRAP_RAM_WIDTH_64             0x00000000 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_RAM_WIDTH_128            0x00000001 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_BUS_TYPE                        5:5 /* R-XVF */
-#define NV_PEXTDEV_BOOT_0_STRAP_BUS_TYPE_PCI             0x00000000 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_BUS_TYPE_AGP             0x00000001 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_CRYSTAL                         6:6 /* R-XVF */
-#define NV_PEXTDEV_BOOT_0_STRAP_CRYSTAL_13500K           0x00000000 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_CRYSTAL_14318180         0x00000001 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_TVMODE                          8:7 /* R-XVF */
-#define NV_PEXTDEV_BOOT_0_STRAP_TVMODE_SECAM             0x00000000 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_TVMODE_NTSC              0x00000001 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_TVMODE_PAL               0x00000002 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_TVMODE_DISABLED          0x00000003 /* R---V */
-#define NV_PEXTDEV_BOOT_0_STRAP_OVERWRITE                     11:11 /* RWIVF */
-#define NV_PEXTDEV_BOOT_0_STRAP_OVERWRITE_DISABLED       0x00000000 /* RWI-V */
-#define NV_PEXTDEV_BOOT_0_STRAP_OVERWRITE_ENABLED        0x00000001 /* RW--V */
-
-/* Extras */
-#define NV_PRAMIN                             0x007FFFFF:0x00700000 /* RW--M */
-/*#define NV_PRAMIN                             0x00FFFFFF:0x00C00000*/
-#define NV_PNVM                               0x01FFFFFF:0x01000000 /* RW--M */
-/*#define NV_PNVM                               0x00BFFFFF:0x00800000*/
-#define NV_CHAN0                              0x0080ffff:0x00800000
-
-/* FIFO subchannels */
-#define NV_UROP                               0x43
-#define NV_UCHROMA                            0x57
-#define NV_UCLIP                              0x19
-#define NV_UPATT                              0x18
-#define NV_ULIN                               0x5C
-#define NV_UTRI                               0x5D
-#define NV_URECT                              0x5E
-#define NV_UBLIT                              0x5F
-#define NV_UGLYPH                             0x4B
-
-#endif /*__NV4REF_H__*/
-
diff --git a/drivers/video/riva/nv_driver.c b/drivers/video/riva/nv_driver.c
index be630a0ccfd4..a11026812d1b 100644
--- a/drivers/video/riva/nv_driver.c
+++ b/drivers/video/riva/nv_driver.c
@@ -231,12 +231,14 @@ unsigned long riva_get_memlen(struct riva_par *par)
         case NV_ARCH_30:
                 if(chipset == NV_CHIP_IGEFORCE2) {
 
-                        dev = pci_find_slot(0, 1);
+                        dev = pci_get_bus_and_slot(0, 1);
                         pci_read_config_dword(dev, 0x7C, &amt);
+                        pci_dev_put(dev);
                         memlen = (((amt >> 6) & 31) + 1) * 1024;
                 } else if (chipset == NV_CHIP_0x01F0) {
-                        dev = pci_find_slot(0, 1);
+                        dev = pci_get_bus_and_slot(0, 1);
                         pci_read_config_dword(dev, 0x84, &amt);
+                        pci_dev_put(dev);
                         memlen = (((amt >> 4) & 127) + 1) * 1024;
                 } else {
                         switch ((NV_RD32(chip->PFB, 0x0000020C) >> 20) &
diff --git a/drivers/video/riva/riva_hw.c b/drivers/video/riva/riva_hw.c
index e0b8c521cc9c..70bfd78eca81 100644
--- a/drivers/video/riva/riva_hw.c
+++ b/drivers/video/riva/riva_hw.c
@@ -1118,8 +1118,9 @@ static void nForceUpdateArbitrationSettings
     unsigned int uMClkPostDiv;
     struct pci_dev *dev;
 
-    dev = pci_find_slot(0, 3);
+    dev = pci_get_bus_and_slot(0, 3);
     pci_read_config_dword(dev, 0x6C, &uMClkPostDiv);
+    pci_dev_put(dev);
     uMClkPostDiv = (uMClkPostDiv >> 8) & 0xf;
 
     if(!uMClkPostDiv) uMClkPostDiv = 4;
@@ -1132,8 +1133,9 @@ static void nForceUpdateArbitrationSettings
     sim_data.enable_video   = 0;
     sim_data.enable_mp      = 0;
 
-    dev = pci_find_slot(0, 1);
+    dev = pci_get_bus_and_slot(0, 1);
     pci_read_config_dword(dev, 0x7C, &sim_data.memory_type);
+    pci_dev_put(dev);
     sim_data.memory_type    = (sim_data.memory_type >> 12) & 1;
 
     sim_data.memory_width   = 64;
@@ -2112,12 +2114,14 @@ static void nv10GetConfig
      * Fill in chip configuration.
      */
     if(chipset == NV_CHIP_IGEFORCE2) {
-        dev = pci_find_slot(0, 1);
+        dev = pci_get_bus_and_slot(0, 1);
         pci_read_config_dword(dev, 0x7C, &amt);
+        pci_dev_put(dev);
         chip->RamAmountKBytes = (((amt >> 6) & 31) + 1) * 1024;
     } else if(chipset == NV_CHIP_0x01F0) {
-        dev = pci_find_slot(0, 1);
+        dev = pci_get_bus_and_slot(0, 1);
         pci_read_config_dword(dev, 0x84, &amt);
+        pci_dev_put(dev);
         chip->RamAmountKBytes = (((amt >> 4) & 127) + 1) * 1024;
     } else {
         switch ((NV_RD32(chip->PFB, 0x0000020C) >> 20) & 0x000000FF)
diff --git a/drivers/video/riva/rivafb-i2c.c b/drivers/video/riva/rivafb-i2c.c
index 0405e839ff93..76e6ce353c8e 100644
--- a/drivers/video/riva/rivafb-i2c.c
+++ b/drivers/video/riva/rivafb-i2c.c
@@ -88,13 +88,16 @@ static int riva_gpio_getsda(void* data)
         return val;
 }
 
-static int riva_setup_i2c_bus(struct riva_i2c_chan *chan, const char *name)
+static int __devinit riva_setup_i2c_bus(struct riva_i2c_chan *chan,
+                                        const char *name,
+                                        unsigned int i2c_class)
 {
         int rc;
 
         strcpy(chan->adapter.name, name);
         chan->adapter.owner             = THIS_MODULE;
         chan->adapter.id                = I2C_HW_B_RIVA;
+        chan->adapter.class             = i2c_class;
         chan->adapter.algo_data         = &chan->algo;
         chan->adapter.dev.parent        = &chan->par->pdev->dev;
         chan->algo.setsda               = riva_gpio_setsda;
@@ -124,42 +127,38 @@ static int riva_setup_i2c_bus(struct riva_i2c_chan *chan, const char *name)
         return rc;
 }
 
-void riva_create_i2c_busses(struct riva_par *par)
+void __devinit riva_create_i2c_busses(struct riva_par *par)
 {
-        par->bus = 3;
-
         par->chan[0].par        = par;
         par->chan[1].par        = par;
         par->chan[2].par        = par;
 
-        par->chan[0].ddc_base = 0x3e;
-        par->chan[1].ddc_base = 0x36;
+        par->chan[0].ddc_base = 0x36;
+        par->chan[1].ddc_base = 0x3e;
         par->chan[2].ddc_base = 0x50;
-        riva_setup_i2c_bus(&par->chan[0], "BUS1");
-        riva_setup_i2c_bus(&par->chan[1], "BUS2");
-        riva_setup_i2c_bus(&par->chan[2], "BUS3");
+        riva_setup_i2c_bus(&par->chan[0], "BUS1", I2C_CLASS_HWMON);
+        riva_setup_i2c_bus(&par->chan[1], "BUS2", 0);
+        riva_setup_i2c_bus(&par->chan[2], "BUS3", 0);
 }
 
 void riva_delete_i2c_busses(struct riva_par *par)
 {
-        if (par->chan[0].par)
-                i2c_del_adapter(&par->chan[0].adapter);
-        par->chan[0].par = NULL;
-
-        if (par->chan[1].par)
-                i2c_del_adapter(&par->chan[1].adapter);
-        par->chan[1].par = NULL;
+        int i;
 
-        if (par->chan[2].par)
-                i2c_del_adapter(&par->chan[2].adapter);
-        par->chan[2].par = NULL;
+        for (i = 0; i < 3; i++) {
+                if (!par->chan[i].par)
+                        continue;
+                i2c_del_adapter(&par->chan[i].adapter);
+                par->chan[i].par = NULL;
+        }
 }
 
-int riva_probe_i2c_connector(struct riva_par *par, int conn, u8 **out_edid)
+int __devinit riva_probe_i2c_connector(struct riva_par *par, int conn, u8 **out_edid)
 {
         u8 *edid = NULL;
 
-        edid = fb_ddc_read(&par->chan[conn-1].adapter);
+        if (par->chan[conn].par)
+                edid = fb_ddc_read(&par->chan[conn].adapter);
 
         if (out_edid)
                 *out_edid = edid;
diff --git a/drivers/video/riva/rivafb.h b/drivers/video/riva/rivafb.h
index 48ead6d72f24..d9f107b704c6 100644
--- a/drivers/video/riva/rivafb.h
+++ b/drivers/video/riva/rivafb.h
@@ -4,7 +4,6 @@
 #include <linux/fb.h>
 #include <video/vga.h>
 #include <linux/i2c.h>
-#include <linux/i2c-id.h>
 #include <linux/i2c-algo-bit.h>
 
 #include "riva_hw.h"
@@ -61,7 +60,6 @@ struct riva_par {
         Bool SecondCRTC;
         int FlatPanel;
         struct pci_dev *pdev;
-        int bus;
         int cursor_reset;
 #ifdef CONFIG_MTRR
         struct { int vram; int vram_valid; } mtrr;
diff --git a/drivers/video/s3fb.c b/drivers/video/s3fb.c
index 3091b20124b4..756fafb41d78 100644
--- a/drivers/video/s3fb.c
+++ b/drivers/video/s3fb.c
@@ -65,7 +65,7 @@ static const struct svga_fb_format s3fb_formats[] = {
 
 
 static const struct svga_pll s3_pll = {3, 129, 3, 33, 0, 3,
-        60000, 240000, 14318};
+        35000, 240000, 14318};
 
 static const int s3_memsizes[] = {4096, 0, 3072, 8192, 2048, 6144, 1024, 512};
 
@@ -164,7 +164,7 @@ MODULE_PARM_DESC(fasttext, "Enable S3 fast text mode (1=enable, 0=disable, defau
 static void s3fb_settile_fast(struct fb_info *info, struct fb_tilemap *map)
 {
         const u8 *font = map->data;
-        u8* fb = (u8 *) info->screen_base;
+        u8 __iomem *fb = (u8 __iomem *) info->screen_base;
         int i, c;
 
         if ((map->width != 8) || (map->height != 16) ||
@@ -177,20 +177,19 @@ static void s3fb_settile_fast(struct fb_info *info, struct fb_tilemap *map)
         fb += 2;
         for (i = 0; i < map->height; i++) {
                 for (c = 0; c < map->length; c++) {
-                        fb[c * 4] = font[c * map->height + i];
+                        fb_writeb(font[c * map->height + i], fb + c * 4);
                 }
                 fb += 1024;
         }
 }
 
-
-
 static struct fb_tile_ops s3fb_tile_ops = {
         .fb_settile     = svga_settile,
         .fb_tilecopy    = svga_tilecopy,
         .fb_tilefill    = svga_tilefill,
         .fb_tileblit    = svga_tileblit,
         .fb_tilecursor  = svga_tilecursor,
+        .fb_get_tilemax = svga_get_tilemax,
 };
 
 static struct fb_tile_ops s3fb_fast_tile_ops = {
@@ -199,6 +198,7 @@ static struct fb_tile_ops s3fb_fast_tile_ops = {
         .fb_tilefill    = svga_tilefill,
         .fb_tileblit    = svga_tileblit,
         .fb_tilecursor  = svga_tilecursor,
+        .fb_get_tilemax = svga_get_tilemax,
 };
 
 
@@ -326,8 +326,13 @@ static void s3_set_pixclock(struct fb_info *info, u32 pixclock)
 {
         u16 m, n, r;
         u8 regval;
+        int rv;
 
-        svga_compute_pll(&s3_pll, 1000000000 / pixclock, &m, &n, &r, info->node);
+        rv = svga_compute_pll(&s3_pll, 1000000000 / pixclock, &m, &n, &r, info->node);
+        if (rv < 0) {
+                printk(KERN_ERR "fb%d: cannot set requested pixclock, keeping old value\n", info->node);
+                return;
+        }
 
         /* Set VGA misc register  */
         regval = vga_r(NULL, VGA_MIS_R);
@@ -449,6 +454,10 @@ static int s3fb_set_par(struct fb_info *info)
                 info->flags &= ~FBINFO_MISC_TILEBLITTING;
                 info->tileops = NULL;
 
+                /* in 4bpp supports 8p wide tiles only, any tiles otherwise */
+                info->pixmap.blit_x = (bpp == 4) ? (1 << (8 - 1)) : (~(u32)0);
+                info->pixmap.blit_y = ~(u32)0;
+
                 offset_value = (info->var.xres_virtual * bpp) / 64;
                 screen_size = info->var.yres_virtual * info->fix.line_length;
         } else {
@@ -458,6 +467,10 @@ static int s3fb_set_par(struct fb_info *info)
                 info->flags |= FBINFO_MISC_TILEBLITTING;
                 info->tileops = fasttext ? &s3fb_fast_tile_ops : &s3fb_tile_ops;
 
+                /* supports 8x16 tiles only */
+                info->pixmap.blit_x = 1 << (8 - 1);
+                info->pixmap.blit_y = 1 << (16 - 1);
+
                 offset_value = info->var.xres_virtual / 16;
                 screen_size = (info->var.xres_virtual * info->var.yres_virtual) / 64;
         }
@@ -656,7 +669,7 @@ static int s3fb_set_par(struct fb_info *info)
         value = ((value * hmul) / 8) - 5;
         vga_wcrt(NULL, 0x3C, (value + 1) / 2);
 
-        memset((u8*)info->screen_base, 0x00, screen_size);
+        memset_io(info->screen_base, 0x00, screen_size);
         /* Device and screen back on */
         svga_wcrt_mask(0x17, 0x80, 0x80);
         svga_wseq_mask(0x01, 0x00, 0x20);
@@ -699,7 +712,7 @@ static int s3fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
                 break;
         case 16:
                 if (regno >= 16)
-                        return -EINVAL;
+                        return 0;
 
                 if (fb->var.green.length == 5)
                         ((u32*)fb->pseudo_palette)[regno] = ((red & 0xF800) >> 1) |
@@ -712,9 +725,9 @@ static int s3fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
         case 24:
         case 32:
                 if (regno >= 16)
-                        return -EINVAL;
+                        return 0;
 
-                ((u32*)fb->pseudo_palette)[regno] = ((transp & 0xFF00) << 16) | ((red & 0xFF00) << 8) |
+                ((u32*)fb->pseudo_palette)[regno] = ((red & 0xFF00) << 8) |
                         (green & 0xFF00) | ((blue & 0xFF00) >> 8);
                 break;
         default:
@@ -767,12 +780,6 @@ static int s3fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
 
         unsigned int offset;
 
-        /* Validate the offsets */
-        if ((var->xoffset + var->xres) > var->xres_virtual)
-                return -EINVAL;
-        if ((var->yoffset + var->yres) > var->yres_virtual)
-                return -EINVAL;
-
         /* Calculate the offset */
         if (var->bits_per_pixel == 0) {
                 offset = (var->yoffset / 16) * (var->xres_virtual / 2) + (var->xoffset / 2);
@@ -789,6 +796,23 @@ static int s3fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
         return 0;
 }
 
+/* Get capabilities of accelerator based on the mode */
+
+static void s3fb_get_caps(struct fb_info *info, struct fb_blit_caps *caps,
+                          struct fb_var_screeninfo *var)
+{
+        if (var->bits_per_pixel == 0) {
+                /* can only support 256 8x16 bitmap */
+                caps->x = 1 << (8 - 1);
+                caps->y = 1 << (16 - 1);
+                caps->len = 256;
+        } else {
+                caps->x = ~(u32)0;
+                caps->y = ~(u32)0;
+                caps->len = ~(u32)0;
+        }
+}
+
 /* ------------------------------------------------------------------------- */
 
 /* Frame buffer operations */
@@ -805,6 +829,7 @@ static struct fb_ops s3fb_ops = {
         .fb_fillrect    = s3fb_fillrect,
         .fb_copyarea    = cfb_copyarea,
         .fb_imageblit   = s3fb_imageblit,
+        .fb_get_caps    = s3fb_get_caps,
 };
 
 /* ------------------------------------------------------------------------- */
@@ -1061,6 +1086,7 @@ static int s3_pci_resume(struct pci_dev* dev)
 {
         struct fb_info *info = pci_get_drvdata(dev);
         struct s3fb_info *par = info->par;
+        int err;
 
         dev_info(&(dev->dev), "resume\n");
 
@@ -1075,7 +1101,13 @@ static int s3_pci_resume(struct pci_dev* dev)
 
         pci_set_power_state(dev, PCI_D0);
         pci_restore_state(dev);
-        pci_enable_device(dev);
+        err = pci_enable_device(dev);
+        if (err) {
+                mutex_unlock(&(par->open_lock));
+                release_console_sem();
+                dev_err(&(dev->dev), "error %d enabling device for resume\n", err);
+                return err;
+        }
         pci_set_master(dev);
 
         s3fb_set_par(info);
diff --git a/drivers/video/savage/savagefb-i2c.c b/drivers/video/savage/savagefb-i2c.c
index 8db066ccca6b..35c1ce62b216 100644
--- a/drivers/video/savage/savagefb-i2c.c
+++ b/drivers/video/savage/savagefb-i2c.c
@@ -41,10 +41,6 @@
 #define SAVAGE4_I2C_SCL_IN      0x00000008
 #define SAVAGE4_I2C_SDA_IN      0x00000010
 
-#define SET_CR_IX(base, val)    writeb((val), base + 0x8000 + VGA_CR_IX)
-#define SET_CR_DATA(base, val)  writeb((val), base + 0x8000 + VGA_CR_DATA)
-#define GET_CR_DATA(base)       readb(base + 0x8000 + VGA_CR_DATA)
-
 static void savage4_gpio_setscl(void *data, int val)
 {
         struct savagefb_i2c_chan *chan = data;
@@ -92,15 +88,15 @@ static void prosavage_gpio_setscl(void* data, int val)
         struct savagefb_i2c_chan *chan = data;
         u32                       r;
 
-        SET_CR_IX(chan->ioaddr, chan->reg);
-        r = GET_CR_DATA(chan->ioaddr);
+        r = VGArCR(chan->reg, chan->par);
         r |= PROSAVAGE_I2C_ENAB;
         if (val) {
                 r |= PROSAVAGE_I2C_SCL_OUT;
         } else {
                 r &= ~PROSAVAGE_I2C_SCL_OUT;
         }
-        SET_CR_DATA(chan->ioaddr, r);
+
+        VGAwCR(chan->reg, r, chan->par);
 }
 
 static void prosavage_gpio_setsda(void* data, int val)
@@ -108,31 +104,29 @@ static void prosavage_gpio_setsda(void* data, int val)
         struct savagefb_i2c_chan *chan = data;
         unsigned int r;
 
-        SET_CR_IX(chan->ioaddr, chan->reg);
-        r = GET_CR_DATA(chan->ioaddr);
+        r = VGArCR(chan->reg, chan->par);
         r |= PROSAVAGE_I2C_ENAB;
         if (val) {
                 r |= PROSAVAGE_I2C_SDA_OUT;
         } else {
                 r &= ~PROSAVAGE_I2C_SDA_OUT;
         }
-        SET_CR_DATA(chan->ioaddr, r);
+
+        VGAwCR(chan->reg, r, chan->par);
 }
 
 static int prosavage_gpio_getscl(void* data)
 {
         struct savagefb_i2c_chan *chan = data;
 
-        SET_CR_IX(chan->ioaddr, chan->reg);
-        return (0 != (GET_CR_DATA(chan->ioaddr) & PROSAVAGE_I2C_SCL_IN));
+        return (VGArCR(chan->reg, chan->par) & PROSAVAGE_I2C_SCL_IN) ? 1 : 0;
 }
 
 static int prosavage_gpio_getsda(void* data)
 {
         struct savagefb_i2c_chan *chan = data;
 
-        SET_CR_IX(chan->ioaddr, chan->reg);
-        return (0 != (GET_CR_DATA(chan->ioaddr) & PROSAVAGE_I2C_SDA_IN));
+        return (VGArCR(chan->reg, chan->par) & PROSAVAGE_I2C_SDA_IN) ? 1 : 0;
 }
 
 static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
diff --git a/drivers/video/savage/savagefb.h b/drivers/video/savage/savagefb.h
index e648a6c0f6d9..8bfdfc3c5234 100644
--- a/drivers/video/savage/savagefb.h
+++ b/drivers/video/savage/savagefb.h
@@ -15,6 +15,8 @@
 #include <linux/i2c.h>
 #include <linux/i2c-id.h>
 #include <linux/i2c-algo-bit.h>
+#include <linux/mutex.h>
+#include <video/vga.h>
 #include "../edid.h"
 
 #ifdef SAVAGEFB_DEBUG
@@ -189,8 +191,12 @@ struct savagefb_par {
         struct savagefb_i2c_chan chan;
         struct savage_reg state;
         struct savage_reg save;
+        struct savage_reg initial;
+        struct vgastate vgastate;
+        struct mutex open_lock;
         unsigned char   *edid;
         u32 pseudo_palette[16];
+        u32 open_count;
         int paletteEnabled;
         int pm_state;
         int display_type;
@@ -203,7 +209,7 @@ struct savagefb_par {
         int clock[4];
         int MCLK, REFCLK, LCDclk;
         struct {
-                u8   __iomem *vbase;
+                void   __iomem *vbase;
                 u32    pbase;
                 u32    len;
 #ifdef CONFIG_MTRR
@@ -212,7 +218,7 @@ struct savagefb_par {
         } video;
 
         struct {
-                volatile u8  __iomem *vbase;
+                void  __iomem *vbase;
                 u32           pbase;
                 u32           len;
         } mmio;
diff --git a/drivers/video/savage/savagefb_driver.c b/drivers/video/savage/savagefb_driver.c
index 0166ec2ccf32..3d7507ad55f6 100644
--- a/drivers/video/savage/savagefb_driver.c
+++ b/drivers/video/savage/savagefb_driver.c
@@ -1623,8 +1623,46 @@ static void savagefb_restore_state(struct fb_info *info)
         savagefb_blank(FB_BLANK_UNBLANK, info);
 }
 
+static int savagefb_open(struct fb_info *info, int user)
+{
+        struct savagefb_par *par = info->par;
+
+        mutex_lock(&par->open_lock);
+
+        if (!par->open_count) {
+                memset(&par->vgastate, 0, sizeof(par->vgastate));
+                par->vgastate.flags = VGA_SAVE_CMAP | VGA_SAVE_FONTS |
+                        VGA_SAVE_MODE;
+                par->vgastate.vgabase = par->mmio.vbase + 0x8000;
+                save_vga(&par->vgastate);
+                savage_get_default_par(par, &par->initial);
+        }
+
+        par->open_count++;
+        mutex_unlock(&par->open_lock);
+        return 0;
+}
+
+static int savagefb_release(struct fb_info *info, int user)
+{
+        struct savagefb_par *par = info->par;
+
+        mutex_lock(&par->open_lock);
+
+        if (par->open_count == 1) {
+                savage_set_default_par(par, &par->initial);
+                restore_vga(&par->vgastate);
+        }
+
+        par->open_count--;
+        mutex_unlock(&par->open_lock);
+        return 0;
+}
+
 static struct fb_ops savagefb_ops = {
         .owner          = THIS_MODULE,
+        .fb_open        = savagefb_open,
+        .fb_release     = savagefb_release,
         .fb_check_var   = savagefb_check_var,
         .fb_set_par     = savagefb_set_par,
         .fb_setcolreg   = savagefb_setcolreg,
@@ -2173,6 +2211,7 @@ static int __devinit savagefb_probe(struct pci_dev* dev,
         if (!info)
                 return -ENOMEM;
         par = info->par;
+        mutex_init(&par->open_lock);
         err = pci_enable_device(dev);
         if (err)
                 goto failed_enable;
diff --git a/drivers/video/sis/osdef.h b/drivers/video/sis/osdef.h
index d048bd39961b..c1492782cb18 100644
--- a/drivers/video/sis/osdef.h
+++ b/drivers/video/sis/osdef.h
@@ -58,9 +58,6 @@
 #define SIS_LINUX_KERNEL                /* Linux kernel framebuffer */
 #undef  SIS_XORG_XF86                   /* XFree86/X.org */
 
-#undef SIS_LINUX_KERNEL_24
-#undef SIS_LINUX_KERNEL_26
-
 #ifdef OutPortByte
 #undef OutPortByte
 #endif
@@ -100,8 +97,6 @@
 #define SIS315H
 #endif
 
-#define SIS_LINUX_KERNEL_26
-
 #if !defined(SIS300) && !defined(SIS315H)
 #warning Neither CONFIG_FB_SIS_300 nor CONFIG_FB_SIS_315 is set
 #warning sisfb will not work!
diff --git a/drivers/video/sis/sis.h b/drivers/video/sis/sis.h
index 7d5ee2145e21..d5e2d9c27847 100644
--- a/drivers/video/sis/sis.h
+++ b/drivers/video/sis/sis.h
@@ -27,11 +27,7 @@
 #include <linux/version.h>
 
 #include "osdef.h"
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
 #include <video/sisfb.h>
-#else
-#include <linux/sisfb.h>
-#endif
 
 #include "vgatypes.h"
 #include "vstruct.h"
@@ -40,33 +36,17 @@
 #define VER_MINOR               8
 #define VER_LEVEL               9
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
 #include <linux/spinlock.h>
-#define SIS_PCI_GET_CLASS(a, b) pci_get_class(a, b)
-#define SIS_PCI_GET_DEVICE(a,b,c) pci_get_device(a,b,c)
-#define SIS_PCI_GET_SLOT(a,b) pci_get_slot(a,b)
-#define SIS_PCI_PUT_DEVICE(a) pci_dev_put(a)
+
 #ifdef CONFIG_COMPAT
 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,10)
 #include <linux/ioctl32.h>
 #define SIS_OLD_CONFIG_COMPAT
 #else
-#include <linux/smp_lock.h>
 #define SIS_NEW_CONFIG_COMPAT
 #endif
 #endif  /* CONFIG_COMPAT */
-#else  /* 2.4 */
-#define SIS_PCI_GET_CLASS(a, b) pci_find_class(a, b)
-#define SIS_PCI_GET_DEVICE(a,b,c) pci_find_device(a,b,c)
-#define SIS_PCI_GET_SLOT(a,b) pci_find_slot(a,b)
-#define SIS_PCI_PUT_DEVICE(a)
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,19)
-#ifdef __x86_64__       /* Shouldn't we check for CONFIG_IA32_EMULATION here? */
-#include <asm/ioctl32.h>
-#define SIS_OLD_CONFIG_COMPAT
-#endif
-#endif
-#endif /* 2.4 */
+
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
 #define SIS_IOTYPE1 void __iomem
 #define SIS_IOTYPE2 __iomem
@@ -498,26 +478,8 @@ struct sis_video_info {
 
         struct fb_var_screeninfo default_var;
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
         struct fb_fix_screeninfo sisfb_fix;
         u32             pseudo_palette[17];
-#endif
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
-        struct display           sis_disp;
-        struct display_switch    sisfb_sw;
-        struct {
-                u16 red, green, blue, pad;
-        }               sis_palette[256];
-        union {
-#ifdef FBCON_HAS_CFB16
-                u16 cfb16[16];
-#endif
-#ifdef FBCON_HAS_CFB32
-                u32 cfb32[16];
-#endif
-        }               sis_fbcon_cmap;
-#endif
 
         struct sisfb_monitor {
                 u16 hmin;
@@ -538,10 +500,6 @@ struct sis_video_info {
 
         int             mni;    /* Mode number index */
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
-        int             currcon;
-#endif
-
         unsigned long   video_size;
         unsigned long   video_base;
         unsigned long   mmio_size;
@@ -578,9 +536,6 @@ struct sis_video_info {
         int             sisfb_tvplug;
         int             sisfb_tvstd;
         int             sisfb_nocrt2rate;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
-        int             sisfb_inverse;
-#endif
 
         u32             heapstart;              /* offset  */
         SIS_IOTYPE1     *sisfb_heap_start;      /* address */
@@ -646,9 +601,7 @@ struct sis_video_info {
         int             modechanged;
         unsigned char   modeprechange;
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
         u8              sisfb_lastrates[128];
-#endif
 
         int             newrom;
         int             haveXGIROM;
diff --git a/drivers/video/sis/sis_main.c b/drivers/video/sis/sis_main.c
index 01197d740217..a30e1e13d8be 100644
--- a/drivers/video/sis/sis_main.c
+++ b/drivers/video/sis/sis_main.c
@@ -37,7 +37,6 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/kernel.h>
-#include <linux/smp_lock.h>
 #include <linux/spinlock.h>
 #include <linux/errno.h>
 #include <linux/string.h>
@@ -1948,7 +1947,7 @@ sisfb_get_northbridge(int basechipid)
         default:        return NULL;
         }
         for(i = 0; i < nbridgenum; i++) {
-                if((pdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI,
+                if((pdev = pci_get_device(PCI_VENDOR_ID_SI,
                                 nbridgeids[nbridgeidx+i], NULL)))
                         break;
         }
@@ -4613,9 +4612,9 @@ sisfb_find_host_bridge(struct sis_video_info *ivideo, struct pci_dev *mypdev,
         unsigned short temp;
         int ret = 0;
 
-        while((pdev = SIS_PCI_GET_CLASS(PCI_CLASS_BRIDGE_HOST, pdev))) {
+        while((pdev = pci_get_class(PCI_CLASS_BRIDGE_HOST, pdev))) {
                 temp = pdev->vendor;
-                SIS_PCI_PUT_DEVICE(pdev);
+                pci_dev_put(pdev);
                 if(temp == pcivendor) {
                         ret = 1;
                         break;
@@ -5154,24 +5153,24 @@ sisfb_post_xgi(struct pci_dev *pdev)
                         if(reg & 0x80) v2 |= 0x80;
                         v2 |= 0x01;
 
-                        if((mypdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0730, NULL))) {
-                                SIS_PCI_PUT_DEVICE(mypdev);
+                        if((mypdev = pci_get_device(PCI_VENDOR_ID_SI, 0x0730, NULL))) {
+                                pci_dev_put(mypdev);
                                 if(((v2 & 0x06) == 2) || ((v2 & 0x06) == 4))
                                         v2 &= 0xf9;
                                 v2 |= 0x08;
                                 v1 &= 0xfe;
                         } else {
-                                mypdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0735, NULL);
+                                mypdev = pci_get_device(PCI_VENDOR_ID_SI, 0x0735, NULL);
                                 if(!mypdev)
-                                        mypdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0645, NULL);
+                                        mypdev = pci_get_device(PCI_VENDOR_ID_SI, 0x0645, NULL);
                                 if(!mypdev)
-                                        mypdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0650, NULL);
+                                        mypdev = pci_get_device(PCI_VENDOR_ID_SI, 0x0650, NULL);
                                 if(mypdev) {
                                         pci_read_config_dword(mypdev, 0x94, &regd);
                                         regd &= 0xfffffeff;
                                         pci_write_config_dword(mypdev, 0x94, regd);
                                         v1 &= 0xfe;
-                                        SIS_PCI_PUT_DEVICE(mypdev);
+                                        pci_dev_put(mypdev);
                                 } else if(sisfb_find_host_bridge(ivideo, pdev, PCI_VENDOR_ID_SI)) {
                                         v1 &= 0xfe;
                                 } else if(sisfb_find_host_bridge(ivideo, pdev, 0x1106) ||
@@ -5194,13 +5193,13 @@ sisfb_post_xgi(struct pci_dev *pdev)
                         if( (!(v1 & 0x02)) && (v2 & 0x30) && (regd < 0xcf) )
                                 setSISIDXREG(SISCR, 0x5f, 0xf1, 0x01);
 
-                        if((mypdev = SIS_PCI_GET_DEVICE(0x10de, 0x01e0, NULL))) {
+                        if((mypdev = pci_get_device(0x10de, 0x01e0, NULL))) {
                                 /* TODO: set CR5f &0xf1 | 0x01 for version 6570
                                  * of nforce 2 ROM
                                  */
                                 if(0)
                                         setSISIDXREG(SISCR, 0x5f, 0xf1, 0x01);
-                                SIS_PCI_PUT_DEVICE(mypdev);
+                                pci_dev_put(mypdev);
                         }
                 }
 
@@ -5236,9 +5235,9 @@ sisfb_post_xgi(struct pci_dev *pdev)
                 setSISIDXREG(SISCR, 0x75, 0xe0, bios[0x4ff] & 0x1f);
                 setSISIDXREG(SISCR, 0x76, 0xe0, bios[0x500] & 0x1f);
                 v1 = bios[0x501];
-                if((mypdev = SIS_PCI_GET_DEVICE(0x8086, 0x2530, NULL))) {
+                if((mypdev = pci_get_device(0x8086, 0x2530, NULL))) {
                         v1 = 0xf0;
-                        SIS_PCI_PUT_DEVICE(mypdev);
+                        pci_dev_put(mypdev);
                 }
                 outSISIDXREG(SISCR, 0x77, v1);
         }
@@ -5947,7 +5946,7 @@ sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         if(!ivideo->sisvga_enabled) {
                 if(pci_enable_device(pdev)) {
-                        if(ivideo->nbridge) SIS_PCI_PUT_DEVICE(ivideo->nbridge);
+                        if(ivideo->nbridge) pci_dev_put(ivideo->nbridge);
                         pci_set_drvdata(pdev, NULL);
                         kfree(sis_fb_info);
                         return -EIO;
@@ -5974,7 +5973,7 @@ sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                                         "requiring Chrontel/GPIO setup\n",
                                         mychswtable[i].vendorName,
                                         mychswtable[i].cardName);
-                                ivideo->lpcdev = SIS_PCI_GET_DEVICE(PCI_VENDOR_ID_SI, 0x0008, NULL);
+                                ivideo->lpcdev = pci_get_device(PCI_VENDOR_ID_SI, 0x0008, NULL);
                                 break;
                         }
                         i++;
@@ -5984,7 +5983,7 @@ sisfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
 #ifdef CONFIG_FB_SIS_315
         if((ivideo->chip == SIS_760) && (ivideo->nbridge)) {
-                ivideo->lpcdev = SIS_PCI_GET_SLOT(ivideo->nbridge->bus, (2 << 3));
+                ivideo->lpcdev = pci_get_slot(ivideo->nbridge->bus, (2 << 3));
         }
 #endif
 
@@ -6149,9 +6148,9 @@ error_1:	release_mem_region(ivideo->video_base, ivideo->video_size);
 error_2:        release_mem_region(ivideo->mmio_base, ivideo->mmio_size);
 error_3:        vfree(ivideo->bios_abase);
                 if(ivideo->lpcdev)
-                        SIS_PCI_PUT_DEVICE(ivideo->lpcdev);
+                        pci_dev_put(ivideo->lpcdev);
                 if(ivideo->nbridge)
-                        SIS_PCI_PUT_DEVICE(ivideo->nbridge);
+                        pci_dev_put(ivideo->nbridge);
                 pci_set_drvdata(pdev, NULL);
                 if(!ivideo->sisvga_enabled)
                         pci_disable_device(pdev);
@@ -6331,70 +6330,6 @@ error_3:	vfree(ivideo->bios_abase);
 
                 sisfb_set_vparms(ivideo);
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
-
-                /* ---------------- For 2.4: Now switch the mode ------------------ */
-
-                printk(KERN_INFO "sisfb: Setting mode %dx%dx%d (%dHz)\n",
-                        ivideo->video_width, ivideo->video_height, ivideo->video_bpp,
-                        ivideo->refresh_rate);
-
-                /* Determine whether or not acceleration is to be
-                 * used. Need to know before pre/post_set_mode()
-                 */
-                ivideo->accel = 0;
-                ivideo->default_var.accel_flags &= ~FB_ACCELF_TEXT;
-                if(ivideo->sisfb_accel) {
-                        ivideo->accel = -1;
-                        ivideo->default_var.accel_flags |= FB_ACCELF_TEXT;
-                }
-
-                /* Now switch the mode */
-                sisfb_pre_setmode(ivideo);
-
-                if(SiSSetMode(&ivideo->SiS_Pr, ivideo->mode_no) == 0) {
-                        printk(KERN_ERR "sisfb: Fatal error: Setting mode[0x%x] failed\n",
-                                                                        ivideo->mode_no);
-                        ret = -EINVAL;
-                        iounmap(ivideo->mmio_vbase);
-                        goto error_0;
-                }
-
-                outSISIDXREG(SISSR, IND_SIS_PASSWORD, SIS_PASSWORD);
-
-                sisfb_post_setmode(ivideo);
-
-                /* Maximize regardless of sisfb_max at startup */
-                ivideo->default_var.yres_virtual = 32767;
-
-                /* Force reset of x virtual in crtc_to_var */
-                ivideo->default_var.xres_virtual = 0;
-
-                /* Copy mode timing to var */
-                sisfb_crtc_to_var(ivideo, &ivideo->default_var);
-
-                /* Find out about screen pitch */
-                sisfb_calc_pitch(ivideo, &ivideo->default_var);
-                sisfb_set_pitch(ivideo);
-
-                /* Init the accelerator (does nothing currently) */
-                sisfb_initaccel(ivideo);
-
-                /* Init some fbinfo entries */
-                sis_fb_info->node  = -1;
-                sis_fb_info->flags = FBINFO_FLAG_DEFAULT;
-                sis_fb_info->fbops = &sisfb_ops;
-                sis_fb_info->disp  = &ivideo->sis_disp;
-                sis_fb_info->blank = &sisfb_blank;
-                sis_fb_info->switch_con = &sisfb_switch;
-                sis_fb_info->updatevar  = &sisfb_update_var;
-                sis_fb_info->changevar  = NULL;
-                strcpy(sis_fb_info->fontname, sisfb_fontname);
-
-                sisfb_set_disp(-1, &ivideo->default_var, sis_fb_info);
-
-#else           /* --------- For 2.6: Setup a somewhat sane default var ------------ */
-
                 printk(KERN_INFO "sisfb: Default mode is %dx%dx%d (%dHz)\n",
                         ivideo->video_width, ivideo->video_height, ivideo->video_bpp,
                         ivideo->refresh_rate);
@@ -6454,7 +6389,6 @@ error_3:	vfree(ivideo->bios_abase);
                 sis_fb_info->pseudo_palette = ivideo->pseudo_palette;
 
                 fb_alloc_cmap(&sis_fb_info->cmap, 256 , 0);
-#endif          /* 2.6 */
 
                 printk(KERN_DEBUG "sisfb: Initial vbflags 0x%x\n", (int)ivideo->vbflags);
 
@@ -6564,10 +6498,10 @@ static void __devexit sisfb_remove(struct pci_dev *pdev)
         vfree(ivideo->bios_abase);
 
         if(ivideo->lpcdev)
-                SIS_PCI_PUT_DEVICE(ivideo->lpcdev);
+                pci_dev_put(ivideo->lpcdev);
 
         if(ivideo->nbridge)
-                SIS_PCI_PUT_DEVICE(ivideo->nbridge);
+                pci_dev_put(ivideo->nbridge);
 
 #ifdef CONFIG_MTRR
         /* Release MTRR region */
diff --git a/drivers/video/skeletonfb.c b/drivers/video/skeletonfb.c
index bb96cb65fdaa..842b5cd054c6 100644
--- a/drivers/video/skeletonfb.c
+++ b/drivers/video/skeletonfb.c
@@ -51,6 +51,7 @@
 #include <linux/delay.h>
 #include <linux/fb.h>
 #include <linux/init.h>
+#include <linux/pci.h>
 
     /*
      *  This is just simple sample code.
@@ -60,6 +61,11 @@
      */
 
 /*
+ * Driver data
+ */
+static char *mode_option __devinitdata;
+
+/*
  *  If your driver supports multiple boards, you should make the  
  *  below data types arrays, or allocate them dynamically (using kmalloc()). 
  */ 
@@ -78,7 +84,7 @@ struct xxx_par;
  * if we don't use modedb. If we do use modedb see xxxfb_init how to use it
  * to get a fb_var_screeninfo. Otherwise define a default var as well. 
  */
-static struct fb_fix_screeninfo xxxfb_fix __initdata = {
+static struct fb_fix_screeninfo xxxfb_fix __devinitdata = {
         .id =           "FB's name", 
         .type =         FB_TYPE_PACKED_PIXELS,
         .visual =       FB_VISUAL_PSEUDOCOLOR,
@@ -142,7 +148,7 @@ int xxxfb_setup(char*);
  *
  *      Returns negative errno on error, or zero on success.
  */
-static int xxxfb_open(const struct fb_info *info, int user)
+static int xxxfb_open(struct fb_info *info, int user)
 {
     return 0;
 }
@@ -161,7 +167,7 @@ static int xxxfb_open(const struct fb_info *info, int user)
  *
  *      Returns negative errno on error, or zero on success.
  */
-static int xxxfb_release(const struct fb_info *info, int user)
+static int xxxfb_release(struct fb_info *info, int user)
 {
     return 0;
 }
@@ -278,7 +284,7 @@ static int xxxfb_set_par(struct fb_info *info)
  */
 static int xxxfb_setcolreg(unsigned regno, unsigned red, unsigned green,
                            unsigned blue, unsigned transp,
-                           const struct fb_info *info)
+                           struct fb_info *info)
 {
     if (regno >= 256)  /* no. of hw registers */
        return -EINVAL;
@@ -416,7 +422,7 @@ static int xxxfb_setcolreg(unsigned regno, unsigned red, unsigned green,
  *      Returns negative errno on error, or zero on success.
  */
 static int xxxfb_pan_display(struct fb_var_screeninfo *var,
-                             const struct fb_info *info)
+                             struct fb_info *info)
 {
     /*
      * If your hardware does not support panning, _do_ _not_ implement this
@@ -454,7 +460,7 @@ static int xxxfb_pan_display(struct fb_var_screeninfo *var,
  *      Return !0 for any modes that are unimplemented.
  *
  */
-static int xxxfb_blank(int blank_mode, const struct fb_info *info)
+static int xxxfb_blank(int blank_mode, struct fb_info *info)
 {
     /* ... */
     return 0;
@@ -483,7 +489,7 @@ static int xxxfb_blank(int blank_mode, const struct fb_info *info)
  *      depending on the rastering operation with the value of color which
  *      is in the current color depth format.
  */
-void xxfb_fillrect(struct fb_info *p, const struct fb_fillrect *region)
+void xxxfb_fillrect(struct fb_info *p, const struct fb_fillrect *region)
 {
 /*      Meaning of struct fb_fillrect
  *
@@ -623,19 +629,6 @@ void xxxfb_rotate(struct fb_info *info, int angle)
 }
 
 /**
- *      xxxfb_poll - NOT a required function. The purpose of this
- *                   function is to provide a way for some process
- *                   to wait until a specific hardware event occurs
- *                   for the framebuffer device.
- *                               
- *      @info: frame buffer structure that represents a single frame buffer
- *      @wait: poll table where we store process that await a event.     
- */
-void xxxfb_poll(struct fb_info *info, poll_table *wait)
-{
-}
-
-/**
  *      xxxfb_sync - NOT a required function. Normally the accel engine 
  *                   for a graphics card take a specific amount of time.
  *                   Often we have to wait for the accelerator to finish
@@ -647,21 +640,49 @@ void xxxfb_poll(struct fb_info *info, poll_table *wait)
  *      If the driver has implemented its own hardware-based drawing function,
  *      implementing this function is highly recommended.
  */
-void xxxfb_sync(struct fb_info *info)
+int xxxfb_sync(struct fb_info *info)
 {
+        return 0;
 }
 
     /*
+     *  Frame buffer operations
+     */
+
+static struct fb_ops xxxfb_ops = {
+        .owner          = THIS_MODULE,
+        .fb_open        = xxxfb_open,
+        .fb_read        = xxxfb_read,
+        .fb_write       = xxxfb_write,
+        .fb_release     = xxxfb_release,
+        .fb_check_var   = xxxfb_check_var,
+        .fb_set_par     = xxxfb_set_par,
+        .fb_setcolreg   = xxxfb_setcolreg,
+        .fb_blank       = xxxfb_blank,
+        .fb_pan_display = xxxfb_pan_display,
+        .fb_fillrect    = xxxfb_fillrect,       /* Needed !!! */
+        .fb_copyarea    = xxxfb_copyarea,       /* Needed !!! */
+        .fb_imageblit   = xxxfb_imageblit,      /* Needed !!! */
+        .fb_cursor      = xxxfb_cursor,         /* Optional !!! */
+        .fb_rotate      = xxxfb_rotate,
+        .fb_sync        = xxxfb_sync,
+        .fb_ioctl       = xxxfb_ioctl,
+        .fb_mmap        = xxxfb_mmap,
+};
+
+/* ------------------------------------------------------------------------- */
+
+    /*
      *  Initialization
      */
 
 /* static int __init xxfb_probe (struct device *device) -- for platform devs */
-static int __init xxxfb_probe(struct pci_dev *dev,
-                              const_struct pci_device_id *ent)
+static int __devinit xxxfb_probe(struct pci_dev *dev,
+                              const struct pci_device_id *ent)
 {
     struct fb_info *info;
     struct xxx_par *par;
-    struct device = &dev->dev; /* for pci drivers */
+    struct device* device = &dev->dev; /* for pci drivers */
     int cmap_len, retval;       
    
     /*
@@ -684,7 +705,7 @@ static int __init xxxfb_probe(struct pci_dev *dev,
     info->screen_base = framebuffer_virtual_memory;
     info->fbops = &xxxfb_ops;
     info->fix = xxxfb_fix; /* this will be the only time xxxfb_fix will be
-                            * used, so mark it as __initdata
+                            * used, so mark it as __devinitdata
                             */
     info->pseudo_palette = pseudo_palette; /* The pseudopalette is an
                                             * 16-member array
@@ -760,7 +781,7 @@ static int __init xxxfb_probe(struct pci_dev *dev,
      *
      * NOTE: This field is currently unused.
      */
-    info->pixmap.scan_align = 32
+    info->pixmap.scan_align = 32;
 /***************************** End optional stage ***************************/
 
     /*
@@ -770,13 +791,13 @@ static int __init xxxfb_probe(struct pci_dev *dev,
     if (!mode_option)
         mode_option = "640x480@60";             
 
-    retval = fb_find_mode(info->var, info, mode_option, NULL, 0, NULL, 8);
+    retval = fb_find_mode(&info->var, info, mode_option, NULL, 0, NULL, 8);
   
     if (!retval || retval == 4)
         return -EINVAL;                 
 
     /* This has to been done !!! */     
-    fb_alloc_cmap(info->cmap, cmap_len, 0);
+    fb_alloc_cmap(&info->cmap, cmap_len, 0);
         
     /* 
      * The following is done in the case of having hardware with a static 
@@ -811,34 +832,77 @@ static int __init xxxfb_probe(struct pci_dev *dev,
     /*
      *  Cleanup
      */
-/* static void __exit xxxfb_remove(struct device *device) */
-static void __exit xxxfb_remove(struct pci_dev *dev)
+/* static void __devexit xxxfb_remove(struct device *device) */
+static void __devexit xxxfb_remove(struct pci_dev *dev)
 {
-        struct fb_info *info = pci_get_drv_data(dev);
-        /* or dev_get_drv_data(device); */
+        struct fb_info *info = pci_get_drvdata(dev);
+        /* or dev_get_drvdata(device); */
 
         if (info) {
                 unregister_framebuffer(info);
-                fb_dealloc_cmap(&info.cmap);
+                fb_dealloc_cmap(&info->cmap);
                 /* ... */
                 framebuffer_release(info);
         }
+}
+
+#ifdef CONFIG_PCI
+#ifdef CONFIG_PM
+/**
+ *      xxxfb_suspend - Optional but recommended function. Suspend the device.
+ *      @dev: PCI device
+ *      @msg: the suspend event code.
+ *
+ *      See Documentation/power/devices.txt for more information
+ */
+static int xxxfb_suspend(struct pci_dev *dev, pm_message_t msg)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct xxxfb_par *par = info->par;
+
+        /* suspend here */
+        return 0;
+}
+
+/**
+ *      xxxfb_resume - Optional but recommended function. Resume the device.
+ *      @dev: PCI device
+ *
+ *      See Documentation/power/devices.txt for more information
+ */
+static int xxxfb_resume(struct pci_dev *dev)
+{
+        struct fb_info *info = pci_get_drvdata(dev);
+        struct xxxfb_par *par = info->par;
 
+        /* resume here */
         return 0;
 }
+#else
+#define xxxfb_suspend NULL
+#define xxxfb_resume NULL
+#endif /* CONFIG_PM */
+
+static struct pci_device_id xxxfb_id_table[] = {
+        { PCI_VENDOR_ID_XXX, PCI_DEVICE_ID_XXX,
+          PCI_ANY_ID, PCI_ANY_ID, PCI_BASE_CLASS_DISPLAY << 16,
+          PCI_CLASS_MASK, 0 },
+        { 0, }
+};
 
-#if CONFIG_PCI
 /* For PCI drivers */
 static struct pci_driver xxxfb_driver = {
         .name =         "xxxfb",
-        .id_table =     xxxfb_devices,
+        .id_table =     xxxfb_id_table,
         .probe =        xxxfb_probe,
         .remove =       __devexit_p(xxxfb_remove),
-        .suspend =      xxxfb_suspend, /* optional */
-        .resume =       xxxfb_resume,  /* optional */
+        .suspend =      xxxfb_suspend, /* optional but recommended */
+        .resume =       xxxfb_resume,  /* optional but recommended */
 };
 
-static int __init xxxfb_init(void)
+MODULE_DEVICE_TABLE(pci, xxxfb_id_table);
+
+int __init xxxfb_init(void)
 {
         /*
          *  For kernel boot options (in 'video=xxxfb:<options>' format)
@@ -858,16 +922,53 @@ static void __exit xxxfb_exit(void)
 {
         pci_unregister_driver(&xxxfb_driver);
 }
-#else
+#else /* non PCI, platform drivers */
 #include <linux/platform_device.h>
 /* for platform devices */
+
+#ifdef CONFIG_PM
+/**
+ *      xxxfb_suspend - Optional but recommended function. Suspend the device.
+ *      @dev: platform device
+ *      @msg: the suspend event code.
+ *
+ *      See Documentation/power/devices.txt for more information
+ */
+static int xxxfb_suspend(struct platform_device *dev, pm_message_t msg)
+{
+        struct fb_info *info = platform_get_drvdata(dev);
+        struct xxxfb_par *par = info->par;
+
+        /* suspend here */
+        return 0;
+}
+
+/**
+ *      xxxfb_resume - Optional but recommended function. Resume the device.
+ *      @dev: platform device
+ *
+ *      See Documentation/power/devices.txt for more information
+ */
+static int xxxfb_resume(struct platform_dev *dev)
+{
+        struct fb_info *info = platform_get_drvdata(dev);
+        struct xxxfb_par *par = info->par;
+
+        /* resume here */
+        return 0;
+}
+#else
+#define xxxfb_suspend NULL
+#define xxxfb_resume NULL
+#endif /* CONFIG_PM */
+
 static struct device_driver xxxfb_driver = {
         .name = "xxxfb",
         .bus  = &platform_bus_type,
         .probe = xxxfb_probe,
         .remove = xxxfb_remove,
-        .suspend = xxxfb_suspend, /* optional */
-        .resume = xxxfb_resume,   /* optional */
+        .suspend = xxxfb_suspend, /* optional but recommended */
+        .resume = xxxfb_resume,   /* optional but recommended */
 };
 
 static struct platform_device xxxfb_device = {
@@ -903,8 +1004,9 @@ static void __exit xxxfb_exit(void)
         platform_device_unregister(&xxxfb_device);
         driver_unregister(&xxxfb_driver);
 }
-#endif
+#endif /* CONFIG_PCI */
 
+#ifdef MODULE
     /*
      *  Setup
      */
@@ -917,34 +1019,7 @@ int __init xxxfb_setup(char *options)
 {
     /* Parse user speficied options (`video=xxxfb:') */
 }
-
-/* ------------------------------------------------------------------------- */
-
-    /*
-     *  Frame buffer operations
-     */
-
-static struct fb_ops xxxfb_ops = {
-        .owner          = THIS_MODULE,
-        .fb_open        = xxxfb_open,
-        .fb_read        = xxxfb_read,
-        .fb_write       = xxxfb_write,
-        .fb_release     = xxxfb_release,
-        .fb_check_var   = xxxfb_check_var,
-        .fb_set_par     = xxxfb_set_par,        
-        .fb_setcolreg   = xxxfb_setcolreg,
-        .fb_blank       = xxxfb_blank,
-        .fb_pan_display = xxxfb_pan_display,    
-        .fb_fillrect    = xxxfb_fillrect,       /* Needed !!! */ 
-        .fb_copyarea    = xxxfb_copyarea,       /* Needed !!! */ 
-        .fb_imageblit   = xxxfb_imageblit,      /* Needed !!! */
-        .fb_cursor      = xxxfb_cursor,         /* Optional !!! */
-        .fb_rotate      = xxxfb_rotate,
-        .fb_poll        = xxxfb_poll,
-        .fb_sync        = xxxfb_sync,
-        .fb_ioctl       = xxxfb_ioctl,
-        .fb_mmap        = xxxfb_mmap,   
-};
+#endif /* MODULE */
 
 /* ------------------------------------------------------------------------- */
 
@@ -954,6 +1029,6 @@ static struct fb_ops xxxfb_ops = {
      */
 
 module_init(xxxfb_init);
-module_exit(xxxfb_cleanup);
+module_exit(xxxfb_remove);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/video/sm501fb.c b/drivers/video/sm501fb.c
index 0a44c44672c8..c86df126f93a 100644
--- a/drivers/video/sm501fb.c
+++ b/drivers/video/sm501fb.c
@@ -989,7 +989,7 @@ static int sm501fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
                         ((info->cmap.green[fg_col] & 0xFC) << 3) |
                         ((info->cmap.blue[fg_col] & 0xF8) >> 3);
 
-                dev_dbg(fbi->dev, "fgcol %08x, bgcol %08x\n", fg, bg);
+                dev_dbg(fbi->dev, "fgcol %08lx, bgcol %08lx\n", fg, bg);
 
                 writel(bg, base + SM501_OFF_HWC_COLOR_1_2);
                 writel(fg, base + SM501_OFF_HWC_COLOR_3);
diff --git a/drivers/video/svgalib.c b/drivers/video/svgalib.c
index 68b30d9eac58..079cdc911e48 100644
--- a/drivers/video/svgalib.c
+++ b/drivers/video/svgalib.c
@@ -194,7 +194,7 @@ void svga_dump_var(struct fb_var_screeninfo *var, int node)
 void svga_settile(struct fb_info *info, struct fb_tilemap *map)
 {
         const u8 *font = map->data;
-        u8* fb = (u8 *) info->screen_base;
+        u8 __iomem *fb = (u8 __iomem *)info->screen_base;
         int i, c;
 
         if ((map->width != 8) || (map->height != 16) ||
@@ -207,7 +207,8 @@ void svga_settile(struct fb_info *info, struct fb_tilemap *map)
         fb += 2;
         for (c = 0; c < map->length; c++) {
                 for (i = 0; i < map->height; i++) {
-                        fb[i * 4] = font[i];
+                        fb_writeb(font[i], fb + i * 4);
+//                      fb[i * 4] = font[i];
                 }
                 fb += 128;
                 font += map->height;
@@ -221,8 +222,8 @@ void svga_tilecopy(struct fb_info *info, struct fb_tilearea *area)
         /*  colstride is halved in this function because u16 are used */
         int colstride = 1 << (info->fix.type_aux & FB_AUX_TEXT_SVGA_MASK);
         int rowstride = colstride * (info->var.xres_virtual / 8);
-        u16 *fb = (u16 *) info->screen_base;
-        u16 *src, *dst;
+        u16 __iomem *fb = (u16 __iomem *) info->screen_base;
+        u16 __iomem *src, *dst;
 
         if ((area->sy > area->dy) ||
             ((area->sy == area->dy) && (area->sx > area->dx))) {
@@ -239,10 +240,11 @@ void svga_tilecopy(struct fb_info *info, struct fb_tilearea *area)
             }
 
         for (dy = 0; dy < area->height; dy++) {
-                u16* src2 = src;
-                u16* dst2 = dst;
+                u16 __iomem *src2 = src;
+                u16 __iomem *dst2 = dst;
                 for (dx = 0; dx < area->width; dx++) {
-                        *dst2 = *src2;
+                        fb_writew(fb_readw(src2), dst2);
+//                      *dst2 = *src2;
                         src2 += colstride;
                         dst2 += colstride;
                 }
@@ -258,14 +260,14 @@ void svga_tilefill(struct fb_info *info, struct fb_tilerect *rect)
         int colstride = 2 << (info->fix.type_aux & FB_AUX_TEXT_SVGA_MASK);
         int rowstride = colstride * (info->var.xres_virtual / 8);
         int attr = (0x0F & rect->bg) << 4 | (0x0F & rect->fg);
-        u8  *fb = (u8 *) info->screen_base;
+        u8 __iomem *fb = (u8 __iomem *)info->screen_base;
         fb += rect->sx * colstride + rect->sy * rowstride;
 
         for (dy = 0; dy < rect->height; dy++) {
-                u8* fb2 = fb;
+                u8 __iomem *fb2 = fb;
                 for (dx = 0; dx < rect->width; dx++) {
-                        fb2[0] = rect->index;
-                        fb2[1] = attr;
+                        fb_writeb(rect->index, fb2);
+                        fb_writeb(attr, fb2 + 1);
                         fb2 += colstride;
                 }
                 fb += rowstride;
@@ -279,15 +281,15 @@ void svga_tileblit(struct fb_info *info, struct fb_tileblit *blit)
         int colstride = 2 << (info->fix.type_aux & FB_AUX_TEXT_SVGA_MASK);
         int rowstride = colstride * (info->var.xres_virtual / 8);
         int attr = (0x0F & blit->bg) << 4 | (0x0F & blit->fg);
-        u8* fb = (u8 *) info->screen_base;
+        u8 __iomem *fb = (u8 __iomem *)info->screen_base;
         fb += blit->sx * colstride + blit->sy * rowstride;
 
         i=0;
         for (dy=0; dy < blit->height; dy ++) {
-                u8* fb2 = fb;
+                u8 __iomem *fb2 = fb;
                 for (dx = 0; dx < blit->width; dx ++) {
-                        fb2[0] = blit->indices[i];
-                        fb2[1] = attr;
+                        fb_writeb(blit->indices[i], fb2);
+                        fb_writeb(attr, fb2 + 1);
                         fb2 += colstride;
                         i ++;
                         if (i == blit->length) return;
@@ -340,6 +342,11 @@ void svga_tilecursor(struct fb_info *info, struct fb_tilecursor *cursor)
         vga_wcrt(NULL, 0x0A, cs); /* set cursor start and enable it */
 }
 
+int svga_get_tilemax(struct fb_info *info)
+{
+        return 256;
+}
+
 
 /* ------------------------------------------------------------------------- */
 
@@ -621,6 +628,7 @@ EXPORT_SYMBOL(svga_tilecopy);
 EXPORT_SYMBOL(svga_tilefill);
 EXPORT_SYMBOL(svga_tileblit);
 EXPORT_SYMBOL(svga_tilecursor);
+EXPORT_SYMBOL(svga_get_tilemax);
 
 EXPORT_SYMBOL(svga_compute_pll);
 EXPORT_SYMBOL(svga_check_timings);
diff --git a/drivers/video/syscopyarea.c b/drivers/video/syscopyarea.c
new file mode 100644
index 000000000000..37af10ab8f52
--- /dev/null
+++ b/drivers/video/syscopyarea.c
@@ -0,0 +1,378 @@
+/*
+ *  Generic Bit Block Transfer for frame buffers located in system RAM with
+ *  packed pixels of any depth.
+ *
+ *  Based almost entirely from cfbcopyarea.c (which is based almost entirely
+ *  on Geert Uytterhoeven's copyarea routine)
+ *
+ *      Copyright (C)  2007 Antonino Daplas <adaplas@pol.net>
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License.  See the file COPYING in the main directory of this archive for
+ *  more details.
+ *
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/fb.h>
+#include <linux/slab.h>
+#include <asm/types.h>
+#include <asm/io.h>
+#include "fb_draw.h"
+
+    /*
+     *  Generic bitwise copy algorithm
+     */
+
+static void
+bitcpy(unsigned long *dst, int dst_idx, const unsigned long *src,
+        int src_idx, int bits, unsigned n)
+{
+        unsigned long first, last;
+        int const shift = dst_idx-src_idx;
+        int left, right;
+
+        first = FB_SHIFT_HIGH(~0UL, dst_idx);
+        last = ~(FB_SHIFT_HIGH(~0UL, (dst_idx+n) % bits));
+
+        if (!shift) {
+                /* Same alignment for source and dest */
+                if (dst_idx+n <= bits) {
+                        /* Single word */
+                        if (last)
+                                first &= last;
+                        *dst = comp(*src, *dst, first);
+                } else {
+                        /* Multiple destination words */
+                        /* Leading bits */
+                        if (first != ~0UL) {
+                                *dst = comp(*src, *dst, first);
+                                dst++;
+                                src++;
+                                n -= bits - dst_idx;
+                        }
+
+                        /* Main chunk */
+                        n /= bits;
+                        while (n >= 8) {
+                                *dst++ = *src++;
+                                *dst++ = *src++;
+                                *dst++ = *src++;
+                                *dst++ = *src++;
+                                *dst++ = *src++;
+                                *dst++ = *src++;
+                                *dst++ = *src++;
+                                *dst++ = *src++;
+                                n -= 8;
+                        }
+                        while (n--)
+                                *dst++ = *src++;
+
+                        /* Trailing bits */
+                        if (last)
+                                *dst = comp(*src, *dst, last);
+                }
+        } else {
+                unsigned long d0, d1;
+                int m;
+
+                /* Different alignment for source and dest */
+                right = shift & (bits - 1);
+                left = -shift & (bits - 1);
+
+                if (dst_idx+n <= bits) {
+                        /* Single destination word */
+                        if (last)
+                                first &= last;
+                        if (shift > 0) {
+                                /* Single source word */
+                                *dst = comp(*src >> right, *dst, first);
+                        } else if (src_idx+n <= bits) {
+                                /* Single source word */
+                                *dst = comp(*src << left, *dst, first);
+                        } else {
+                                /* 2 source words */
+                                d0 = *src++;
+                                d1 = *src;
+                                *dst = comp(d0 << left | d1 >> right, *dst,
+                                            first);
+                        }
+                } else {
+                        /* Multiple destination words */
+                        /** We must always remember the last value read,
+                            because in case SRC and DST overlap bitwise (e.g.
+                            when moving just one pixel in 1bpp), we always
+                            collect one full long for DST and that might
+                            overlap with the current long from SRC. We store
+                            this value in 'd0'. */
+                        d0 = *src++;
+                        /* Leading bits */
+                        if (shift > 0) {
+                                /* Single source word */
+                                *dst = comp(d0 >> right, *dst, first);
+                                dst++;
+                                n -= bits - dst_idx;
+                        } else {
+                                /* 2 source words */
+                                d1 = *src++;
+                                *dst = comp(d0 << left | *dst >> right, *dst, first);
+                                d0 = d1;
+                                dst++;
+                                n -= bits - dst_idx;
+                        }
+
+                        /* Main chunk */
+                        m = n % bits;
+                        n /= bits;
+                        while (n >= 4) {
+                                d1 = *src++;
+                                *dst++ = d0 << left | d1 >> right;
+                                d0 = d1;
+                                d1 = *src++;
+                                *dst++ = d0 << left | d1 >> right;
+                                d0 = d1;
+                                d1 = *src++;
+                                *dst++ = d0 << left | d1 >> right;
+                                d0 = d1;
+                                d1 = *src++;
+                                *dst++ = d0 << left | d1 >> right;
+                                d0 = d1;
+                                n -= 4;
+                        }
+                        while (n--) {
+                                d1 = *src++;
+                                *dst++ = d0 << left | d1 >> right;
+                                d0 = d1;
+                        }
+
+                        /* Trailing bits */
+                        if (last) {
+                                if (m <= right) {
+                                        /* Single source word */
+                                        *dst = comp(d0 << left, *dst, last);
+                                } else {
+                                        /* 2 source words */
+                                        d1 = *src;
+                                        *dst = comp(d0 << left | d1 >> right,
+                                                    *dst, last);
+                                }
+                        }
+                }
+        }
+}
+
+    /*
+     *  Generic bitwise copy algorithm, operating backward
+     */
+
+static void
+bitcpy_rev(unsigned long *dst, int dst_idx, const unsigned long *src,
+           int src_idx, int bits, unsigned n)
+{
+        unsigned long first, last;
+        int shift;
+
+        dst += (n-1)/bits;
+        src += (n-1)/bits;
+        if ((n-1) % bits) {
+                dst_idx += (n-1) % bits;
+                dst += dst_idx >> (ffs(bits) - 1);
+                dst_idx &= bits - 1;
+                src_idx += (n-1) % bits;
+                src += src_idx >> (ffs(bits) - 1);
+                src_idx &= bits - 1;
+        }
+
+        shift = dst_idx-src_idx;
+
+        first = FB_SHIFT_LOW(~0UL, bits - 1 - dst_idx);
+        last = ~(FB_SHIFT_LOW(~0UL, bits - 1 - ((dst_idx-n) % bits)));
+
+        if (!shift) {
+                /* Same alignment for source and dest */
+                if ((unsigned long)dst_idx+1 >= n) {
+                        /* Single word */
+                        if (last)
+                                first &= last;
+                        *dst = comp(*src, *dst, first);
+                } else {
+                        /* Multiple destination words */
+
+                        /* Leading bits */
+                        if (first != ~0UL) {
+                                *dst = comp(*src, *dst, first);
+                                dst--;
+                                src--;
+                                n -= dst_idx+1;
+                        }
+
+                        /* Main chunk */
+                        n /= bits;
+                        while (n >= 8) {
+                                *dst-- = *src--;
+                                *dst-- = *src--;
+                                *dst-- = *src--;
+                                *dst-- = *src--;
+                                *dst-- = *src--;
+                                *dst-- = *src--;
+                                *dst-- = *src--;
+                                *dst-- = *src--;
+                                n -= 8;
+                        }
+                        while (n--)
+                                *dst-- = *src--;
+                        /* Trailing bits */
+                        if (last)
+                                *dst = comp(*src, *dst, last);
+                }
+        } else {
+                /* Different alignment for source and dest */
+
+                int const left = -shift & (bits-1);
+                int const right = shift & (bits-1);
+
+                if ((unsigned long)dst_idx+1 >= n) {
+                        /* Single destination word */
+                        if (last)
+                                first &= last;
+                        if (shift < 0) {
+                                /* Single source word */
+                                *dst = comp(*src << left, *dst, first);
+                        } else if (1+(unsigned long)src_idx >= n) {
+                                /* Single source word */
+                                *dst = comp(*src >> right, *dst, first);
+                        } else {
+                                /* 2 source words */
+                                *dst = comp(*src >> right | *(src-1) << left,
+                                            *dst, first);
+                        }
+                } else {
+                        /* Multiple destination words */
+                        /** We must always remember the last value read,
+                            because in case SRC and DST overlap bitwise (e.g.
+                            when moving just one pixel in 1bpp), we always
+                            collect one full long for DST and that might
+                            overlap with the current long from SRC. We store
+                            this value in 'd0'. */
+                        unsigned long d0, d1;
+                        int m;
+
+                        d0 = *src--;
+                        /* Leading bits */
+                        if (shift < 0) {
+                                /* Single source word */
+                                *dst = comp(d0 << left, *dst, first);
+                        } else {
+                                /* 2 source words */
+                                d1 = *src--;
+                                *dst = comp(d0 >> right | d1 << left, *dst,
+                                            first);
+                                d0 = d1;
+                        }
+                        dst--;
+                        n -= dst_idx+1;
+
+                        /* Main chunk */
+                        m = n % bits;
+                        n /= bits;
+                        while (n >= 4) {
+                                d1 = *src--;
+                                *dst-- = d0 >> right | d1 << left;
+                                d0 = d1;
+                                d1 = *src--;
+                                *dst-- = d0 >> right | d1 << left;
+                                d0 = d1;
+                                d1 = *src--;
+                                *dst-- = d0 >> right | d1 << left;
+                                d0 = d1;
+                                d1 = *src--;
+                                *dst-- = d0 >> right | d1 << left;
+                                d0 = d1;
+                                n -= 4;
+                        }
+                        while (n--) {
+                                d1 = *src--;
+                                *dst-- = d0 >> right | d1 << left;
+                                d0 = d1;
+                        }
+
+                        /* Trailing bits */
+                        if (last) {
+                                if (m <= left) {
+                                        /* Single source word */
+                                        *dst = comp(d0 >> right, *dst, last);
+                                } else {
+                                        /* 2 source words */
+                                        d1 = *src;
+                                        *dst = comp(d0 >> right | d1 << left,
+                                                    *dst, last);
+                                }
+                        }
+                }
+        }
+}
+
+void sys_copyarea(struct fb_info *p, const struct fb_copyarea *area)
+{
+        u32 dx = area->dx, dy = area->dy, sx = area->sx, sy = area->sy;
+        u32 height = area->height, width = area->width;
+        unsigned long const bits_per_line = p->fix.line_length*8u;
+        unsigned long *dst = NULL, *src = NULL;
+        int bits = BITS_PER_LONG, bytes = bits >> 3;
+        int dst_idx = 0, src_idx = 0, rev_copy = 0;
+
+        if (p->state != FBINFO_STATE_RUNNING)
+                return;
+
+        /* if the beginning of the target area might overlap with the end of
+        the source area, be have to copy the area reverse. */
+        if ((dy == sy && dx > sx) || (dy > sy)) {
+                dy += height;
+                sy += height;
+                rev_copy = 1;
+        }
+
+        /* split the base of the framebuffer into a long-aligned address and
+           the index of the first bit */
+        dst = src = (unsigned long *)((unsigned long)p->screen_base &
+                                      ~(bytes-1));
+        dst_idx = src_idx = 8*((unsigned long)p->screen_base & (bytes-1));
+        /* add offset of source and target area */
+        dst_idx += dy*bits_per_line + dx*p->var.bits_per_pixel;
+        src_idx += sy*bits_per_line + sx*p->var.bits_per_pixel;
+
+        if (p->fbops->fb_sync)
+                p->fbops->fb_sync(p);
+
+        if (rev_copy) {
+                while (height--) {
+                        dst_idx -= bits_per_line;
+                        src_idx -= bits_per_line;
+                        dst += dst_idx >> (ffs(bits) - 1);
+                        dst_idx &= (bytes - 1);
+                        src += src_idx >> (ffs(bits) - 1);
+                        src_idx &= (bytes - 1);
+                        bitcpy_rev(dst, dst_idx, src, src_idx, bits,
+                                width*p->var.bits_per_pixel);
+                }
+        } else {
+                while (height--) {
+                        dst += dst_idx >> (ffs(bits) - 1);
+                        dst_idx &= (bytes - 1);
+                        src += src_idx >> (ffs(bits) - 1);
+                        src_idx &= (bytes - 1);
+                        bitcpy(dst, dst_idx, src, src_idx, bits,
+                                width*p->var.bits_per_pixel);
+                        dst_idx += bits_per_line;
+                        src_idx += bits_per_line;
+                }
+        }
+}
+
+EXPORT_SYMBOL(sys_copyarea);
+
+MODULE_AUTHOR("Antonino Daplas <adaplas@pol.net>");
+MODULE_DESCRIPTION("Generic copyarea (sys-to-sys)");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/video/sysfillrect.c b/drivers/video/sysfillrect.c
new file mode 100644
index 000000000000..a261e9e6a675
--- /dev/null
+++ b/drivers/video/sysfillrect.c
@@ -0,0 +1,334 @@
+/*
+ *  Generic fillrect for frame buffers in system RAM with packed pixels of
+ *  any depth.
+ *
+ *  Based almost entirely from cfbfillrect.c (which is based almost entirely
+ *  on Geert Uytterhoeven's fillrect routine)
+ *
+ *      Copyright (C)  2007 Antonino Daplas <adaplas@pol.net>
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License.  See the file COPYING in the main directory of this archive for
+ *  more details.
+ */
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/fb.h>
+#include <asm/types.h>
+#include "fb_draw.h"
+
+    /*
+     *  Aligned pattern fill using 32/64-bit memory accesses
+     */
+
+static void
+bitfill_aligned(unsigned long *dst, int dst_idx, unsigned long pat,
+                unsigned n, int bits)
+{
+        unsigned long first, last;
+
+        if (!n)
+                return;
+
+        first = FB_SHIFT_HIGH(~0UL, dst_idx);
+        last = ~(FB_SHIFT_HIGH(~0UL, (dst_idx+n) % bits));
+
+        if (dst_idx+n <= bits) {
+                /* Single word */
+                if (last)
+                        first &= last;
+                *dst = comp(pat, *dst, first);
+        } else {
+                /* Multiple destination words */
+
+                /* Leading bits */
+                if (first!= ~0UL) {
+                        *dst = comp(pat, *dst, first);
+                        dst++;
+                        n -= bits - dst_idx;
+                }
+
+                /* Main chunk */
+                n /= bits;
+                while (n >= 8) {
+                        *dst++ = pat;
+                        *dst++ = pat;
+                        *dst++ = pat;
+                        *dst++ = pat;
+                        *dst++ = pat;
+                        *dst++ = pat;
+                        *dst++ = pat;
+                        *dst++ = pat;
+                        n -= 8;
+                }
+                while (n--)
+                        *dst++ = pat;
+                /* Trailing bits */
+                if (last)
+                        *dst = comp(pat, *dst, last);
+        }
+}
+
+
+    /*
+     *  Unaligned generic pattern fill using 32/64-bit memory accesses
+     *  The pattern must have been expanded to a full 32/64-bit value
+     *  Left/right are the appropriate shifts to convert to the pattern to be
+     *  used for the next 32/64-bit word
+     */
+
+static void
+bitfill_unaligned(unsigned long *dst, int dst_idx, unsigned long pat,
+                  int left, int right, unsigned n, int bits)
+{
+        unsigned long first, last;
+
+        if (!n)
+                return;
+
+        first = FB_SHIFT_HIGH(~0UL, dst_idx);
+        last = ~(FB_SHIFT_HIGH(~0UL, (dst_idx+n) % bits));
+
+        if (dst_idx+n <= bits) {
+                /* Single word */
+                if (last)
+                        first &= last;
+                *dst = comp(pat, *dst, first);
+        } else {
+                /* Multiple destination words */
+                /* Leading bits */
+                if (first) {
+                        *dst = comp(pat, *dst, first);
+                        dst++;
+                        pat = pat << left | pat >> right;
+                        n -= bits - dst_idx;
+                }
+
+                /* Main chunk */
+                n /= bits;
+                while (n >= 4) {
+                        *dst++ = pat;
+                        pat = pat << left | pat >> right;
+                        *dst++ = pat;
+                        pat = pat << left | pat >> right;
+                        *dst++ = pat;
+                        pat = pat << left | pat >> right;
+                        *dst++ = pat;
+                        pat = pat << left | pat >> right;
+                        n -= 4;
+                }
+                while (n--) {
+                        *dst++ = pat;
+                        pat = pat << left | pat >> right;
+                }
+
+                /* Trailing bits */
+                if (last)
+                        *dst = comp(pat, *dst, first);
+        }
+}
+
+    /*
+     *  Aligned pattern invert using 32/64-bit memory accesses
+     */
+static void
+bitfill_aligned_rev(unsigned long *dst, int dst_idx, unsigned long pat,
+                    unsigned n, int bits)
+{
+        unsigned long val = pat;
+        unsigned long first, last;
+
+        if (!n)
+                return;
+
+        first = FB_SHIFT_HIGH(~0UL, dst_idx);
+        last = ~(FB_SHIFT_HIGH(~0UL, (dst_idx+n) % bits));
+
+        if (dst_idx+n <= bits) {
+                /* Single word */
+                if (last)
+                        first &= last;
+                *dst = comp(*dst ^ val, *dst, first);
+        } else {
+                /* Multiple destination words */
+                /* Leading bits */
+                if (first!=0UL) {
+                        *dst = comp(*dst ^ val, *dst, first);
+                        dst++;
+                        n -= bits - dst_idx;
+                }
+
+                /* Main chunk */
+                n /= bits;
+                while (n >= 8) {
+                        *dst++ ^= val;
+                        *dst++ ^= val;
+                        *dst++ ^= val;
+                        *dst++ ^= val;
+                        *dst++ ^= val;
+                        *dst++ ^= val;
+                        *dst++ ^= val;
+                        *dst++ ^= val;
+                        n -= 8;
+                }
+                while (n--)
+                        *dst++ ^= val;
+                /* Trailing bits */
+                if (last)
+                        *dst = comp(*dst ^ val, *dst, last);
+        }
+}
+
+
+    /*
+     *  Unaligned generic pattern invert using 32/64-bit memory accesses
+     *  The pattern must have been expanded to a full 32/64-bit value
+     *  Left/right are the appropriate shifts to convert to the pattern to be
+     *  used for the next 32/64-bit word
+     */
+
+static void
+bitfill_unaligned_rev(unsigned long *dst, int dst_idx, unsigned long pat,
+                        int left, int right, unsigned n, int bits)
+{
+        unsigned long first, last;
+
+        if (!n)
+                return;
+
+        first = FB_SHIFT_HIGH(~0UL, dst_idx);
+        last = ~(FB_SHIFT_HIGH(~0UL, (dst_idx+n) % bits));
+
+        if (dst_idx+n <= bits) {
+                /* Single word */
+                if (last)
+                        first &= last;
+                *dst = comp(*dst ^ pat, *dst, first);
+        } else {
+                /* Multiple destination words */
+
+                /* Leading bits */
+                if (first != 0UL) {
+                        *dst = comp(*dst ^ pat, *dst, first);
+                        dst++;
+                        pat = pat << left | pat >> right;
+                        n -= bits - dst_idx;
+                }
+
+                /* Main chunk */
+                n /= bits;
+                while (n >= 4) {
+                        *dst++ ^= pat;
+                        pat = pat << left | pat >> right;
+                        *dst++ ^= pat;
+                        pat = pat << left | pat >> right;
+                        *dst++ ^= pat;
+                        pat = pat << left | pat >> right;
+                        *dst++ ^= pat;
+                        pat = pat << left | pat >> right;
+                        n -= 4;
+                }
+                while (n--) {
+                        *dst ^= pat;
+                        pat = pat << left | pat >> right;
+                }
+
+                /* Trailing bits */
+                if (last)
+                        *dst = comp(*dst ^ pat, *dst, last);
+        }
+}
+
+void sys_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
+{
+        unsigned long pat, fg;
+        unsigned long width = rect->width, height = rect->height;
+        int bits = BITS_PER_LONG, bytes = bits >> 3;
+        u32 bpp = p->var.bits_per_pixel;
+        unsigned long *dst;
+        int dst_idx, left;
+
+        if (p->state != FBINFO_STATE_RUNNING)
+                return;
+
+        if (p->fix.visual == FB_VISUAL_TRUECOLOR ||
+            p->fix.visual == FB_VISUAL_DIRECTCOLOR )
+                fg = ((u32 *) (p->pseudo_palette))[rect->color];
+        else
+                fg = rect->color;
+
+        pat = pixel_to_pat( bpp, fg);
+
+        dst = (unsigned long *)((unsigned long)p->screen_base & ~(bytes-1));
+        dst_idx = ((unsigned long)p->screen_base & (bytes - 1))*8;
+        dst_idx += rect->dy*p->fix.line_length*8+rect->dx*bpp;
+        /* FIXME For now we support 1-32 bpp only */
+        left = bits % bpp;
+        if (p->fbops->fb_sync)
+                p->fbops->fb_sync(p);
+        if (!left) {
+                void (*fill_op32)(unsigned long *dst, int dst_idx,
+                                  unsigned long pat, unsigned n, int bits) =
+                        NULL;
+
+                switch (rect->rop) {
+                case ROP_XOR:
+                        fill_op32 = bitfill_aligned_rev;
+                        break;
+                case ROP_COPY:
+                        fill_op32 = bitfill_aligned;
+                        break;
+                default:
+                        printk( KERN_ERR "cfb_fillrect(): unknown rop, "
+                                "defaulting to ROP_COPY\n");
+                        fill_op32 = bitfill_aligned;
+                        break;
+                }
+                while (height--) {
+                        dst += dst_idx >> (ffs(bits) - 1);
+                        dst_idx &= (bits - 1);
+                        fill_op32(dst, dst_idx, pat, width*bpp, bits);
+                        dst_idx += p->fix.line_length*8;
+                }
+        } else {
+                int right;
+                int r;
+                int rot = (left-dst_idx) % bpp;
+                void (*fill_op)(unsigned long *dst, int dst_idx,
+                                unsigned long pat, int left, int right,
+                                unsigned n, int bits) = NULL;
+
+                /* rotate pattern to correct start position */
+                pat = pat << rot | pat >> (bpp-rot);
+
+                right = bpp-left;
+                switch (rect->rop) {
+                case ROP_XOR:
+                        fill_op = bitfill_unaligned_rev;
+                        break;
+                case ROP_COPY:
+                        fill_op = bitfill_unaligned;
+                        break;
+                default:
+                        printk(KERN_ERR "cfb_fillrect(): unknown rop, "
+                                "defaulting to ROP_COPY\n");
+                        fill_op = bitfill_unaligned;
+                        break;
+                }
+                while (height--) {
+                        dst += dst_idx >> (ffs(bits) - 1);
+                        dst_idx &= (bits - 1);
+                        fill_op(dst, dst_idx, pat, left, right,
+                                width*bpp, bits);
+                        r = (p->fix.line_length*8) % bpp;
+                        pat = pat << (bpp-r) | pat >> r;
+                        dst_idx += p->fix.line_length*8;
+                }
+        }
+}
+
+EXPORT_SYMBOL(sys_fillrect);
+
+MODULE_AUTHOR("Antonino Daplas <adaplas@pol.net>");
+MODULE_DESCRIPTION("Generic fill rectangle (sys-to-sys)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/sysimgblt.c b/drivers/video/sysimgblt.c
new file mode 100644
index 000000000000..bd7e7e9d155f
--- /dev/null
+++ b/drivers/video/sysimgblt.c
@@ -0,0 +1,291 @@
+/*
+ *  Generic 1-bit or 8-bit source to 1-32 bit destination expansion
+ *  for frame buffer located in system RAM with packed pixels of any depth.
+ *
+ *  Based almost entirely on cfbimgblt.c
+ *
+ *      Copyright (C)  April 2007 Antonino Daplas <adaplas@pol.net>
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License.  See the file COPYING in the main directory of this archive for
+ *  more details.
+ */
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/fb.h>
+#include <asm/types.h>
+
+#define DEBUG
+
+#ifdef DEBUG
+#define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt,__FUNCTION__,## args)
+#else
+#define DPRINTK(fmt, args...)
+#endif
+
+static const u32 cfb_tab8[] = {
+#if defined(__BIG_ENDIAN)
+    0x00000000,0x000000ff,0x0000ff00,0x0000ffff,
+    0x00ff0000,0x00ff00ff,0x00ffff00,0x00ffffff,
+    0xff000000,0xff0000ff,0xff00ff00,0xff00ffff,
+    0xffff0000,0xffff00ff,0xffffff00,0xffffffff
+#elif defined(__LITTLE_ENDIAN)
+    0x00000000,0xff000000,0x00ff0000,0xffff0000,
+    0x0000ff00,0xff00ff00,0x00ffff00,0xffffff00,
+    0x000000ff,0xff0000ff,0x00ff00ff,0xffff00ff,
+    0x0000ffff,0xff00ffff,0x00ffffff,0xffffffff
+#else
+#error FIXME: No endianness??
+#endif
+};
+
+static const u32 cfb_tab16[] = {
+#if defined(__BIG_ENDIAN)
+    0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff
+#elif defined(__LITTLE_ENDIAN)
+    0x00000000, 0xffff0000, 0x0000ffff, 0xffffffff
+#else
+#error FIXME: No endianness??
+#endif
+};
+
+static const u32 cfb_tab32[] = {
+        0x00000000, 0xffffffff
+};
+
+static void color_imageblit(const struct fb_image *image, struct fb_info *p,
+                            void *dst1, u32 start_index, u32 pitch_index)
+{
+        /* Draw the penguin */
+        u32 *dst, *dst2;
+        u32 color = 0, val, shift;
+        int i, n, bpp = p->var.bits_per_pixel;
+        u32 null_bits = 32 - bpp;
+        u32 *palette = (u32 *) p->pseudo_palette;
+        const u8 *src = image->data;
+
+        dst2 = dst1;
+        for (i = image->height; i--; ) {
+                n = image->width;
+                dst = dst1;
+                shift = 0;
+                val = 0;
+
+                if (start_index) {
+                        u32 start_mask = ~(FB_SHIFT_HIGH(~(u32)0,
+                                                         start_index));
+                        val = *dst & start_mask;
+                        shift = start_index;
+                }
+                while (n--) {
+                        if (p->fix.visual == FB_VISUAL_TRUECOLOR ||
+                            p->fix.visual == FB_VISUAL_DIRECTCOLOR )
+                                color = palette[*src];
+                        else
+                                color = *src;
+                        color <<= FB_LEFT_POS(bpp);
+                        val |= FB_SHIFT_HIGH(color, shift);
+                        if (shift >= null_bits) {
+                                *dst++ = val;
+
+                                val = (shift == null_bits) ? 0 :
+                                        FB_SHIFT_LOW(color, 32 - shift);
+                        }
+                        shift += bpp;
+                        shift &= (32 - 1);
+                        src++;
+                }
+                if (shift) {
+                        u32 end_mask = FB_SHIFT_HIGH(~(u32)0, shift);
+
+                        *dst &= end_mask;
+                        *dst |= val;
+                }
+                dst1 += p->fix.line_length;
+                if (pitch_index) {
+                        dst2 += p->fix.line_length;
+                        dst1 = (u8 *)((long)dst2 & ~(sizeof(u32) - 1));
+
+                        start_index += pitch_index;
+                        start_index &= 32 - 1;
+                }
+        }
+}
+
+static void slow_imageblit(const struct fb_image *image, struct fb_info *p,
+                                  void *dst1, u32 fgcolor, u32 bgcolor,
+                                  u32 start_index, u32 pitch_index)
+{
+        u32 shift, color = 0, bpp = p->var.bits_per_pixel;
+        u32 *dst, *dst2;
+        u32 val, pitch = p->fix.line_length;
+        u32 null_bits = 32 - bpp;
+        u32 spitch = (image->width+7)/8;
+        const u8 *src = image->data, *s;
+        u32 i, j, l;
+
+        dst2 = dst1;
+        fgcolor <<= FB_LEFT_POS(bpp);
+        bgcolor <<= FB_LEFT_POS(bpp);
+
+        for (i = image->height; i--; ) {
+                shift = val = 0;
+                l = 8;
+                j = image->width;
+                dst = dst1;
+                s = src;
+
+                /* write leading bits */
+                if (start_index) {
+                        u32 start_mask = ~(FB_SHIFT_HIGH(~(u32)0,start_index));
+                        val = *dst & start_mask;
+                        shift = start_index;
+                }
+
+                while (j--) {
+                        l--;
+                        color = (*s & (1 << l)) ? fgcolor : bgcolor;
+                        val |= FB_SHIFT_HIGH(color, shift);
+
+                        /* Did the bitshift spill bits to the next long? */
+                        if (shift >= null_bits) {
+                                *dst++ = val;
+                                val = (shift == null_bits) ? 0 :
+                                        FB_SHIFT_LOW(color,32 - shift);
+                        }
+                        shift += bpp;
+                        shift &= (32 - 1);
+                        if (!l) { l = 8; s++; };
+                }
+
+                /* write trailing bits */
+                if (shift) {
+                        u32 end_mask = FB_SHIFT_HIGH(~(u32)0, shift);
+
+                        *dst &= end_mask;
+                        *dst |= val;
+                }
+
+                dst1 += pitch;
+                src += spitch;
+                if (pitch_index) {
+                        dst2 += pitch;
+                        dst1 = (u8 *)((long)dst2 & ~(sizeof(u32) - 1));
+                        start_index += pitch_index;
+                        start_index &= 32 - 1;
+                }
+
+        }
+}
+
+/*
+ * fast_imageblit - optimized monochrome color expansion
+ *
+ * Only if:  bits_per_pixel == 8, 16, or 32
+ *           image->width is divisible by pixel/dword (ppw);
+ *           fix->line_legth is divisible by 4;
+ *           beginning and end of a scanline is dword aligned
+ */
+static void fast_imageblit(const struct fb_image *image, struct fb_info *p,
+                                  void *dst1, u32 fgcolor, u32 bgcolor)
+{
+        u32 fgx = fgcolor, bgx = bgcolor, bpp = p->var.bits_per_pixel;
+        u32 ppw = 32/bpp, spitch = (image->width + 7)/8;
+        u32 bit_mask, end_mask, eorx, shift;
+        const char *s = image->data, *src;
+        u32 *dst;
+        const u32 *tab = NULL;
+        int i, j, k;
+
+        switch (bpp) {
+        case 8:
+                tab = cfb_tab8;
+                break;
+        case 16:
+                tab = cfb_tab16;
+                break;
+        case 32:
+        default:
+                tab = cfb_tab32;
+                break;
+        }
+
+        for (i = ppw-1; i--; ) {
+                fgx <<= bpp;
+                bgx <<= bpp;
+                fgx |= fgcolor;
+                bgx |= bgcolor;
+        }
+
+        bit_mask = (1 << ppw) - 1;
+        eorx = fgx ^ bgx;
+        k = image->width/ppw;
+
+        for (i = image->height; i--; ) {
+                dst = dst1;
+                shift = 8;
+                src = s;
+
+                for (j = k; j--; ) {
+                        shift -= ppw;
+                        end_mask = tab[(*src >> shift) & bit_mask];
+                        *dst++ = (end_mask & eorx) ^ bgx;
+                        if (!shift) {
+                                shift = 8;
+                                src++;
+                        }
+                }
+                dst1 += p->fix.line_length;
+                s += spitch;
+        }
+}
+
+void sys_imageblit(struct fb_info *p, const struct fb_image *image)
+{
+        u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0;
+        u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel;
+        u32 width = image->width;
+        u32 dx = image->dx, dy = image->dy;
+        void *dst1;
+
+        if (p->state != FBINFO_STATE_RUNNING)
+                return;
+
+        bitstart = (dy * p->fix.line_length * 8) + (dx * bpp);
+        start_index = bitstart & (32 - 1);
+        pitch_index = (p->fix.line_length & (bpl - 1)) * 8;
+
+        bitstart /= 8;
+        bitstart &= ~(bpl - 1);
+        dst1 = (void __force *)p->screen_base + bitstart;
+
+        if (p->fbops->fb_sync)
+                p->fbops->fb_sync(p);
+
+        if (image->depth == 1) {
+                if (p->fix.visual == FB_VISUAL_TRUECOLOR ||
+                    p->fix.visual == FB_VISUAL_DIRECTCOLOR) {
+                        fgcolor = ((u32*)(p->pseudo_palette))[image->fg_color];
+                        bgcolor = ((u32*)(p->pseudo_palette))[image->bg_color];
+                } else {
+                        fgcolor = image->fg_color;
+                        bgcolor = image->bg_color;
+                }
+
+                if (32 % bpp == 0 && !start_index && !pitch_index &&
+                    ((width & (32/bpp-1)) == 0) &&
+                    bpp >= 8 && bpp <= 32)
+                        fast_imageblit(image, p, dst1, fgcolor, bgcolor);
+                else
+                        slow_imageblit(image, p, dst1, fgcolor, bgcolor,
+                                        start_index, pitch_index);
+        } else
+                color_imageblit(image, p, dst1, start_index, pitch_index);
+}
+
+EXPORT_SYMBOL(sys_imageblit);
+
+MODULE_AUTHOR("Antonino Daplas <adaplas@pol.net>");
+MODULE_DESCRIPTION("1-bit/8-bit to 1-32 bit color expansion (sys-to-sys)");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/video/tgafb.c b/drivers/video/tgafb.c
index 7478d0e3e211..f0fde6ea7c36 100644
--- a/drivers/video/tgafb.c
+++ b/drivers/video/tgafb.c
@@ -5,27 +5,45 @@
  *      Copyright (C) 1997 Geert Uytterhoeven
  *      Copyright (C) 1999,2000 Martin Lucina, Tom Zerucha
  *      Copyright (C) 2002 Richard Henderson
+ *      Copyright (C) 2006 Maciej W. Rozycki
  *
  *  This file is subject to the terms and conditions of the GNU General Public
  *  License. See the file COPYING in the main directory of this archive for
  *  more details.
  */
 
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
+#include <linux/bitrev.h>
 #include <linux/delay.h>
-#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/errno.h>
 #include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/selection.h>
-#include <linux/bitrev.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/tc.h>
+
 #include <asm/io.h>
+
 #include <video/tgafb.h>
 
+#ifdef CONFIG_PCI
+#define TGA_BUS_PCI(dev) (dev->bus == &pci_bus_type)
+#else
+#define TGA_BUS_PCI(dev) 0
+#endif
+
+#ifdef CONFIG_TC
+#define TGA_BUS_TC(dev) (dev->bus == &tc_bus_type)
+#else
+#define TGA_BUS_TC(dev) 0
+#endif
+
 /*
  * Local functions.
  */
@@ -41,14 +59,19 @@ static void tgafb_init_fix(struct fb_info *);
 static void tgafb_imageblit(struct fb_info *, const struct fb_image *);
 static void tgafb_fillrect(struct fb_info *, const struct fb_fillrect *);
 static void tgafb_copyarea(struct fb_info *, const struct fb_copyarea *);
+static int tgafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info);
 
-static int __devinit tgafb_pci_register(struct pci_dev *,
-                                        const struct pci_device_id *);
-static void __devexit tgafb_pci_unregister(struct pci_dev *);
+static int __devinit tgafb_register(struct device *dev);
+static void __devexit tgafb_unregister(struct device *dev);
 
-static const char *mode_option = "640x480@60";
+static const char *mode_option;
+static const char *mode_option_pci = "640x480@60";
+static const char *mode_option_tc = "1280x1024@72";
 
 
+static struct pci_driver tgafb_pci_driver;
+static struct tc_driver tgafb_tc_driver;
+
 /*
  *  Frame buffer operations
  */
@@ -59,15 +82,20 @@ static struct fb_ops tgafb_ops = {
         .fb_set_par             = tgafb_set_par,
         .fb_setcolreg           = tgafb_setcolreg,
         .fb_blank               = tgafb_blank,
+        .fb_pan_display         = tgafb_pan_display,
         .fb_fillrect            = tgafb_fillrect,
         .fb_copyarea            = tgafb_copyarea,
         .fb_imageblit           = tgafb_imageblit,
 };
 
 
+#ifdef CONFIG_PCI
 /*
  *  PCI registration operations
  */
+static int __devinit tgafb_pci_register(struct pci_dev *,
+                                        const struct pci_device_id *);
+static void __devexit tgafb_pci_unregister(struct pci_dev *);
 
 static struct pci_device_id const tgafb_pci_table[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TGA) },
@@ -75,13 +103,68 @@ static struct pci_device_id const tgafb_pci_table[] = {
 };
 MODULE_DEVICE_TABLE(pci, tgafb_pci_table);
 
-static struct pci_driver tgafb_driver = {
+static struct pci_driver tgafb_pci_driver = {
         .name                   = "tgafb",
         .id_table               = tgafb_pci_table,
         .probe                  = tgafb_pci_register,
         .remove                 = __devexit_p(tgafb_pci_unregister),
 };
 
+static int __devinit
+tgafb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+        return tgafb_register(&pdev->dev);
+}
+
+static void __devexit
+tgafb_pci_unregister(struct pci_dev *pdev)
+{
+        tgafb_unregister(&pdev->dev);
+}
+#endif /* CONFIG_PCI */
+
+#ifdef CONFIG_TC
+/*
+ *  TC registration operations
+ */
+static int __devinit tgafb_tc_register(struct device *);
+static int __devexit tgafb_tc_unregister(struct device *);
+
+static struct tc_device_id const tgafb_tc_table[] = {
+        { "DEC     ", "PMAGD-AA" },
+        { "DEC     ", "PMAGD   " },
+        { }
+};
+MODULE_DEVICE_TABLE(tc, tgafb_tc_table);
+
+static struct tc_driver tgafb_tc_driver = {
+        .id_table               = tgafb_tc_table,
+        .driver                 = {
+                .name           = "tgafb",
+                .bus            = &tc_bus_type,
+                .probe          = tgafb_tc_register,
+                .remove         = __devexit_p(tgafb_tc_unregister),
+        },
+};
+
+static int __devinit
+tgafb_tc_register(struct device *dev)
+{
+        int status = tgafb_register(dev);
+        if (!status)
+                get_device(dev);
+        return status;
+}
+
+static int __devexit
+tgafb_tc_unregister(struct device *dev)
+{
+        put_device(dev);
+        tgafb_unregister(dev);
+        return 0;
+}
+#endif /* CONFIG_TC */
+
 
 /**
  *      tgafb_check_var - Optional function.  Validates a var passed in.
@@ -132,10 +215,10 @@ static int
 tgafb_set_par(struct fb_info *info)
 {
         static unsigned int const deep_presets[4] = {
-                0x00014000,
-                0x0001440d,
+                0x00004000,
+                0x0000440d,
                 0xffffffff,
-                0x0001441d
+                0x0000441d
         };
         static unsigned int const rasterop_presets[4] = {
                 0x00000003,
@@ -157,6 +240,8 @@ tgafb_set_par(struct fb_info *info)
         };
 
         struct tga_par *par = (struct tga_par *) info->par;
+        int tga_bus_pci = TGA_BUS_PCI(par->dev);
+        int tga_bus_tc = TGA_BUS_TC(par->dev);
         u32 htimings, vtimings, pll_freq;
         u8 tga_type;
         int i;
@@ -221,7 +306,7 @@ tgafb_set_par(struct fb_info *info)
         TGA_WRITE_REG(par, vtimings, TGA_VERT_REG);
 
         /* Initalise RAMDAC. */
-        if (tga_type == TGA_TYPE_8PLANE) {
+        if (tga_type == TGA_TYPE_8PLANE && tga_bus_pci) {
 
                 /* Init BT485 RAMDAC registers.  */
                 BT485_WRITE(par, 0xa2 | (par->sync_on_green ? 0x8 : 0x0),
@@ -236,21 +321,7 @@ tgafb_set_par(struct fb_info *info)
                 BT485_WRITE(par, 0x00, BT485_ADDR_PAL_WRITE);
                 TGA_WRITE_REG(par, BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);
 
-#ifdef CONFIG_HW_CONSOLE
-                for (i = 0; i < 16; i++) {
-                        int j = color_table[i];
-
-                        TGA_WRITE_REG(par, default_red[j]|(BT485_DATA_PAL<<8),
-                                      TGA_RAMDAC_REG);
-                        TGA_WRITE_REG(par, default_grn[j]|(BT485_DATA_PAL<<8),
-                                      TGA_RAMDAC_REG);
-                        TGA_WRITE_REG(par, default_blu[j]|(BT485_DATA_PAL<<8),
-                                      TGA_RAMDAC_REG);
-                }
-                for (i = 0; i < 240 * 3; i += 4) {
-#else
                 for (i = 0; i < 256 * 3; i += 4) {
-#endif
                         TGA_WRITE_REG(par, 0x55 | (BT485_DATA_PAL << 8),
                                       TGA_RAMDAC_REG);
                         TGA_WRITE_REG(par, 0x00 | (BT485_DATA_PAL << 8),
@@ -261,6 +332,27 @@ tgafb_set_par(struct fb_info *info)
                                       TGA_RAMDAC_REG);
                 }
 
+        } else if (tga_type == TGA_TYPE_8PLANE && tga_bus_tc) {
+
+                /* Init BT459 RAMDAC registers.  */
+                BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_0, 0x40);
+                BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_1, 0x00);
+                BT459_WRITE(par, BT459_REG_ACC, BT459_CMD_REG_2,
+                            (par->sync_on_green ? 0xc0 : 0x40));
+
+                BT459_WRITE(par, BT459_REG_ACC, BT459_CUR_CMD_REG, 0x00);
+
+                /* Fill the palette.  */
+                BT459_LOAD_ADDR(par, 0x0000);
+                TGA_WRITE_REG(par, BT459_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
+
+                for (i = 0; i < 256 * 3; i += 4) {
+                        TGA_WRITE_REG(par, 0x55, TGA_RAMDAC_REG);
+                        TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
+                        TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
+                        TGA_WRITE_REG(par, 0x00, TGA_RAMDAC_REG);
+                }
+
         } else { /* 24-plane or 24plusZ */
 
                 /* Init BT463 RAMDAC registers.  */
@@ -431,6 +523,8 @@ tgafb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
                 unsigned transp, struct fb_info *info)
 {
         struct tga_par *par = (struct tga_par *) info->par;
+        int tga_bus_pci = TGA_BUS_PCI(par->dev);
+        int tga_bus_tc = TGA_BUS_TC(par->dev);
 
         if (regno > 255)
                 return 1;
@@ -438,12 +532,18 @@ tgafb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
         green >>= 8;
         blue >>= 8;
 
-        if (par->tga_type == TGA_TYPE_8PLANE) {
+        if (par->tga_type == TGA_TYPE_8PLANE && tga_bus_pci) {
                 BT485_WRITE(par, regno, BT485_ADDR_PAL_WRITE);
                 TGA_WRITE_REG(par, BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);
                 TGA_WRITE_REG(par, red|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
                 TGA_WRITE_REG(par, green|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
                 TGA_WRITE_REG(par, blue|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
+        } else if (par->tga_type == TGA_TYPE_8PLANE && tga_bus_tc) {
+                BT459_LOAD_ADDR(par, regno);
+                TGA_WRITE_REG(par, BT459_PALETTE << 2, TGA_RAMDAC_SETUP_REG);
+                TGA_WRITE_REG(par, red, TGA_RAMDAC_REG);
+                TGA_WRITE_REG(par, green, TGA_RAMDAC_REG);
+                TGA_WRITE_REG(par, blue, TGA_RAMDAC_REG);
         } else {
                 if (regno < 16) {
                         u32 value = (regno << 16) | (regno << 8) | regno;
@@ -523,16 +623,8 @@ tgafb_blank(int blank, struct fb_info *info)
  *  Acceleration.
  */
 
-/**
- *      tgafb_imageblit - REQUIRED function. Can use generic routines if
- *                        non acclerated hardware and packed pixel based.
- *                        Copies a image from system memory to the screen. 
- *
- *      @info: frame buffer structure that represents a single frame buffer
- *      @image: structure defining the image.
- */
 static void
-tgafb_imageblit(struct fb_info *info, const struct fb_image *image)
+tgafb_mono_imageblit(struct fb_info *info, const struct fb_image *image)
 {
         struct tga_par *par = (struct tga_par *) info->par;
         u32 fgcolor, bgcolor, dx, dy, width, height, vxres, vyres, pixelmask;
@@ -542,6 +634,17 @@ tgafb_imageblit(struct fb_info *info, const struct fb_image *image)
         void __iomem *regs_base;
         void __iomem *fb_base;
 
+        is8bpp = info->var.bits_per_pixel == 8;
+
+        /* For copies that aren't pixel expansion, there's little we
+           can do better than the generic code.  */
+        /* ??? There is a DMA write mode; I wonder if that could be
+           made to pull the data from the image buffer...  */
+        if (image->depth > 1) {
+                cfb_imageblit(info, image);
+                return;
+        }
+
         dx = image->dx;
         dy = image->dy;
         width = image->width;
@@ -559,18 +662,8 @@ tgafb_imageblit(struct fb_info *info, const struct fb_image *image)
         if (dy + height > vyres)
                 height = vyres - dy;
 
-        /* For copies that aren't pixel expansion, there's little we
-           can do better than the generic code.  */
-        /* ??? There is a DMA write mode; I wonder if that could be
-           made to pull the data from the image buffer...  */
-        if (image->depth > 1) {
-                cfb_imageblit(info, image);
-                return;
-        }
-
         regs_base = par->tga_regs_base;
         fb_base = par->tga_fb_base;
-        is8bpp = info->var.bits_per_pixel == 8;
 
         /* Expand the color values to fill 32-bits.  */
         /* ??? Would be nice to notice colour changes elsewhere, so
@@ -748,6 +841,85 @@ tgafb_imageblit(struct fb_info *info, const struct fb_image *image)
                      regs_base + TGA_MODE_REG);
 }
 
+static void
+tgafb_clut_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+        struct tga_par *par = (struct tga_par *) info->par;
+        u32 color, dx, dy, width, height, vxres, vyres;
+        u32 *palette = ((u32 *)info->pseudo_palette);
+        unsigned long pos, line_length, i, j;
+        const unsigned char *data;
+        void *regs_base, *fb_base;
+
+        dx = image->dx;
+        dy = image->dy;
+        width = image->width;
+        height = image->height;
+        vxres = info->var.xres_virtual;
+        vyres = info->var.yres_virtual;
+        line_length = info->fix.line_length;
+
+        /* Crop the image to the screen.  */
+        if (dx > vxres || dy > vyres)
+                return;
+        if (dx + width > vxres)
+                width = vxres - dx;
+        if (dy + height > vyres)
+                height = vyres - dy;
+
+        regs_base = par->tga_regs_base;
+        fb_base = par->tga_fb_base;
+
+        pos = dy * line_length + (dx * 4);
+        data = image->data;
+
+        /* Now copy the image, color_expanding via the palette. */
+        for (i = 0; i < height; i++) {
+                for (j = 0; j < width; j++) {
+                        color = palette[*data++];
+                        __raw_writel(color, fb_base + pos + j*4);
+                }
+                pos += line_length;
+        }
+}
+
+/**
+ *      tgafb_imageblit - REQUIRED function. Can use generic routines if
+ *                        non acclerated hardware and packed pixel based.
+ *                        Copies a image from system memory to the screen.
+ *
+ *      @info: frame buffer structure that represents a single frame buffer
+ *      @image: structure defining the image.
+ */
+static void
+tgafb_imageblit(struct fb_info *info, const struct fb_image *image)
+{
+        unsigned int is8bpp = info->var.bits_per_pixel == 8;
+
+        /* If a mono image, regardless of FB depth, go do it. */
+        if (image->depth == 1) {
+                tgafb_mono_imageblit(info, image);
+                return;
+        }
+
+        /* For copies that aren't pixel expansion, there's little we
+           can do better than the generic code.  */
+        /* ??? There is a DMA write mode; I wonder if that could be
+           made to pull the data from the image buffer...  */
+        if (image->depth == info->var.bits_per_pixel) {
+                cfb_imageblit(info, image);
+                return;
+        }
+
+        /* If 24-plane FB and the image is 8-plane with CLUT, we can do it. */
+        if (!is8bpp && image->depth == 8) {
+                tgafb_clut_imageblit(info, image);
+                return;
+        }
+
+        /* Silently return... */
+}
+
 /**
  *      tgafb_fillrect - REQUIRED function. Can use generic routines if 
  *                       non acclerated hardware and packed pixel based.
@@ -1309,18 +1481,29 @@ static void
 tgafb_init_fix(struct fb_info *info)
 {
         struct tga_par *par = (struct tga_par *)info->par;
+        int tga_bus_pci = TGA_BUS_PCI(par->dev);
+        int tga_bus_tc = TGA_BUS_TC(par->dev);
         u8 tga_type = par->tga_type;
-        const char *tga_type_name;
+        const char *tga_type_name = NULL;
 
         switch (tga_type) {
         case TGA_TYPE_8PLANE:
-                tga_type_name = "Digital ZLXp-E1";
+                if (tga_bus_pci)
+                        tga_type_name = "Digital ZLXp-E1";
+                if (tga_bus_tc)
+                        tga_type_name = "Digital ZLX-E1";
                 break;
         case TGA_TYPE_24PLANE:
-                tga_type_name = "Digital ZLXp-E2";
+                if (tga_bus_pci)
+                        tga_type_name = "Digital ZLXp-E2";
+                if (tga_bus_tc)
+                        tga_type_name = "Digital ZLX-E2";
                 break;
         case TGA_TYPE_24PLUSZ:
-                tga_type_name = "Digital ZLXp-E3";
+                if (tga_bus_pci)
+                        tga_type_name = "Digital ZLXp-E3";
+                if (tga_bus_tc)
+                        tga_type_name = "Digital ZLX-E3";
                 break;
         default:
                 tga_type_name = "Unknown";
@@ -1346,11 +1529,37 @@ tgafb_init_fix(struct fb_info *info)
         info->fix.ywrapstep = 0;
 
         info->fix.accel = FB_ACCEL_DEC_TGA;
+
+        /*
+         * These are needed by fb_set_logo_truepalette(), so we
+         * set them here for 24-plane cards.
+         */
+        if (tga_type != TGA_TYPE_8PLANE) {
+                info->var.red.length = 8;
+                info->var.green.length = 8;
+                info->var.blue.length = 8;
+                info->var.red.offset = 16;
+                info->var.green.offset = 8;
+                info->var.blue.offset = 0;
+        }
 }
 
-static __devinit int
-tgafb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent)
+static int tgafb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        /* We just use this to catch switches out of graphics mode. */
+        tgafb_set_par(info); /* A bit of overkill for BASE_ADDR reset. */
+        return 0;
+}
+
+static int __devinit
+tgafb_register(struct device *dev)
 {
+        static const struct fb_videomode modedb_tc = {
+                /* 1280x1024 @ 72 Hz, 76.8 kHz hsync */
+                "1280x1024@72", 0, 1280, 1024, 7645, 224, 28, 33, 3, 160, 3,
+                FB_SYNC_ON_GREEN, FB_VMODE_NONINTERLACED
+        };
+
         static unsigned int const fb_offset_presets[4] = {
                 TGA_8PLANE_FB_OFFSET,
                 TGA_24PLANE_FB_OFFSET,
@@ -1358,40 +1567,51 @@ tgafb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent)
                 TGA_24PLUSZ_FB_OFFSET
         };
 
+        const struct fb_videomode *modedb_tga = NULL;
+        resource_size_t bar0_start = 0, bar0_len = 0;
+        const char *mode_option_tga = NULL;
+        int tga_bus_pci = TGA_BUS_PCI(dev);
+        int tga_bus_tc = TGA_BUS_TC(dev);
+        unsigned int modedbsize_tga = 0;
         void __iomem *mem_base;
-        unsigned long bar0_start, bar0_len;
         struct fb_info *info;
         struct tga_par *par;
         u8 tga_type;
-        int ret;
+        int ret = 0;
 
         /* Enable device in PCI config.  */
-        if (pci_enable_device(pdev)) {
+        if (tga_bus_pci && pci_enable_device(to_pci_dev(dev))) {
                 printk(KERN_ERR "tgafb: Cannot enable PCI device\n");
                 return -ENODEV;
         }
 
         /* Allocate the fb and par structures.  */
-        info = framebuffer_alloc(sizeof(struct tga_par), &pdev->dev);
+        info = framebuffer_alloc(sizeof(struct tga_par), dev);
         if (!info) {
                 printk(KERN_ERR "tgafb: Cannot allocate memory\n");
                 return -ENOMEM;
         }
 
         par = info->par;
-        pci_set_drvdata(pdev, info);
+        dev_set_drvdata(dev, info);
 
         /* Request the mem regions.  */
-        bar0_start = pci_resource_start(pdev, 0);
-        bar0_len = pci_resource_len(pdev, 0);
         ret = -ENODEV;
+        if (tga_bus_pci) {
+                bar0_start = pci_resource_start(to_pci_dev(dev), 0);
+                bar0_len = pci_resource_len(to_pci_dev(dev), 0);
+        }
+        if (tga_bus_tc) {
+                bar0_start = to_tc_dev(dev)->resource.start;
+                bar0_len = to_tc_dev(dev)->resource.end - bar0_start + 1;
+        }
         if (!request_mem_region (bar0_start, bar0_len, "tgafb")) {
                 printk(KERN_ERR "tgafb: cannot reserve FB region\n");
                 goto err0;
         }
 
         /* Map the framebuffer.  */
-        mem_base = ioremap(bar0_start, bar0_len);
+        mem_base = ioremap_nocache(bar0_start, bar0_len);
         if (!mem_base) {
                 printk(KERN_ERR "tgafb: Cannot map MMIO\n");
                 goto err1;
@@ -1399,12 +1619,16 @@ tgafb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         /* Grab info about the card.  */
         tga_type = (readl(mem_base) >> 12) & 0x0f;
-        par->pdev = pdev;
+        par->dev = dev;
         par->tga_mem_base = mem_base;
         par->tga_fb_base = mem_base + fb_offset_presets[tga_type];
         par->tga_regs_base = mem_base + TGA_REGS_OFFSET;
         par->tga_type = tga_type;
-        pci_read_config_byte(pdev, PCI_REVISION_ID, &par->tga_chip_rev);
+        if (tga_bus_pci)
+                pci_read_config_byte(to_pci_dev(dev), PCI_REVISION_ID,
+                                     &par->tga_chip_rev);
+        if (tga_bus_tc)
+                par->tga_chip_rev = TGA_READ_REG(par, TGA_START_REG) & 0xff;
 
         /* Setup framebuffer.  */
         info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_COPYAREA |
@@ -1414,8 +1638,17 @@ tgafb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent)
         info->pseudo_palette = (void *)(par + 1);
 
         /* This should give a reasonable default video mode.  */
-
-        ret = fb_find_mode(&info->var, info, mode_option, NULL, 0, NULL,
+        if (tga_bus_pci) {
+                mode_option_tga = mode_option_pci;
+        }
+        if (tga_bus_tc) {
+                mode_option_tga = mode_option_tc;
+                modedb_tga = &modedb_tc;
+                modedbsize_tga = 1;
+        }
+        ret = fb_find_mode(&info->var, info,
+                           mode_option ? mode_option : mode_option_tga,
+                           modedb_tga, modedbsize_tga, NULL,
                            tga_type == TGA_TYPE_8PLANE ? 8 : 32);
         if (ret == 0 || ret == 4) {
                 printk(KERN_ERR "tgafb: Could not find valid video mode\n");
@@ -1438,13 +1671,19 @@ tgafb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent)
                 goto err1;
         }
 
-        printk(KERN_INFO "tgafb: DC21030 [TGA] detected, rev=0x%02x\n",
-               par->tga_chip_rev);
-        printk(KERN_INFO "tgafb: at PCI bus %d, device %d, function %d\n",
-               pdev->bus->number, PCI_SLOT(pdev->devfn),
-               PCI_FUNC(pdev->devfn));
-        printk(KERN_INFO "fb%d: %s frame buffer device at 0x%lx\n",
-               info->node, info->fix.id, bar0_start);
+        if (tga_bus_pci) {
+                pr_info("tgafb: DC21030 [TGA] detected, rev=0x%02x\n",
+                        par->tga_chip_rev);
+                pr_info("tgafb: at PCI bus %d, device %d, function %d\n",
+                        to_pci_dev(dev)->bus->number,
+                        PCI_SLOT(to_pci_dev(dev)->devfn),
+                        PCI_FUNC(to_pci_dev(dev)->devfn));
+        }
+        if (tga_bus_tc)
+                pr_info("tgafb: SFB+ detected, rev=0x%02x\n",
+                        par->tga_chip_rev);
+        pr_info("fb%d: %s frame buffer device at 0x%lx\n",
+                info->node, info->fix.id, (long)bar0_start);
 
         return 0;
 
@@ -1458,25 +1697,39 @@ tgafb_pci_register(struct pci_dev *pdev, const struct pci_device_id *ent)
 }
 
 static void __devexit
-tgafb_pci_unregister(struct pci_dev *pdev)
+tgafb_unregister(struct device *dev)
 {
-        struct fb_info *info = pci_get_drvdata(pdev);
-        struct tga_par *par = info->par;
+        resource_size_t bar0_start = 0, bar0_len = 0;
+        int tga_bus_pci = TGA_BUS_PCI(dev);
+        int tga_bus_tc = TGA_BUS_TC(dev);
+        struct fb_info *info = NULL;
+        struct tga_par *par;
 
+        info = dev_get_drvdata(dev);
         if (!info)
                 return;
+
+        par = info->par;
         unregister_framebuffer(info);
         fb_dealloc_cmap(&info->cmap);
         iounmap(par->tga_mem_base);
-        release_mem_region(pci_resource_start(pdev, 0),
-                           pci_resource_len(pdev, 0));
+        if (tga_bus_pci) {
+                bar0_start = pci_resource_start(to_pci_dev(dev), 0);
+                bar0_len = pci_resource_len(to_pci_dev(dev), 0);
+        }
+        if (tga_bus_tc) {
+                bar0_start = to_tc_dev(dev)->resource.start;
+                bar0_len = to_tc_dev(dev)->resource.end - bar0_start + 1;
+        }
+        release_mem_region(bar0_start, bar0_len);
         framebuffer_release(info);
 }
 
 static void __devexit
 tgafb_exit(void)
 {
-        pci_unregister_driver(&tgafb_driver);
+        tc_unregister_driver(&tgafb_tc_driver);
+        pci_unregister_driver(&tgafb_pci_driver);
 }
 
 #ifndef MODULE
@@ -1505,6 +1758,7 @@ tgafb_setup(char *arg)
 static int __devinit
 tgafb_init(void)
 {
+        int status;
 #ifndef MODULE
         char *option = NULL;
 
@@ -1512,7 +1766,10 @@ tgafb_init(void)
                 return -ENODEV;
         tgafb_setup(option);
 #endif
-        return pci_register_driver(&tgafb_driver);
+        status = pci_register_driver(&tgafb_pci_driver);
+        if (!status)
+                status = tc_register_driver(&tgafb_tc_driver);
+        return status;
 }
 
 /*
@@ -1522,5 +1779,5 @@ tgafb_init(void)
 module_init(tgafb_init);
 module_exit(tgafb_exit);
 
-MODULE_DESCRIPTION("framebuffer driver for TGA chipset");
+MODULE_DESCRIPTION("Framebuffer driver for TGA/SFB+ chipset");
 MODULE_LICENSE("GPL");
diff --git a/drivers/video/vermilion/Makefile b/drivers/video/vermilion/Makefile
new file mode 100644
index 000000000000..cc21a656153d
--- /dev/null
+++ b/drivers/video/vermilion/Makefile
@@ -0,0 +1,5 @@
+obj-$(CONFIG_FB_LE80578) += vmlfb.o
+obj-$(CONFIG_FB_CARILLO_RANCH) += crvml.o
+
+vmlfb-objs := vermilion.o
+crvml-objs := cr_pll.o
diff --git a/drivers/video/vermilion/cr_pll.c b/drivers/video/vermilion/cr_pll.c
new file mode 100644
index 000000000000..ebc6e6e0dd0f
--- /dev/null
+++ b/drivers/video/vermilion/cr_pll.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) Intel Corp. 2007.
+ * All Rights Reserved.
+ *
+ * Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
+ * develop this driver.
+ *
+ * This file is part of the Carillo Ranch video subsystem driver.
+ * The Carillo Ranch video subsystem driver 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.
+ *
+ * The Carillo Ranch video subsystem driver is distributed
+ * in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this driver; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Authors:
+ *   Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
+ *   Alan Hourihane <alanh-at-tungstengraphics-dot-com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/errno.h>
+#include <linux/fb.h>
+#include "vermilion.h"
+
+/* The PLL Clock register sits on Host bridge */
+#define CRVML_DEVICE_MCH   0x5001
+#define CRVML_REG_MCHBAR   0x44
+#define CRVML_REG_MCHEN    0x54
+#define CRVML_MCHEN_BIT    (1 << 28)
+#define CRVML_MCHMAP_SIZE  4096
+#define CRVML_REG_CLOCK    0xc3c
+#define CRVML_CLOCK_SHIFT  8
+#define CRVML_CLOCK_MASK   0x00000f00
+
+static struct pci_dev *mch_dev;
+static u32 mch_bar;
+static void __iomem *mch_regs_base;
+static u32 saved_clock;
+
+static const unsigned crvml_clocks[] = {
+        6750,
+        13500,
+        27000,
+        29700,
+        37125,
+        54000,
+        59400,
+        74250,
+        120000
+            /*
+             * There are more clocks, but they are disabled on the CR board.
+             */
+};
+
+static const u32 crvml_clock_bits[] = {
+        0x0a,
+        0x09,
+        0x08,
+        0x07,
+        0x06,
+        0x05,
+        0x04,
+        0x03,
+        0x0b
+};
+
+static const unsigned crvml_num_clocks = ARRAY_SIZE(crvml_clocks);
+
+static int crvml_sys_restore(struct vml_sys *sys)
+{
+        void __iomem *clock_reg = mch_regs_base + CRVML_REG_CLOCK;
+
+        iowrite32(saved_clock, clock_reg);
+        ioread32(clock_reg);
+
+        return 0;
+}
+
+static int crvml_sys_save(struct vml_sys *sys)
+{
+        void __iomem *clock_reg = mch_regs_base + CRVML_REG_CLOCK;
+
+        saved_clock = ioread32(clock_reg);
+
+        return 0;
+}
+
+static int crvml_nearest_index(const struct vml_sys *sys, int clock)
+{
+        int i;
+        int cur_index = 0;
+        int cur_diff;
+        int diff;
+
+        cur_diff = clock - crvml_clocks[0];
+        cur_diff = (cur_diff < 0) ? -cur_diff : cur_diff;
+        for (i = 1; i < crvml_num_clocks; ++i) {
+                diff = clock - crvml_clocks[i];
+                diff = (diff < 0) ? -diff : diff;
+                if (diff < cur_diff) {
+                        cur_index = i;
+                        cur_diff = diff;
+                }
+        }
+        return cur_index;
+}
+
+static int crvml_nearest_clock(const struct vml_sys *sys, int clock)
+{
+        return crvml_clocks[crvml_nearest_index(sys, clock)];
+}
+
+static int crvml_set_clock(struct vml_sys *sys, int clock)
+{
+        void __iomem *clock_reg = mch_regs_base + CRVML_REG_CLOCK;
+        int index;
+        u32 clock_val;
+
+        index = crvml_nearest_index(sys, clock);
+
+        if (crvml_clocks[index] != clock)
+                return -EINVAL;
+
+        clock_val = ioread32(clock_reg) & ~CRVML_CLOCK_MASK;
+        clock_val = crvml_clock_bits[index] << CRVML_CLOCK_SHIFT;
+        iowrite32(clock_val, clock_reg);
+        ioread32(clock_reg);
+
+        return 0;
+}
+
+static struct vml_sys cr_pll_ops = {
+        .name = "Carillo Ranch",
+        .save = crvml_sys_save,
+        .restore = crvml_sys_restore,
+        .set_clock = crvml_set_clock,
+        .nearest_clock = crvml_nearest_clock,
+};
+
+static int __init cr_pll_init(void)
+{
+        int err;
+        u32 dev_en;
+
+        mch_dev = pci_get_device(PCI_VENDOR_ID_INTEL,
+                                        CRVML_DEVICE_MCH, NULL);
+        if (!mch_dev) {
+                printk(KERN_ERR
+                       "Could not find Carillo Ranch MCH device.\n");
+                return -ENODEV;
+        }
+
+        pci_read_config_dword(mch_dev, CRVML_REG_MCHEN, &dev_en);
+        if (!(dev_en & CRVML_MCHEN_BIT)) {
+                printk(KERN_ERR
+                       "Carillo Ranch MCH device was not enabled.\n");
+                pci_dev_put(mch_dev);
+                return -ENODEV;
+        }
+
+        pci_read_config_dword(mch_dev, CRVML_REG_MCHBAR,
+                              &mch_bar);
+        mch_regs_base =
+            ioremap_nocache(mch_bar, CRVML_MCHMAP_SIZE);
+        if (!mch_regs_base) {
+                printk(KERN_ERR
+                       "Carillo Ranch MCH device was not enabled.\n");
+                pci_dev_put(mch_dev);
+                return -ENODEV;
+        }
+
+        err = vmlfb_register_subsys(&cr_pll_ops);
+        if (err) {
+                printk(KERN_ERR
+                       "Carillo Ranch failed to initialize vml_sys.\n");
+                pci_dev_put(mch_dev);
+                return err;
+        }
+
+        return 0;
+}
+
+static void __exit cr_pll_exit(void)
+{
+        vmlfb_unregister_subsys(&cr_pll_ops);
+
+        iounmap(mch_regs_base);
+        pci_dev_put(mch_dev);
+}
+
+module_init(cr_pll_init);
+module_exit(cr_pll_exit);
+
+MODULE_AUTHOR("Tungsten Graphics Inc.");
+MODULE_DESCRIPTION("Carillo Ranch PLL Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/vermilion/vermilion.c b/drivers/video/vermilion/vermilion.c
new file mode 100644
index 000000000000..de531c907718
--- /dev/null
+++ b/drivers/video/vermilion/vermilion.c
@@ -0,0 +1,1195 @@
+/*
+ * Copyright (c) Intel Corp. 2007.
+ * All Rights Reserved.
+ *
+ * Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
+ * develop this driver.
+ *
+ * This file is part of the Vermilion Range fb driver.
+ * The Vermilion Range fb driver 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.
+ *
+ * The Vermilion Range fb driver is distributed
+ * in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this driver; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Authors:
+ *   Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+ *   Michel Dänzer <michel-at-tungstengraphics-dot-com>
+ *   Alan Hourihane <alanh-at-tungstengraphics-dot-com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/delay.h>
+#include <linux/mm.h>
+#include <linux/fb.h>
+#include <linux/pci.h>
+#include <asm/cacheflush.h>
+#include <asm/tlbflush.h>
+#include <linux/mmzone.h>
+#include <asm/uaccess.h>
+
+/* #define VERMILION_DEBUG */
+
+#include "vermilion.h"
+
+#define MODULE_NAME "vmlfb"
+
+#define VML_TOHW(_val, _width) ((((_val) << (_width)) + 0x7FFF - (_val)) >> 16)
+
+static struct mutex vml_mutex;
+static struct list_head global_no_mode;
+static struct list_head global_has_mode;
+static struct fb_ops vmlfb_ops;
+static struct vml_sys *subsys = NULL;
+static char *vml_default_mode = "1024x768@60";
+static struct fb_videomode defaultmode = {
+        NULL, 60, 1024, 768, 12896, 144, 24, 29, 3, 136, 6,
+        0, FB_VMODE_NONINTERLACED
+};
+
+static u32 vml_mem_requested = (10 * 1024 * 1024);
+static u32 vml_mem_contig = (4 * 1024 * 1024);
+static u32 vml_mem_min = (4 * 1024 * 1024);
+
+static u32 vml_clocks[] = {
+        6750,
+        13500,
+        27000,
+        29700,
+        37125,
+        54000,
+        59400,
+        74250,
+        120000,
+        148500
+};
+
+static u32 vml_num_clocks = ARRAY_SIZE(vml_clocks);
+
+/*
+ * Allocate a contiguous vram area and make its linear kernel map
+ * uncached.
+ */
+
+static int vmlfb_alloc_vram_area(struct vram_area *va, unsigned max_order,
+                                 unsigned min_order)
+{
+        gfp_t flags;
+        unsigned long i;
+        pgprot_t wc_pageprot;
+
+        wc_pageprot = PAGE_KERNEL_NOCACHE;
+        max_order++;
+        do {
+                /*
+                 * Really try hard to get the needed memory.
+                 * We need memory below the first 32MB, so we
+                 * add the __GFP_DMA flag that guarantees that we are
+                 * below the first 16MB.
+                 */
+
+                flags = __GFP_DMA | __GFP_HIGH;
+                va->logical =
+                         __get_free_pages(flags, --max_order);
+        } while (va->logical == 0 && max_order > min_order);
+
+        if (!va->logical)
+                return -ENOMEM;
+
+        va->phys = virt_to_phys((void *)va->logical);
+        va->size = PAGE_SIZE << max_order;
+        va->order = max_order;
+
+        /*
+         * It seems like __get_free_pages only ups the usage count
+         * of the first page. This doesn't work with nopage mapping, so
+         * up the usage count once more.
+         */
+
+        memset((void *)va->logical, 0x00, va->size);
+        for (i = va->logical; i < va->logical + va->size; i += PAGE_SIZE) {
+                get_page(virt_to_page(i));
+        }
+
+        /*
+         * Change caching policy of the linear kernel map to avoid
+         * mapping type conflicts with user-space mappings.
+         * The first global_flush_tlb() is really only there to do a global
+         * wbinvd().
+         */
+
+        global_flush_tlb();
+        change_page_attr(virt_to_page(va->logical), va->size >> PAGE_SHIFT,
+                         wc_pageprot);
+        global_flush_tlb();
+
+        printk(KERN_DEBUG MODULE_NAME
+               ": Allocated %ld bytes vram area at 0x%08lx\n",
+               va->size, va->phys);
+
+        return 0;
+}
+
+/*
+ * Free a contiguous vram area and reset its linear kernel map
+ * mapping type.
+ */
+
+static void vmlfb_free_vram_area(struct vram_area *va)
+{
+        unsigned long j;
+
+        if (va->logical) {
+
+                /*
+                 * Reset the linear kernel map caching policy.
+                 */
+
+                change_page_attr(virt_to_page(va->logical),
+                                 va->size >> PAGE_SHIFT, PAGE_KERNEL);
+                global_flush_tlb();
+
+                /*
+                 * Decrease the usage count on the pages we've used
+                 * to compensate for upping when allocating.
+                 */
+
+                for (j = va->logical; j < va->logical + va->size;
+                     j += PAGE_SIZE) {
+                        (void)put_page_testzero(virt_to_page(j));
+                }
+
+                printk(KERN_DEBUG MODULE_NAME
+                       ": Freeing %ld bytes vram area at 0x%08lx\n",
+                       va->size, va->phys);
+                free_pages(va->logical, va->order);
+
+                va->logical = 0;
+        }
+}
+
+/*
+ * Free allocated vram.
+ */
+
+static void vmlfb_free_vram(struct vml_info *vinfo)
+{
+        int i;
+
+        for (i = 0; i < vinfo->num_areas; ++i) {
+                vmlfb_free_vram_area(&vinfo->vram[i]);
+        }
+        vinfo->num_areas = 0;
+}
+
+/*
+ * Allocate vram. Currently we try to allocate contiguous areas from the
+ * __GFP_DMA zone and puzzle them together. A better approach would be to
+ * allocate one contiguous area for scanout and use one-page allocations for
+ * offscreen areas. This requires user-space and GPU virtual mappings.
+ */
+
+static int vmlfb_alloc_vram(struct vml_info *vinfo,
+                            size_t requested,
+                            size_t min_total, size_t min_contig)
+{
+        int i, j;
+        int order;
+        int contiguous;
+        int err;
+        struct vram_area *va;
+        struct vram_area *va2;
+
+        vinfo->num_areas = 0;
+        for (i = 0; i < VML_VRAM_AREAS; ++i) {
+                va = &vinfo->vram[i];
+                order = 0;
+
+                while (requested > (PAGE_SIZE << order) && order < MAX_ORDER)
+                        order++;
+
+                err = vmlfb_alloc_vram_area(va, order, 0);
+
+                if (err)
+                        break;
+
+                if (i == 0) {
+                        vinfo->vram_start = va->phys;
+                        vinfo->vram_logical = (void __iomem *) va->logical;
+                        vinfo->vram_contig_size = va->size;
+                        vinfo->num_areas = 1;
+                } else {
+                        contiguous = 0;
+
+                        for (j = 0; j < i; ++j) {
+                                va2 = &vinfo->vram[j];
+                                if (va->phys + va->size == va2->phys ||
+                                    va2->phys + va2->size == va->phys) {
+                                        contiguous = 1;
+                                        break;
+                                }
+                        }
+
+                        if (contiguous) {
+                                vinfo->num_areas++;
+                                if (va->phys < vinfo->vram_start) {
+                                        vinfo->vram_start = va->phys;
+                                        vinfo->vram_logical =
+                                                (void __iomem *)va->logical;
+                                }
+                                vinfo->vram_contig_size += va->size;
+                        } else {
+                                vmlfb_free_vram_area(va);
+                                break;
+                        }
+                }
+
+                if (requested < va->size)
+                        break;
+                else
+                        requested -= va->size;
+        }
+
+        if (vinfo->vram_contig_size > min_total &&
+            vinfo->vram_contig_size > min_contig) {
+
+                printk(KERN_DEBUG MODULE_NAME
+                       ": Contiguous vram: %ld bytes at physical 0x%08lx.\n",
+                       (unsigned long)vinfo->vram_contig_size,
+                       (unsigned long)vinfo->vram_start);
+
+                return 0;
+        }
+
+        printk(KERN_ERR MODULE_NAME
+               ": Could not allocate requested minimal amount of vram.\n");
+
+        vmlfb_free_vram(vinfo);
+
+        return -ENOMEM;
+}
+
+/*
+ * Find the GPU to use with our display controller.
+ */
+
+static int vmlfb_get_gpu(struct vml_par *par)
+{
+        mutex_lock(&vml_mutex);
+
+        par->gpu = pci_get_device(PCI_VENDOR_ID_INTEL, VML_DEVICE_GPU, NULL);
+
+        if (!par->gpu) {
+                mutex_unlock(&vml_mutex);
+                return -ENODEV;
+        }
+
+        mutex_unlock(&vml_mutex);
+
+        if (pci_enable_device(par->gpu) < 0)
+                return -ENODEV;
+
+        return 0;
+}
+
+/*
+ * Find a contiguous vram area that contains a given offset from vram start.
+ */
+static int vmlfb_vram_offset(struct vml_info *vinfo, unsigned long offset)
+{
+        unsigned long aoffset;
+        unsigned i;
+
+        for (i = 0; i < vinfo->num_areas; ++i) {
+                aoffset = offset - (vinfo->vram[i].phys - vinfo->vram_start);
+
+                if (aoffset < vinfo->vram[i].size) {
+                        return 0;
+                }
+        }
+
+        return -EINVAL;
+}
+
+/*
+ * Remap the MMIO register spaces of the VDC and the GPU.
+ */
+
+static int vmlfb_enable_mmio(struct vml_par *par)
+{
+        int err;
+
+        par->vdc_mem_base = pci_resource_start(par->vdc, 0);
+        par->vdc_mem_size = pci_resource_len(par->vdc, 0);
+        if (!request_mem_region(par->vdc_mem_base, par->vdc_mem_size, "vmlfb")) {
+                printk(KERN_ERR MODULE_NAME
+                       ": Could not claim display controller MMIO.\n");
+                return -EBUSY;
+        }
+        par->vdc_mem = ioremap_nocache(par->vdc_mem_base, par->vdc_mem_size);
+        if (par->vdc_mem == NULL) {
+                printk(KERN_ERR MODULE_NAME
+                       ": Could not map display controller MMIO.\n");
+                err = -ENOMEM;
+                goto out_err_0;
+        }
+
+        par->gpu_mem_base = pci_resource_start(par->gpu, 0);
+        par->gpu_mem_size = pci_resource_len(par->gpu, 0);
+        if (!request_mem_region(par->gpu_mem_base, par->gpu_mem_size, "vmlfb")) {
+                printk(KERN_ERR MODULE_NAME ": Could not claim GPU MMIO.\n");
+                err = -EBUSY;
+                goto out_err_1;
+        }
+        par->gpu_mem = ioremap_nocache(par->gpu_mem_base, par->gpu_mem_size);
+        if (par->gpu_mem == NULL) {
+                printk(KERN_ERR MODULE_NAME ": Could not map GPU MMIO.\n");
+                err = -ENOMEM;
+                goto out_err_2;
+        }
+
+        return 0;
+
+out_err_2:
+        release_mem_region(par->gpu_mem_base, par->gpu_mem_size);
+out_err_1:
+        iounmap(par->vdc_mem);
+out_err_0:
+        release_mem_region(par->vdc_mem_base, par->vdc_mem_size);
+        return err;
+}
+
+/*
+ * Unmap the VDC and GPU register spaces.
+ */
+
+static void vmlfb_disable_mmio(struct vml_par *par)
+{
+        iounmap(par->gpu_mem);
+        release_mem_region(par->gpu_mem_base, par->gpu_mem_size);
+        iounmap(par->vdc_mem);
+        release_mem_region(par->vdc_mem_base, par->vdc_mem_size);
+}
+
+/*
+ * Release and uninit the VDC and GPU.
+ */
+
+static void vmlfb_release_devices(struct vml_par *par)
+{
+        if (atomic_dec_and_test(&par->refcount)) {
+                pci_set_drvdata(par->vdc, NULL);
+                pci_disable_device(par->gpu);
+                pci_disable_device(par->vdc);
+        }
+}
+
+/*
+ * Free up allocated resources for a device.
+ */
+
+static void __devexit vml_pci_remove(struct pci_dev *dev)
+{
+        struct fb_info *info;
+        struct vml_info *vinfo;
+        struct vml_par *par;
+
+        info = pci_get_drvdata(dev);
+        if (info) {
+                vinfo = container_of(info, struct vml_info, info);
+                par = vinfo->par;
+                mutex_lock(&vml_mutex);
+                unregister_framebuffer(info);
+                fb_dealloc_cmap(&info->cmap);
+                vmlfb_free_vram(vinfo);
+                vmlfb_disable_mmio(par);
+                vmlfb_release_devices(par);
+                kfree(vinfo);
+                kfree(par);
+                mutex_unlock(&vml_mutex);
+        }
+}
+
+static void vmlfb_set_pref_pixel_format(struct fb_var_screeninfo *var)
+{
+        switch (var->bits_per_pixel) {
+        case 16:
+                var->blue.offset = 0;
+                var->blue.length = 5;
+                var->green.offset = 5;
+                var->green.length = 5;
+                var->red.offset = 10;
+                var->red.length = 5;
+                var->transp.offset = 15;
+                var->transp.length = 1;
+                break;
+        case 32:
+                var->blue.offset = 0;
+                var->blue.length = 8;
+                var->green.offset = 8;
+                var->green.length = 8;
+                var->red.offset = 16;
+                var->red.length = 8;
+                var->transp.offset = 24;
+                var->transp.length = 0;
+                break;
+        default:
+                break;
+        }
+
+        var->blue.msb_right = var->green.msb_right =
+            var->red.msb_right = var->transp.msb_right = 0;
+}
+
+/*
+ * Device initialization.
+ * We initialize one vml_par struct per device and one vml_info
+ * struct per pipe. Currently we have only one pipe.
+ */
+
+static int __devinit vml_pci_probe(struct pci_dev *dev,
+                                   const struct pci_device_id *id)
+{
+        struct vml_info *vinfo;
+        struct fb_info *info;
+        struct vml_par *par;
+        int err = 0;
+
+        par = kzalloc(sizeof(*par), GFP_KERNEL);
+        if (par == NULL)
+                return -ENOMEM;
+
+        vinfo = kzalloc(sizeof(*vinfo), GFP_KERNEL);
+        if (vinfo == NULL) {
+                err = -ENOMEM;
+                goto out_err_0;
+        }
+
+        vinfo->par = par;
+        par->vdc = dev;
+        atomic_set(&par->refcount, 1);
+
+        switch (id->device) {
+        case VML_DEVICE_VDC:
+                if ((err = vmlfb_get_gpu(par)))
+                        goto out_err_1;
+                pci_set_drvdata(dev, &vinfo->info);
+                break;
+        default:
+                err = -ENODEV;
+                goto out_err_1;
+                break;
+        }
+
+        info = &vinfo->info;
+        info->flags = FBINFO_DEFAULT | FBINFO_PARTIAL_PAN_OK;
+
+        err = vmlfb_enable_mmio(par);
+        if (err)
+                goto out_err_2;
+
+        err = vmlfb_alloc_vram(vinfo, vml_mem_requested,
+                               vml_mem_contig, vml_mem_min);
+        if (err)
+                goto out_err_3;
+
+        strcpy(info->fix.id, "Vermilion Range");
+        info->fix.mmio_start = 0;
+        info->fix.mmio_len = 0;
+        info->fix.smem_start = vinfo->vram_start;
+        info->fix.smem_len = vinfo->vram_contig_size;
+        info->fix.type = FB_TYPE_PACKED_PIXELS;
+        info->fix.visual = FB_VISUAL_TRUECOLOR;
+        info->fix.ypanstep = 1;
+        info->fix.xpanstep = 1;
+        info->fix.ywrapstep = 0;
+        info->fix.accel = FB_ACCEL_NONE;
+        info->screen_base = vinfo->vram_logical;
+        info->pseudo_palette = vinfo->pseudo_palette;
+        info->par = par;
+        info->fbops = &vmlfb_ops;
+        info->device = &dev->dev;
+
+        INIT_LIST_HEAD(&vinfo->head);
+        vinfo->pipe_disabled = 1;
+        vinfo->cur_blank_mode = FB_BLANK_UNBLANK;
+
+        info->var.grayscale = 0;
+        info->var.bits_per_pixel = 16;
+        vmlfb_set_pref_pixel_format(&info->var);
+
+        if (!fb_find_mode
+            (&info->var, info, vml_default_mode, NULL, 0, &defaultmode, 16)) {
+                printk(KERN_ERR MODULE_NAME ": Could not find initial mode\n");
+        }
+
+        if (fb_alloc_cmap(&info->cmap, 256, 1) < 0) {
+                err = -ENOMEM;
+                goto out_err_4;
+        }
+
+        err = register_framebuffer(info);
+        if (err) {
+                printk(KERN_ERR MODULE_NAME ": Register framebuffer error.\n");
+                goto out_err_5;
+        }
+
+        printk("Initialized vmlfb\n");
+
+        return 0;
+
+out_err_5:
+        fb_dealloc_cmap(&info->cmap);
+out_err_4:
+        vmlfb_free_vram(vinfo);
+out_err_3:
+        vmlfb_disable_mmio(par);
+out_err_2:
+        vmlfb_release_devices(par);
+out_err_1:
+        kfree(vinfo);
+out_err_0:
+        kfree(par);
+        return err;
+}
+
+static int vmlfb_open(struct fb_info *info, int user)
+{
+        /*
+         * Save registers here?
+         */
+        return 0;
+}
+
+static int vmlfb_release(struct fb_info *info, int user)
+{
+        /*
+         * Restore registers here.
+         */
+
+        return 0;
+}
+
+static int vml_nearest_clock(int clock)
+{
+
+        int i;
+        int cur_index;
+        int cur_diff;
+        int diff;
+
+        cur_index = 0;
+        cur_diff = clock - vml_clocks[0];
+        cur_diff = (cur_diff < 0) ? -cur_diff : cur_diff;
+        for (i = 1; i < vml_num_clocks; ++i) {
+                diff = clock - vml_clocks[i];
+                diff = (diff < 0) ? -diff : diff;
+                if (diff < cur_diff) {
+                        cur_index = i;
+                        cur_diff = diff;
+                }
+        }
+        return vml_clocks[cur_index];
+}
+
+static int vmlfb_check_var_locked(struct fb_var_screeninfo *var,
+                                  struct vml_info *vinfo)
+{
+        u32 pitch;
+        u64 mem;
+        int nearest_clock;
+        int clock;
+        int clock_diff;
+        struct fb_var_screeninfo v;
+
+        v = *var;
+        clock = PICOS2KHZ(var->pixclock);
+
+        if (subsys && subsys->nearest_clock) {
+                nearest_clock = subsys->nearest_clock(subsys, clock);
+        } else {
+                nearest_clock = vml_nearest_clock(clock);
+        }
+
+        /*
+         * Accept a 20% diff.
+         */
+
+        clock_diff = nearest_clock - clock;
+        clock_diff = (clock_diff < 0) ? -clock_diff : clock_diff;
+        if (clock_diff > clock / 5) {
+#if 0
+                printk(KERN_DEBUG MODULE_NAME ": Diff failure. %d %d\n",clock_diff,clock);
+#endif
+                return -EINVAL;
+        }
+
+        v.pixclock = KHZ2PICOS(nearest_clock);
+
+        if (var->xres > VML_MAX_XRES || var->yres > VML_MAX_YRES) {
+                printk(KERN_DEBUG MODULE_NAME ": Resolution failure.\n");
+                return -EINVAL;
+        }
+        if (var->xres_virtual > VML_MAX_XRES_VIRTUAL) {
+                printk(KERN_DEBUG MODULE_NAME
+                       ": Virtual resolution failure.\n");
+                return -EINVAL;
+        }
+        switch (v.bits_per_pixel) {
+        case 0 ... 16:
+                v.bits_per_pixel = 16;
+                break;
+        case 17 ... 32:
+                v.bits_per_pixel = 32;
+                break;
+        default:
+                printk(KERN_DEBUG MODULE_NAME ": Invalid bpp: %d.\n",
+                       var->bits_per_pixel);
+                return -EINVAL;
+        }
+
+        pitch = __ALIGN_MASK((var->xres * var->bits_per_pixel) >> 3, 0x3F);
+        mem = pitch * var->yres_virtual;
+        if (mem > vinfo->vram_contig_size) {
+                return -ENOMEM;
+        }
+
+        switch (v.bits_per_pixel) {
+        case 16:
+                if (var->blue.offset != 0 ||
+                    var->blue.length != 5 ||
+                    var->green.offset != 5 ||
+                    var->green.length != 5 ||
+                    var->red.offset != 10 ||
+                    var->red.length != 5 ||
+                    var->transp.offset != 15 || var->transp.length != 1) {
+                        vmlfb_set_pref_pixel_format(&v);
+                }
+                break;
+        case 32:
+                if (var->blue.offset != 0 ||
+                    var->blue.length != 8 ||
+                    var->green.offset != 8 ||
+                    var->green.length != 8 ||
+                    var->red.offset != 16 ||
+                    var->red.length != 8 ||
+                    (var->transp.length != 0 && var->transp.length != 8) ||
+                    (var->transp.length == 8 && var->transp.offset != 24)) {
+                        vmlfb_set_pref_pixel_format(&v);
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        *var = v;
+
+        return 0;
+}
+
+static int vmlfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+        struct vml_info *vinfo = container_of(info, struct vml_info, info);
+        int ret;
+
+        mutex_lock(&vml_mutex);
+        ret = vmlfb_check_var_locked(var, vinfo);
+        mutex_unlock(&vml_mutex);
+
+        return ret;
+}
+
+static void vml_wait_vblank(struct vml_info *vinfo)
+{
+        /* Wait for vblank. For now, just wait for a 50Hz cycle (20ms)) */
+        mdelay(20);
+}
+
+static void vmlfb_disable_pipe(struct vml_info *vinfo)
+{
+        struct vml_par *par = vinfo->par;
+
+        /* Disable the MDVO pad */
+        VML_WRITE32(par, VML_RCOMPSTAT, 0);
+        while (!(VML_READ32(par, VML_RCOMPSTAT) & VML_MDVO_VDC_I_RCOMP)) ;
+
+        /* Disable display planes */
+        VML_WRITE32(par, VML_DSPCCNTR,
+                    VML_READ32(par, VML_DSPCCNTR) & ~VML_GFX_ENABLE);
+        (void)VML_READ32(par, VML_DSPCCNTR);
+        /* Wait for vblank for the disable to take effect */
+        vml_wait_vblank(vinfo);
+
+        /* Next, disable display pipes */
+        VML_WRITE32(par, VML_PIPEACONF, 0);
+        (void)VML_READ32(par, VML_PIPEACONF);
+
+        vinfo->pipe_disabled = 1;
+}
+
+#ifdef VERMILION_DEBUG
+static void vml_dump_regs(struct vml_info *vinfo)
+{
+        struct vml_par *par = vinfo->par;
+
+        printk(KERN_DEBUG MODULE_NAME ": Modesetting register dump:\n");
+        printk(KERN_DEBUG MODULE_NAME ": \tHTOTAL_A         : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_HTOTAL_A));
+        printk(KERN_DEBUG MODULE_NAME ": \tHBLANK_A         : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_HBLANK_A));
+        printk(KERN_DEBUG MODULE_NAME ": \tHSYNC_A          : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_HSYNC_A));
+        printk(KERN_DEBUG MODULE_NAME ": \tVTOTAL_A         : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_VTOTAL_A));
+        printk(KERN_DEBUG MODULE_NAME ": \tVBLANK_A         : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_VBLANK_A));
+        printk(KERN_DEBUG MODULE_NAME ": \tVSYNC_A          : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_VSYNC_A));
+        printk(KERN_DEBUG MODULE_NAME ": \tDSPCSTRIDE       : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_DSPCSTRIDE));
+        printk(KERN_DEBUG MODULE_NAME ": \tDSPCSIZE         : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_DSPCSIZE));
+        printk(KERN_DEBUG MODULE_NAME ": \tDSPCPOS          : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_DSPCPOS));
+        printk(KERN_DEBUG MODULE_NAME ": \tDSPARB           : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_DSPARB));
+        printk(KERN_DEBUG MODULE_NAME ": \tDSPCADDR         : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_DSPCADDR));
+        printk(KERN_DEBUG MODULE_NAME ": \tBCLRPAT_A        : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_BCLRPAT_A));
+        printk(KERN_DEBUG MODULE_NAME ": \tCANVSCLR_A       : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_CANVSCLR_A));
+        printk(KERN_DEBUG MODULE_NAME ": \tPIPEASRC         : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_PIPEASRC));
+        printk(KERN_DEBUG MODULE_NAME ": \tPIPEACONF        : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_PIPEACONF));
+        printk(KERN_DEBUG MODULE_NAME ": \tDSPCCNTR         : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_DSPCCNTR));
+        printk(KERN_DEBUG MODULE_NAME ": \tRCOMPSTAT        : 0x%08x\n",
+               (unsigned)VML_READ32(par, VML_RCOMPSTAT));
+        printk(KERN_DEBUG MODULE_NAME ": End of modesetting register dump.\n");
+}
+#endif
+
+static int vmlfb_set_par_locked(struct vml_info *vinfo)
+{
+        struct vml_par *par = vinfo->par;
+        struct fb_info *info = &vinfo->info;
+        struct fb_var_screeninfo *var = &info->var;
+        u32 htotal, hactive, hblank_start, hblank_end, hsync_start, hsync_end;
+        u32 vtotal, vactive, vblank_start, vblank_end, vsync_start, vsync_end;
+        u32 dspcntr;
+        int clock;
+
+        vinfo->bytes_per_pixel = var->bits_per_pixel >> 3;
+        vinfo->stride =
+            __ALIGN_MASK(var->xres_virtual * vinfo->bytes_per_pixel, 0x3F);
+        info->fix.line_length = vinfo->stride;
+
+        if (!subsys)
+                return 0;
+
+        htotal =
+            var->xres + var->right_margin + var->hsync_len + var->left_margin;
+        hactive = var->xres;
+        hblank_start = var->xres;
+        hblank_end = htotal;
+        hsync_start = hactive + var->right_margin;
+        hsync_end = hsync_start + var->hsync_len;
+
+        vtotal =
+            var->yres + var->lower_margin + var->vsync_len + var->upper_margin;
+        vactive = var->yres;
+        vblank_start = var->yres;
+        vblank_end = vtotal;
+        vsync_start = vactive + var->lower_margin;
+        vsync_end = vsync_start + var->vsync_len;
+
+        dspcntr = VML_GFX_ENABLE | VML_GFX_GAMMABYPASS;
+        clock = PICOS2KHZ(var->pixclock);
+
+        if (subsys->nearest_clock) {
+                clock = subsys->nearest_clock(subsys, clock);
+        } else {
+                clock = vml_nearest_clock(clock);
+        }
+        printk(KERN_DEBUG MODULE_NAME
+               ": Set mode Hfreq : %d kHz, Vfreq : %d Hz.\n", clock / htotal,
+               ((clock / htotal) * 1000) / vtotal);
+
+        switch (var->bits_per_pixel) {
+        case 16:
+                dspcntr |= VML_GFX_ARGB1555;
+                break;
+        case 32:
+                if (var->transp.length == 8)
+                        dspcntr |= VML_GFX_ARGB8888 | VML_GFX_ALPHAMULT;
+                else
+                        dspcntr |= VML_GFX_RGB0888;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        vmlfb_disable_pipe(vinfo);
+        mb();
+
+        if (subsys->set_clock)
+                subsys->set_clock(subsys, clock);
+        else
+                return -EINVAL;
+
+        VML_WRITE32(par, VML_HTOTAL_A, ((htotal - 1) << 16) | (hactive - 1));
+        VML_WRITE32(par, VML_HBLANK_A,
+                    ((hblank_end - 1) << 16) | (hblank_start - 1));
+        VML_WRITE32(par, VML_HSYNC_A,
+                    ((hsync_end - 1) << 16) | (hsync_start - 1));
+        VML_WRITE32(par, VML_VTOTAL_A, ((vtotal - 1) << 16) | (vactive - 1));
+        VML_WRITE32(par, VML_VBLANK_A,
+                    ((vblank_end - 1) << 16) | (vblank_start - 1));
+        VML_WRITE32(par, VML_VSYNC_A,
+                    ((vsync_end - 1) << 16) | (vsync_start - 1));
+        VML_WRITE32(par, VML_DSPCSTRIDE, vinfo->stride);
+        VML_WRITE32(par, VML_DSPCSIZE,
+                    ((var->yres - 1) << 16) | (var->xres - 1));
+        VML_WRITE32(par, VML_DSPCPOS, 0x00000000);
+        VML_WRITE32(par, VML_DSPARB, VML_FIFO_DEFAULT);
+        VML_WRITE32(par, VML_BCLRPAT_A, 0x00000000);
+        VML_WRITE32(par, VML_CANVSCLR_A, 0x00000000);
+        VML_WRITE32(par, VML_PIPEASRC,
+                    ((var->xres - 1) << 16) | (var->yres - 1));
+
+        wmb();
+        VML_WRITE32(par, VML_PIPEACONF, VML_PIPE_ENABLE);
+        wmb();
+        VML_WRITE32(par, VML_DSPCCNTR, dspcntr);
+        wmb();
+        VML_WRITE32(par, VML_DSPCADDR, (u32) vinfo->vram_start +
+                    var->yoffset * vinfo->stride +
+                    var->xoffset * vinfo->bytes_per_pixel);
+
+        VML_WRITE32(par, VML_RCOMPSTAT, VML_MDVO_PAD_ENABLE);
+
+        while (!(VML_READ32(par, VML_RCOMPSTAT) &
+                 (VML_MDVO_VDC_I_RCOMP | VML_MDVO_PAD_ENABLE))) ;
+
+        vinfo->pipe_disabled = 0;
+#ifdef VERMILION_DEBUG
+        vml_dump_regs(vinfo);
+#endif
+
+        return 0;
+}
+
+static int vmlfb_set_par(struct fb_info *info)
+{
+        struct vml_info *vinfo = container_of(info, struct vml_info, info);
+        int ret;
+
+        mutex_lock(&vml_mutex);
+        list_del(&vinfo->head);
+        list_add(&vinfo->head, (subsys) ? &global_has_mode : &global_no_mode);
+        ret = vmlfb_set_par_locked(vinfo);
+
+        mutex_unlock(&vml_mutex);
+        return ret;
+}
+
+static int vmlfb_blank_locked(struct vml_info *vinfo)
+{
+        struct vml_par *par = vinfo->par;
+        u32 cur = VML_READ32(par, VML_PIPEACONF);
+
+        switch (vinfo->cur_blank_mode) {
+        case FB_BLANK_UNBLANK:
+                if (vinfo->pipe_disabled) {
+                        vmlfb_set_par_locked(vinfo);
+                }
+                VML_WRITE32(par, VML_PIPEACONF, cur & ~VML_PIPE_FORCE_BORDER);
+                (void)VML_READ32(par, VML_PIPEACONF);
+                break;
+        case FB_BLANK_NORMAL:
+                if (vinfo->pipe_disabled) {
+                        vmlfb_set_par_locked(vinfo);
+                }
+                VML_WRITE32(par, VML_PIPEACONF, cur | VML_PIPE_FORCE_BORDER);
+                (void)VML_READ32(par, VML_PIPEACONF);
+                break;
+        case FB_BLANK_VSYNC_SUSPEND:
+        case FB_BLANK_HSYNC_SUSPEND:
+                if (!vinfo->pipe_disabled) {
+                        vmlfb_disable_pipe(vinfo);
+                }
+                break;
+        case FB_BLANK_POWERDOWN:
+                if (!vinfo->pipe_disabled) {
+                        vmlfb_disable_pipe(vinfo);
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vmlfb_blank(int blank_mode, struct fb_info *info)
+{
+        struct vml_info *vinfo = container_of(info, struct vml_info, info);
+        int ret;
+
+        mutex_lock(&vml_mutex);
+        vinfo->cur_blank_mode = blank_mode;
+        ret = vmlfb_blank_locked(vinfo);
+        mutex_unlock(&vml_mutex);
+        return ret;
+}
+
+static int vmlfb_pan_display(struct fb_var_screeninfo *var,
+                             struct fb_info *info)
+{
+        struct vml_info *vinfo = container_of(info, struct vml_info, info);
+        struct vml_par *par = vinfo->par;
+
+        mutex_lock(&vml_mutex);
+        VML_WRITE32(par, VML_DSPCADDR, (u32) vinfo->vram_start +
+                    var->yoffset * vinfo->stride +
+                    var->xoffset * vinfo->bytes_per_pixel);
+        (void)VML_READ32(par, VML_DSPCADDR);
+        mutex_unlock(&vml_mutex);
+
+        return 0;
+}
+
+static int vmlfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
+                           u_int transp, struct fb_info *info)
+{
+        u32 v;
+
+        if (regno >= 16)
+                return -EINVAL;
+
+        if (info->var.grayscale) {
+                red = green = blue = (red * 77 + green * 151 + blue * 28) >> 8;
+        }
+
+        if (info->fix.visual != FB_VISUAL_TRUECOLOR)
+                return -EINVAL;
+
+        red = VML_TOHW(red, info->var.red.length);
+        blue = VML_TOHW(blue, info->var.blue.length);
+        green = VML_TOHW(green, info->var.green.length);
+        transp = VML_TOHW(transp, info->var.transp.length);
+
+        v = (red << info->var.red.offset) |
+            (green << info->var.green.offset) |
+            (blue << info->var.blue.offset) |
+            (transp << info->var.transp.offset);
+
+        switch (info->var.bits_per_pixel) {
+        case 16:
+                ((u32 *) info->pseudo_palette)[regno] = v;
+                break;
+        case 24:
+        case 32:
+                ((u32 *) info->pseudo_palette)[regno] = v;
+                break;
+        }
+        return 0;
+}
+
+static int vmlfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
+{
+        struct vml_info *vinfo = container_of(info, struct vml_info, info);
+        unsigned long size = vma->vm_end - vma->vm_start;
+        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
+        int ret;
+
+        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
+                return -EINVAL;
+        if (offset + size > vinfo->vram_contig_size)
+                return -EINVAL;
+        ret = vmlfb_vram_offset(vinfo, offset);
+        if (ret)
+                return -EINVAL;
+        offset += vinfo->vram_start;
+        pgprot_val(vma->vm_page_prot) |= _PAGE_PCD;
+        pgprot_val(vma->vm_page_prot) &= ~_PAGE_PWT;
+        vma->vm_flags |= VM_RESERVED | VM_IO;
+        if (remap_pfn_range(vma, vma->vm_start, offset >> PAGE_SHIFT,
+                                                size, vma->vm_page_prot))
+                return -EAGAIN;
+        return 0;
+}
+
+static int vmlfb_sync(struct fb_info *info)
+{
+        return 0;
+}
+
+static int vmlfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
+{
+        return -EINVAL; /* just to force soft_cursor() call */
+}
+
+static struct fb_ops vmlfb_ops = {
+        .owner = THIS_MODULE,
+        .fb_open = vmlfb_open,
+        .fb_release = vmlfb_release,
+        .fb_check_var = vmlfb_check_var,
+        .fb_set_par = vmlfb_set_par,
+        .fb_blank = vmlfb_blank,
+        .fb_pan_display = vmlfb_pan_display,
+        .fb_fillrect = cfb_fillrect,
+        .fb_copyarea = cfb_copyarea,
+        .fb_imageblit = cfb_imageblit,
+        .fb_cursor = vmlfb_cursor,
+        .fb_sync = vmlfb_sync,
+        .fb_mmap = vmlfb_mmap,
+        .fb_setcolreg = vmlfb_setcolreg
+};
+
+static struct pci_device_id vml_ids[] = {
+        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, VML_DEVICE_VDC)},
+        {0}
+};
+
+static struct pci_driver vmlfb_pci_driver = {
+        .name = "vmlfb",
+        .id_table = vml_ids,
+        .probe = vml_pci_probe,
+        .remove = __devexit_p(vml_pci_remove)
+};
+
+static void __exit vmlfb_cleanup(void)
+{
+        pci_unregister_driver(&vmlfb_pci_driver);
+}
+
+static int __init vmlfb_init(void)
+{
+
+#ifndef MODULE
+        char *option = NULL;
+
+        if (fb_get_options(MODULE_NAME, &option))
+                return -ENODEV;
+#endif
+
+        printk(KERN_DEBUG MODULE_NAME ": initializing\n");
+        mutex_init(&vml_mutex);
+        INIT_LIST_HEAD(&global_no_mode);
+        INIT_LIST_HEAD(&global_has_mode);
+
+        return pci_register_driver(&vmlfb_pci_driver);
+}
+
+int vmlfb_register_subsys(struct vml_sys *sys)
+{
+        struct vml_info *entry;
+        struct list_head *list;
+        u32 save_activate;
+
+        mutex_lock(&vml_mutex);
+        if (subsys != NULL) {
+                subsys->restore(subsys);
+        }
+        subsys = sys;
+        subsys->save(subsys);
+
+        /*
+         * We need to restart list traversal for each item, since we
+         * release the list mutex in the loop.
+         */
+
+        list = global_no_mode.next;
+        while (list != &global_no_mode) {
+                list_del_init(list);
+                entry = list_entry(list, struct vml_info, head);
+
+                /*
+                 * First, try the current mode which might not be
+                 * completely validated with respect to the pixel clock.
+                 */
+
+                if (!vmlfb_check_var_locked(&entry->info.var, entry)) {
+                        vmlfb_set_par_locked(entry);
+                        list_add_tail(list, &global_has_mode);
+                } else {
+
+                        /*
+                         * Didn't work. Try to find another mode,
+                         * that matches this subsys.
+                         */
+
+                        mutex_unlock(&vml_mutex);
+                        save_activate = entry->info.var.activate;
+                        entry->info.var.bits_per_pixel = 16;
+                        vmlfb_set_pref_pixel_format(&entry->info.var);
+                        if (fb_find_mode(&entry->info.var,
+                                         &entry->info,
+                                         vml_default_mode, NULL, 0, NULL, 16)) {
+                                entry->info.var.activate |=
+                                    FB_ACTIVATE_FORCE | FB_ACTIVATE_NOW;
+                                fb_set_var(&entry->info, &entry->info.var);
+                        } else {
+                                printk(KERN_ERR MODULE_NAME
+                                       ": Sorry. no mode found for this subsys.\n");
+                        }
+                        entry->info.var.activate = save_activate;
+                        mutex_lock(&vml_mutex);
+                }
+                vmlfb_blank_locked(entry);
+                list = global_no_mode.next;
+        }
+        mutex_unlock(&vml_mutex);
+
+        printk(KERN_DEBUG MODULE_NAME ": Registered %s subsystem.\n",
+                                subsys->name ? subsys->name : "unknown");
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(vmlfb_register_subsys);
+
+void vmlfb_unregister_subsys(struct vml_sys *sys)
+{
+        struct vml_info *entry, *next;
+
+        mutex_lock(&vml_mutex);
+        if (subsys != sys) {
+                mutex_unlock(&vml_mutex);
+                return;
+        }
+        subsys->restore(subsys);
+        subsys = NULL;
+        list_for_each_entry_safe(entry, next, &global_has_mode, head) {
+                printk(KERN_DEBUG MODULE_NAME ": subsys disable pipe\n");
+                vmlfb_disable_pipe(entry);
+                list_del(&entry->head);
+                list_add_tail(&entry->head, &global_no_mode);
+        }
+        mutex_unlock(&vml_mutex);
+}
+
+EXPORT_SYMBOL_GPL(vmlfb_unregister_subsys);
+
+module_init(vmlfb_init);
+module_exit(vmlfb_cleanup);
+
+MODULE_AUTHOR("Tungsten Graphics");
+MODULE_DESCRIPTION("Initialization of the Vermilion display devices");
+MODULE_VERSION("1.0.0");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/vermilion/vermilion.h b/drivers/video/vermilion/vermilion.h
new file mode 100644
index 000000000000..1fc6695a49d2
--- /dev/null
+++ b/drivers/video/vermilion/vermilion.h
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) Intel Corp. 2007.
+ * All Rights Reserved.
+ *
+ * Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
+ * develop this driver.
+ *
+ * This file is part of the Vermilion Range fb driver.
+ * The Vermilion Range fb driver 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.
+ *
+ * The Vermilion Range fb driver is distributed
+ * in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this driver; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Authors:
+ *   Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+ */
+
+#ifndef _VERMILION_H_
+#define _VERMILION_H_
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/pci.h>
+#include <asm/atomic.h>
+#include <linux/mutex.h>
+
+#define VML_DEVICE_GPU 0x5002
+#define VML_DEVICE_VDC 0x5009
+
+#define VML_VRAM_AREAS 3
+#define VML_MAX_XRES 1024
+#define VML_MAX_YRES 768
+#define VML_MAX_XRES_VIRTUAL 1040
+
+/*
+ * Display controller registers:
+ */
+
+/* Display controller 10-bit color representation */
+
+#define VML_R_MASK                   0x3FF00000
+#define VML_R_SHIFT                  20
+#define VML_G_MASK                   0x000FFC00
+#define VML_G_SHIFT                  10
+#define VML_B_MASK                   0x000003FF
+#define VML_B_SHIFT                  0
+
+/* Graphics plane control */
+#define VML_DSPCCNTR                 0x00072180
+#define VML_GFX_ENABLE               0x80000000
+#define VML_GFX_GAMMABYPASS          0x40000000
+#define VML_GFX_ARGB1555             0x0C000000
+#define VML_GFX_RGB0888              0x18000000
+#define VML_GFX_ARGB8888             0x1C000000
+#define VML_GFX_ALPHACONST           0x02000000
+#define VML_GFX_ALPHAMULT            0x01000000
+#define VML_GFX_CONST_ALPHA          0x000000FF
+
+/* Graphics plane start address. Pixel aligned. */
+#define VML_DSPCADDR                 0x00072184
+
+/* Graphics plane stride register. */
+#define VML_DSPCSTRIDE               0x00072188
+
+/* Graphics plane position register. */
+#define VML_DSPCPOS                  0x0007218C
+#define VML_POS_YMASK                0x0FFF0000
+#define VML_POS_YSHIFT               16
+#define VML_POS_XMASK                0x00000FFF
+#define VML_POS_XSHIFT               0
+
+/* Graphics plane height and width */
+#define VML_DSPCSIZE                 0x00072190
+#define VML_SIZE_HMASK               0x0FFF0000
+#define VML_SIZE_HSHIFT              16
+#define VML_SISE_WMASK               0x00000FFF
+#define VML_SIZE_WSHIFT              0
+
+/* Graphics plane gamma correction lookup table registers (129 * 32 bits) */
+#define VML_DSPCGAMLUT               0x00072200
+
+/* Pixel video output configuration register */
+#define VML_PVOCONFIG                0x00061140
+#define VML_CONFIG_BASE              0x80000000
+#define VML_CONFIG_PIXEL_SWAP        0x04000000
+#define VML_CONFIG_DE_INV            0x01000000
+#define VML_CONFIG_HREF_INV          0x00400000
+#define VML_CONFIG_VREF_INV          0x00100000
+#define VML_CONFIG_CLK_INV           0x00040000
+#define VML_CONFIG_CLK_DIV2          0x00010000
+#define VML_CONFIG_ESTRB_INV         0x00008000
+
+/* Pipe A Horizontal total register */
+#define VML_HTOTAL_A                 0x00060000
+#define VML_HTOTAL_MASK              0x1FFF0000
+#define VML_HTOTAL_SHIFT             16
+#define VML_HTOTAL_VAL               8192
+#define VML_HACTIVE_MASK             0x000007FF
+#define VML_HACTIVE_SHIFT            0
+#define VML_HACTIVE_VAL              4096
+
+/* Pipe A Horizontal Blank register */
+#define VML_HBLANK_A                 0x00060004
+#define VML_HBLANK_END_MASK          0x1FFF0000
+#define VML_HBLANK_END_SHIFT         16
+#define VML_HBLANK_END_VAL           8192
+#define VML_HBLANK_START_MASK        0x00001FFF
+#define VML_HBLANK_START_SHIFT       0
+#define VML_HBLANK_START_VAL         8192
+
+/* Pipe A Horizontal Sync register */
+#define VML_HSYNC_A                  0x00060008
+#define VML_HSYNC_END_MASK           0x1FFF0000
+#define VML_HSYNC_END_SHIFT          16
+#define VML_HSYNC_END_VAL            8192
+#define VML_HSYNC_START_MASK         0x00001FFF
+#define VML_HSYNC_START_SHIFT        0
+#define VML_HSYNC_START_VAL          8192
+
+/* Pipe A Vertical total register */
+#define VML_VTOTAL_A                 0x0006000C
+#define VML_VTOTAL_MASK              0x1FFF0000
+#define VML_VTOTAL_SHIFT             16
+#define VML_VTOTAL_VAL               8192
+#define VML_VACTIVE_MASK             0x000007FF
+#define VML_VACTIVE_SHIFT            0
+#define VML_VACTIVE_VAL              4096
+
+/* Pipe A Vertical Blank register */
+#define VML_VBLANK_A                 0x00060010
+#define VML_VBLANK_END_MASK          0x1FFF0000
+#define VML_VBLANK_END_SHIFT         16
+#define VML_VBLANK_END_VAL           8192
+#define VML_VBLANK_START_MASK        0x00001FFF
+#define VML_VBLANK_START_SHIFT       0
+#define VML_VBLANK_START_VAL         8192
+
+/* Pipe A Vertical Sync register */
+#define VML_VSYNC_A                  0x00060014
+#define VML_VSYNC_END_MASK           0x1FFF0000
+#define VML_VSYNC_END_SHIFT          16
+#define VML_VSYNC_END_VAL            8192
+#define VML_VSYNC_START_MASK         0x00001FFF
+#define VML_VSYNC_START_SHIFT        0
+#define VML_VSYNC_START_VAL          8192
+
+/* Pipe A Source Image size (minus one - equal to active size)
+ * Programmable while pipe is enabled.
+ */
+#define VML_PIPEASRC                 0x0006001C
+#define VML_PIPEASRC_HMASK           0x0FFF0000
+#define VML_PIPEASRC_HSHIFT          16
+#define VML_PIPEASRC_VMASK           0x00000FFF
+#define VML_PIPEASRC_VSHIFT          0
+
+/* Pipe A Border Color Pattern register (10 bit color) */
+#define VML_BCLRPAT_A                0x00060020
+
+/* Pipe A Canvas Color register  (10 bit color) */
+#define VML_CANVSCLR_A               0x00060024
+
+/* Pipe A Configuration register */
+#define VML_PIPEACONF                0x00070008
+#define VML_PIPE_BASE                0x00000000
+#define VML_PIPE_ENABLE              0x80000000
+#define VML_PIPE_FORCE_BORDER        0x02000000
+#define VML_PIPE_PLANES_OFF          0x00080000
+#define VML_PIPE_ARGB_OUTPUT_MODE    0x00040000
+
+/* Pipe A FIFO setting */
+#define VML_DSPARB                   0x00070030
+#define VML_FIFO_DEFAULT             0x00001D9C
+
+/* MDVO rcomp status & pads control register */
+#define VML_RCOMPSTAT                0x00070048
+#define VML_MDVO_VDC_I_RCOMP         0x80000000
+#define VML_MDVO_POWERSAVE_OFF       0x00000008
+#define VML_MDVO_PAD_ENABLE          0x00000004
+#define VML_MDVO_PULLDOWN_ENABLE     0x00000001
+
+struct vml_par {
+        struct pci_dev *vdc;
+        u64 vdc_mem_base;
+        u64 vdc_mem_size;
+        char __iomem *vdc_mem;
+
+        struct pci_dev *gpu;
+        u64 gpu_mem_base;
+        u64 gpu_mem_size;
+        char __iomem *gpu_mem;
+
+        atomic_t refcount;
+};
+
+struct vram_area {
+        unsigned long logical;
+        unsigned long phys;
+        unsigned long size;
+        unsigned order;
+};
+
+struct vml_info {
+        struct fb_info info;
+        struct vml_par *par;
+        struct list_head head;
+        struct vram_area vram[VML_VRAM_AREAS];
+        u64 vram_start;
+        u64 vram_contig_size;
+        u32 num_areas;
+        void __iomem *vram_logical;
+        u32 pseudo_palette[16];
+        u32 stride;
+        u32 bytes_per_pixel;
+        atomic_t vmas;
+        int cur_blank_mode;
+        int pipe_disabled;
+};
+
+/*
+ * Subsystem
+ */
+
+struct vml_sys {
+        char *name;
+
+        /*
+         * Save / Restore;
+         */
+
+        int (*save) (struct vml_sys * sys);
+        int (*restore) (struct vml_sys * sys);
+
+        /*
+         * PLL programming;
+         */
+
+        int (*set_clock) (struct vml_sys * sys, int clock);
+        int (*nearest_clock) (const struct vml_sys * sys, int clock);
+};
+
+extern int vmlfb_register_subsys(struct vml_sys *sys);
+extern void vmlfb_unregister_subsys(struct vml_sys *sys);
+
+#define VML_READ32(_par, _offset) \
+        (ioread32((_par)->vdc_mem + (_offset)))
+#define VML_WRITE32(_par, _offset, _value)                              \
+        iowrite32(_value, (_par)->vdc_mem + (_offset))
+
+#endif
diff --git a/drivers/video/vfb.c b/drivers/video/vfb.c
index a9b99b01bd8e..64ee78c3c12b 100644
--- a/drivers/video/vfb.c
+++ b/drivers/video/vfb.c
@@ -84,13 +84,15 @@ static int vfb_mmap(struct fb_info *info,
                     struct vm_area_struct *vma);
 
 static struct fb_ops vfb_ops = {
+        .fb_read        = fb_sys_read,
+        .fb_write       = fb_sys_write,
         .fb_check_var   = vfb_check_var,
         .fb_set_par     = vfb_set_par,
         .fb_setcolreg   = vfb_setcolreg,
         .fb_pan_display = vfb_pan_display,
-        .fb_fillrect    = cfb_fillrect,
-        .fb_copyarea    = cfb_copyarea,
-        .fb_imageblit   = cfb_imageblit,
+        .fb_fillrect    = sys_fillrect,
+        .fb_copyarea    = sys_copyarea,
+        .fb_imageblit   = sys_imageblit,
         .fb_mmap        = vfb_mmap,
 };
 
diff --git a/drivers/video/vga16fb.c b/drivers/video/vga16fb.c
index ec4c7dc54a66..2a14d28c4163 100644
--- a/drivers/video/vga16fb.c
+++ b/drivers/video/vga16fb.c
@@ -1378,6 +1378,8 @@ static int __init vga16fb_probe(struct platform_device *dev)
         info->fbops = &vga16fb_ops;
         info->var = vga16fb_defined;
         info->fix = vga16fb_fix;
+        /* supports rectangles with widths of multiples of 8 */
+        info->pixmap.blit_x = 1 << 7 | 1 << 15 | 1 << 23 | 1 << 31;
         info->flags = FBINFO_FLAG_DEFAULT |
                 FBINFO_HWACCEL_YPAN;
 
diff --git a/drivers/video/vgastate.c b/drivers/video/vgastate.c
index d94efafc77b5..b91c466225b9 100644
--- a/drivers/video/vgastate.c
+++ b/drivers/video/vgastate.c
@@ -50,23 +50,28 @@ static void save_vga_text(struct vgastate *state, void __iomem *fbbase)
         struct regstate *saved = (struct regstate *) state->vidstate;
         int i;
         u8 misc, attr10, gr4, gr5, gr6, seq1, seq2, seq4;
+        unsigned short iobase;
 
         /* if in graphics mode, no need to save */
+        misc = vga_r(state->vgabase, VGA_MIS_R);
+        iobase = (misc & 1) ? 0x3d0 : 0x3b0;
+
+        vga_r(state->vgabase, iobase + 0xa);
+        vga_w(state->vgabase, VGA_ATT_W, 0x00);
         attr10 = vga_rattr(state->vgabase, 0x10);
+        vga_r(state->vgabase, iobase + 0xa);
+        vga_w(state->vgabase, VGA_ATT_W, 0x20);
+
         if (attr10 & 1)
                 return;
-        
+
         /* save regs */
-        misc = vga_r(state->vgabase, VGA_MIS_R);
         gr4 = vga_rgfx(state->vgabase, VGA_GFX_PLANE_READ);
         gr5 = vga_rgfx(state->vgabase, VGA_GFX_MODE);
         gr6 = vga_rgfx(state->vgabase, VGA_GFX_MISC);
         seq2 = vga_rseq(state->vgabase, VGA_SEQ_PLANE_WRITE);
         seq4 = vga_rseq(state->vgabase, VGA_SEQ_MEMORY_MODE);
         
-        /* force graphics mode */
-        vga_w(state->vgabase, VGA_MIS_W, misc | 1);
-
         /* blank screen */
         seq1 = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE);
         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
@@ -115,15 +120,12 @@ static void save_vga_text(struct vgastate *state, void __iomem *fbbase)
         }
 
         /* restore regs */
-        vga_wattr(state->vgabase, 0x10, attr10);
-
         vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, seq2);
         vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, seq4);
 
         vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, gr4);
         vga_wgfx(state->vgabase, VGA_GFX_MODE, gr5);
         vga_wgfx(state->vgabase, VGA_GFX_MISC, gr6);
-        vga_w(state->vgabase, VGA_MIS_W, misc);
 
         /* unblank screen */
         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
@@ -137,11 +139,10 @@ static void restore_vga_text(struct vgastate *state, void __iomem *fbbase)
 {
         struct regstate *saved = (struct regstate *) state->vidstate;
         int i;
-        u8 misc, gr1, gr3, gr4, gr5, gr6, gr8; 
+        u8 gr1, gr3, gr4, gr5, gr6, gr8;
         u8 seq1, seq2, seq4;
 
         /* save regs */
-        misc = vga_r(state->vgabase, VGA_MIS_R);
         gr1 = vga_rgfx(state->vgabase, VGA_GFX_SR_ENABLE);
         gr3 = vga_rgfx(state->vgabase, VGA_GFX_DATA_ROTATE);
         gr4 = vga_rgfx(state->vgabase, VGA_GFX_PLANE_READ);
@@ -151,9 +152,6 @@ static void restore_vga_text(struct vgastate *state, void __iomem *fbbase)
         seq2 = vga_rseq(state->vgabase, VGA_SEQ_PLANE_WRITE);
         seq4 = vga_rseq(state->vgabase, VGA_SEQ_MEMORY_MODE);
         
-        /* force graphics mode */
-        vga_w(state->vgabase, VGA_MIS_W, misc | 1);
-
         /* blank screen */
         seq1 = vga_rseq(state->vgabase, VGA_SEQ_CLOCK_MODE);
         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
@@ -213,8 +211,6 @@ static void restore_vga_text(struct vgastate *state, void __iomem *fbbase)
         vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x3);
 
         /* restore regs */
-        vga_w(state->vgabase, VGA_MIS_W, misc);
-
         vga_wgfx(state->vgabase, VGA_GFX_SR_ENABLE, gr1);
         vga_wgfx(state->vgabase, VGA_GFX_DATA_ROTATE, gr3);
         vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, gr4);
diff --git a/drivers/video/xilinxfb.c b/drivers/video/xilinxfb.c
new file mode 100644
index 000000000000..1d29a89a86b4
--- /dev/null
+++ b/drivers/video/xilinxfb.c
@@ -0,0 +1,381 @@
+/*
+ * xilinxfb.c
+ *
+ * Xilinx TFT LCD frame buffer driver
+ *
+ * Author: MontaVista Software, Inc.
+ *         source@mvista.com
+ *
+ * 2002-2007 (c) MontaVista Software, Inc.  This file is licensed under the
+ * terms of the GNU General Public License version 2.  This program is licensed
+ * "as is" without any warranty of any kind, whether express or implied.
+ */
+
+/*
+ * This driver was based on au1100fb.c by MontaVista rewritten for 2.6
+ * by Embedded Alley Solutions <source@embeddedalley.com>, which in turn
+ * was based on skeletonfb.c, Skeleton for a frame buffer device by
+ * Geert Uytterhoeven.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/dma-mapping.h>
+#include <linux/platform_device.h>
+
+#include <asm/io.h>
+#include <syslib/virtex_devices.h>
+
+#define DRIVER_NAME             "xilinxfb"
+#define DRIVER_DESCRIPTION      "Xilinx TFT LCD frame buffer driver"
+
+/*
+ * Xilinx calls it "PLB TFT LCD Controller" though it can also be used for
+ * the VGA port on the Xilinx ML40x board. This is a hardware display controller
+ * for a 640x480 resolution TFT or VGA screen.
+ *
+ * The interface to the framebuffer is nice and simple.  There are two
+ * control registers.  The first tells the LCD interface where in memory
+ * the frame buffer is (only the 11 most significant bits are used, so
+ * don't start thinking about scrolling).  The second allows the LCD to
+ * be turned on or off as well as rotated 180 degrees.
+ */
+#define NUM_REGS        2
+#define REG_FB_ADDR     0
+#define REG_CTRL        1
+#define REG_CTRL_ENABLE  0x0001
+#define REG_CTRL_ROTATE  0x0002
+
+/*
+ * The hardware only handles a single mode: 640x480 24 bit true
+ * color. Each pixel gets a word (32 bits) of memory.  Within each word,
+ * the 8 most significant bits are ignored, the next 8 bits are the red
+ * level, the next 8 bits are the green level and the 8 least
+ * significant bits are the blue level.  Each row of the LCD uses 1024
+ * words, but only the first 640 pixels are displayed with the other 384
+ * words being ignored.  There are 480 rows.
+ */
+#define BYTES_PER_PIXEL 4
+#define BITS_PER_PIXEL  (BYTES_PER_PIXEL * 8)
+#define XRES            640
+#define YRES            480
+#define XRES_VIRTUAL    1024
+#define YRES_VIRTUAL    YRES
+#define LINE_LENGTH     (XRES_VIRTUAL * BYTES_PER_PIXEL)
+#define FB_SIZE         (YRES_VIRTUAL * LINE_LENGTH)
+
+#define RED_SHIFT       16
+#define GREEN_SHIFT     8
+#define BLUE_SHIFT      0
+
+#define PALETTE_ENTRIES_NO      16      /* passed to fb_alloc_cmap() */
+
+/*
+ * Here are the default fb_fix_screeninfo and fb_var_screeninfo structures
+ */
+static struct fb_fix_screeninfo xilinx_fb_fix __initdata = {
+        .id =           "Xilinx",
+        .type =         FB_TYPE_PACKED_PIXELS,
+        .visual =       FB_VISUAL_TRUECOLOR,
+        .smem_len =     FB_SIZE,
+        .line_length =  LINE_LENGTH,
+        .accel =        FB_ACCEL_NONE
+};
+
+static struct fb_var_screeninfo xilinx_fb_var __initdata = {
+        .xres =                 XRES,
+        .yres =                 YRES,
+        .xres_virtual =         XRES_VIRTUAL,
+        .yres_virtual =         YRES_VIRTUAL,
+
+        .bits_per_pixel =       BITS_PER_PIXEL,
+
+        .red =          { RED_SHIFT, 8, 0 },
+        .green =        { GREEN_SHIFT, 8, 0 },
+        .blue =         { BLUE_SHIFT, 8, 0 },
+        .transp =       { 0, 0, 0 },
+
+        .activate =     FB_ACTIVATE_NOW
+};
+
+struct xilinxfb_drvdata {
+
+        struct fb_info  info;           /* FB driver info record */
+
+        u32             regs_phys;      /* phys. address of the control registers */
+        u32 __iomem     *regs;          /* virt. address of the control registers */
+
+        unsigned char __iomem   *fb_virt;       /* virt. address of the frame buffer */
+        dma_addr_t      fb_phys;        /* phys. address of the frame buffer */
+
+        u32             reg_ctrl_default;
+
+        u32             pseudo_palette[PALETTE_ENTRIES_NO];
+                                        /* Fake palette of 16 colors */
+};
+
+#define to_xilinxfb_drvdata(_info) \
+        container_of(_info, struct xilinxfb_drvdata, info)
+
+/*
+ * The LCD controller has DCR interface to its registers, but all
+ * the boards and configurations the driver has been tested with
+ * use opb2dcr bridge. So the registers are seen as memory mapped.
+ * This macro is to make it simple to add the direct DCR access
+ * when it's needed.
+ */
+#define xilinx_fb_out_be32(driverdata, offset, val) \
+        out_be32(driverdata->regs + offset, val)
+
+static int
+xilinx_fb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue,
+        unsigned transp, struct fb_info *fbi)
+{
+        u32 *palette = fbi->pseudo_palette;
+
+        if (regno >= PALETTE_ENTRIES_NO)
+                return -EINVAL;
+
+        if (fbi->var.grayscale) {
+                /* Convert color to grayscale.
+                 * grayscale = 0.30*R + 0.59*G + 0.11*B */
+                red = green = blue =
+                        (red * 77 + green * 151 + blue * 28 + 127) >> 8;
+        }
+
+        /* fbi->fix.visual is always FB_VISUAL_TRUECOLOR */
+
+        /* We only handle 8 bits of each color. */
+        red >>= 8;
+        green >>= 8;
+        blue >>= 8;
+        palette[regno] = (red << RED_SHIFT) | (green << GREEN_SHIFT) |
+                         (blue << BLUE_SHIFT);
+
+        return 0;
+}
+
+static int
+xilinx_fb_blank(int blank_mode, struct fb_info *fbi)
+{
+        struct xilinxfb_drvdata *drvdata = to_xilinxfb_drvdata(fbi);
+
+        switch (blank_mode) {
+        case FB_BLANK_UNBLANK:
+                /* turn on panel */
+                xilinx_fb_out_be32(drvdata, REG_CTRL, drvdata->reg_ctrl_default);
+                break;
+
+        case FB_BLANK_NORMAL:
+        case FB_BLANK_VSYNC_SUSPEND:
+        case FB_BLANK_HSYNC_SUSPEND:
+        case FB_BLANK_POWERDOWN:
+                /* turn off panel */
+                xilinx_fb_out_be32(drvdata, REG_CTRL, 0);
+        default:
+                break;
+
+        }
+        return 0; /* success */
+}
+
+static struct fb_ops xilinxfb_ops =
+{
+        .owner                  = THIS_MODULE,
+        .fb_setcolreg           = xilinx_fb_setcolreg,
+        .fb_blank               = xilinx_fb_blank,
+        .fb_fillrect            = cfb_fillrect,
+        .fb_copyarea            = cfb_copyarea,
+        .fb_imageblit           = cfb_imageblit,
+};
+
+/* === The device driver === */
+
+static int
+xilinxfb_drv_probe(struct device *dev)
+{
+        struct platform_device *pdev;
+        struct xilinxfb_platform_data *pdata;
+        struct xilinxfb_drvdata *drvdata;
+        struct resource *regs_res;
+        int retval;
+
+        if (!dev)
+                return -EINVAL;
+
+        pdev = to_platform_device(dev);
+        pdata = pdev->dev.platform_data;
+
+        if (pdata == NULL) {
+                printk(KERN_ERR "Couldn't find platform data.\n");
+                return -EFAULT;
+        }
+
+        drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
+        if (!drvdata) {
+                printk(KERN_ERR "Couldn't allocate device private record\n");
+                return -ENOMEM;
+        }
+        dev_set_drvdata(dev, drvdata);
+
+        /* Map the control registers in */
+        regs_res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (!regs_res || (regs_res->end - regs_res->start + 1 < 8)) {
+                printk(KERN_ERR "Couldn't get registers resource\n");
+                retval = -EFAULT;
+                goto failed1;
+        }
+
+        if (!request_mem_region(regs_res->start, 8, DRIVER_NAME)) {
+                printk(KERN_ERR
+                       "Couldn't lock memory region at 0x%08X\n",
+                       regs_res->start);
+                retval = -EBUSY;
+                goto failed1;
+        }
+        drvdata->regs = (u32 __iomem*) ioremap(regs_res->start, 8);
+        drvdata->regs_phys = regs_res->start;
+
+        /* Allocate the framebuffer memory */
+        drvdata->fb_virt = dma_alloc_coherent(dev, PAGE_ALIGN(FB_SIZE),
+                                &drvdata->fb_phys, GFP_KERNEL);
+        if (!drvdata->fb_virt) {
+                printk(KERN_ERR "Could not allocate frame buffer memory\n");
+                retval = -ENOMEM;
+                goto failed2;
+        }
+
+        /* Clear (turn to black) the framebuffer */
+        memset_io((void *) drvdata->fb_virt, 0, FB_SIZE);
+
+        /* Tell the hardware where the frame buffer is */
+        xilinx_fb_out_be32(drvdata, REG_FB_ADDR, drvdata->fb_phys);
+
+        /* Turn on the display */
+        if (pdata->rotate_screen) {
+                drvdata->reg_ctrl_default = REG_CTRL_ENABLE | REG_CTRL_ROTATE;
+        } else {
+                drvdata->reg_ctrl_default = REG_CTRL_ENABLE;
+        }
+        xilinx_fb_out_be32(drvdata, REG_CTRL, drvdata->reg_ctrl_default);
+
+        /* Fill struct fb_info */
+        drvdata->info.device = dev;
+        drvdata->info.screen_base = drvdata->fb_virt;
+        drvdata->info.fbops = &xilinxfb_ops;
+        drvdata->info.fix = xilinx_fb_fix;
+        drvdata->info.fix.smem_start = drvdata->fb_phys;
+        drvdata->info.pseudo_palette = drvdata->pseudo_palette;
+
+        if (fb_alloc_cmap(&drvdata->info.cmap, PALETTE_ENTRIES_NO, 0) < 0) {
+                printk(KERN_ERR "Fail to allocate colormap (%d entries)\n",
+                        PALETTE_ENTRIES_NO);
+                retval = -EFAULT;
+                goto failed3;
+        }
+
+        drvdata->info.flags = FBINFO_DEFAULT;
+        xilinx_fb_var.height = pdata->screen_height_mm;
+        xilinx_fb_var.width = pdata->screen_width_mm;
+        drvdata->info.var = xilinx_fb_var;
+
+        /* Register new frame buffer */
+        if (register_framebuffer(&drvdata->info) < 0) {
+                printk(KERN_ERR "Could not register frame buffer\n");
+                retval = -EINVAL;
+                goto failed4;
+        }
+
+        return 0;       /* success */
+
+failed4:
+        fb_dealloc_cmap(&drvdata->info.cmap);
+
+failed3:
+        dma_free_coherent(dev, PAGE_ALIGN(FB_SIZE), drvdata->fb_virt,
+                drvdata->fb_phys);
+
+        /* Turn off the display */
+        xilinx_fb_out_be32(drvdata, REG_CTRL, 0);
+        iounmap(drvdata->regs);
+
+failed2:
+        release_mem_region(regs_res->start, 8);
+
+failed1:
+        kfree(drvdata);
+        dev_set_drvdata(dev, NULL);
+
+        return retval;
+}
+
+static int
+xilinxfb_drv_remove(struct device *dev)
+{
+        struct xilinxfb_drvdata *drvdata;
+
+        if (!dev)
+                return -ENODEV;
+
+        drvdata = (struct xilinxfb_drvdata *) dev_get_drvdata(dev);
+
+#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
+        xilinx_fb_blank(VESA_POWERDOWN, &drvdata->info);
+#endif
+
+        unregister_framebuffer(&drvdata->info);
+
+        fb_dealloc_cmap(&drvdata->info.cmap);
+
+        dma_free_coherent(dev, PAGE_ALIGN(FB_SIZE), drvdata->fb_virt,
+                drvdata->fb_phys);
+
+        /* Turn off the display */
+        xilinx_fb_out_be32(drvdata, REG_CTRL, 0);
+        iounmap(drvdata->regs);
+
+        release_mem_region(drvdata->regs_phys, 8);
+
+        kfree(drvdata);
+        dev_set_drvdata(dev, NULL);
+
+        return 0;
+}
+
+
+static struct device_driver xilinxfb_driver = {
+        .name           = DRIVER_NAME,
+        .bus            = &platform_bus_type,
+
+        .probe          = xilinxfb_drv_probe,
+        .remove         = xilinxfb_drv_remove
+};
+
+static int __init
+xilinxfb_init(void)
+{
+        /*
+         * No kernel boot options used,
+         * so we just need to register the driver
+         */
+        return driver_register(&xilinxfb_driver);
+}
+
+static void __exit
+xilinxfb_cleanup(void)
+{
+        driver_unregister(&xilinxfb_driver);
+}
+
+module_init(xilinxfb_init);
+module_exit(xilinxfb_cleanup);
+
+MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
+MODULE_DESCRIPTION(DRIVER_DESCRIPTION);
+MODULE_LICENSE("GPL");
diff --git a/drivers/w1/masters/Kconfig b/drivers/w1/masters/Kconfig
index 2fb425536eae..8f779338f744 100644
--- a/drivers/w1/masters/Kconfig
+++ b/drivers/w1/masters/Kconfig
@@ -35,5 +35,13 @@ config W1_MASTER_DS2482
           This driver can also be built as a module.  If so, the module
           will be called ds2482.
 
+config W1_MASTER_DS1WM
+        tristate "Maxim DS1WM 1-wire busmaster"
+        depends on W1 && ARM
+        help
+          Say Y here to enable the DS1WM 1-wire driver, such as that
+          in HP iPAQ devices like h5xxx, h2200, and ASIC3-based like
+          hx4700.
+
 endmenu
 
diff --git a/drivers/w1/masters/Makefile b/drivers/w1/masters/Makefile
index 4cee256a8134..11551b328186 100644
--- a/drivers/w1/masters/Makefile
+++ b/drivers/w1/masters/Makefile
@@ -5,4 +5,4 @@
 obj-$(CONFIG_W1_MASTER_MATROX)          += matrox_w1.o
 obj-$(CONFIG_W1_MASTER_DS2490)          += ds2490.o
 obj-$(CONFIG_W1_MASTER_DS2482)          += ds2482.o
-
+obj-$(CONFIG_W1_MASTER_DS1WM)           += ds1wm.o
diff --git a/drivers/w1/masters/ds1wm.c b/drivers/w1/masters/ds1wm.c
new file mode 100644
index 000000000000..763bc73e5070
--- /dev/null
+++ b/drivers/w1/masters/ds1wm.c
@@ -0,0 +1,468 @@
+/*
+ * 1-wire busmaster driver for DS1WM and ASICs with embedded DS1WMs
+ * such as HP iPAQs (including h5xxx, h2200, and devices with ASIC3
+ * like hx4700).
+ *
+ * Copyright (c) 2004-2005, Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>
+ * Copyright (c) 2004-2007, Matt Reimer <mreimer@vpop.net>
+ *
+ * Use consistent with the GNU GPL is permitted,
+ * provided that this copyright notice is
+ * preserved in its entirety in all copies and derived works.
+ */
+
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/pm.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/ds1wm.h>
+
+#include <asm/io.h>
+
+#include "../w1.h"
+#include "../w1_int.h"
+
+
+#define DS1WM_CMD       0x00    /* R/W 4 bits command */
+#define DS1WM_DATA      0x01    /* R/W 8 bits, transmit/receive buffer */
+#define DS1WM_INT       0x02    /* R/W interrupt status */
+#define DS1WM_INT_EN    0x03    /* R/W interrupt enable */
+#define DS1WM_CLKDIV    0x04    /* R/W 5 bits of divisor and pre-scale */
+
+#define DS1WM_CMD_1W_RESET  (1 << 0)    /* force reset on 1-wire bus */
+#define DS1WM_CMD_SRA       (1 << 1)    /* enable Search ROM accelerator mode */
+#define DS1WM_CMD_DQ_OUTPUT (1 << 2)    /* write only - forces bus low */
+#define DS1WM_CMD_DQ_INPUT  (1 << 3)    /* read only - reflects state of bus */
+#define DS1WM_CMD_RST       (1 << 5)    /* software reset */
+#define DS1WM_CMD_OD        (1 << 7)    /* overdrive */
+
+#define DS1WM_INT_PD        (1 << 0)    /* presence detect */
+#define DS1WM_INT_PDR       (1 << 1)    /* presence detect result */
+#define DS1WM_INT_TBE       (1 << 2)    /* tx buffer empty */
+#define DS1WM_INT_TSRE      (1 << 3)    /* tx shift register empty */
+#define DS1WM_INT_RBF       (1 << 4)    /* rx buffer full */
+#define DS1WM_INT_RSRF      (1 << 5)    /* rx shift register full */
+
+#define DS1WM_INTEN_EPD     (1 << 0)    /* enable presence detect int */
+#define DS1WM_INTEN_IAS     (1 << 1)    /* INTR active state */
+#define DS1WM_INTEN_ETBE    (1 << 2)    /* enable tx buffer empty int */
+#define DS1WM_INTEN_ETMT    (1 << 3)    /* enable tx shift register empty int */
+#define DS1WM_INTEN_ERBF    (1 << 4)    /* enable rx buffer full int */
+#define DS1WM_INTEN_ERSRF   (1 << 5)    /* enable rx shift register full int */
+#define DS1WM_INTEN_DQO     (1 << 6)    /* enable direct bus driving ops */
+
+
+#define DS1WM_TIMEOUT (HZ * 5)
+
+static struct {
+        unsigned long freq;
+        unsigned long divisor;
+} freq[] = {
+        { 4000000, 0x8 },
+        { 5000000, 0x2 },
+        { 6000000, 0x5 },
+        { 7000000, 0x3 },
+        { 8000000, 0xc },
+        { 10000000, 0x6 },
+        { 12000000, 0x9 },
+        { 14000000, 0x7 },
+        { 16000000, 0x10 },
+        { 20000000, 0xa },
+        { 24000000, 0xd },
+        { 28000000, 0xb },
+        { 32000000, 0x14 },
+        { 40000000, 0xe },
+        { 48000000, 0x11 },
+        { 56000000, 0xf },
+        { 64000000, 0x18 },
+        { 80000000, 0x12 },
+        { 96000000, 0x15 },
+        { 112000000, 0x13 },
+        { 128000000, 0x1c },
+};
+
+struct ds1wm_data {
+        void            *map;
+        int             bus_shift; /* # of shifts to calc register offsets */
+        struct platform_device *pdev;
+        struct ds1wm_platform_data *pdata;
+        int             irq;
+        int             active_high;
+        struct clk      *clk;
+        int             slave_present;
+        void            *reset_complete;
+        void            *read_complete;
+        void            *write_complete;
+        u8              read_byte; /* last byte received */
+};
+
+static inline void ds1wm_write_register(struct ds1wm_data *ds1wm_data, u32 reg,
+                                        u8 val)
+{
+        __raw_writeb(val, ds1wm_data->map + (reg << ds1wm_data->bus_shift));
+}
+
+static inline u8 ds1wm_read_register(struct ds1wm_data *ds1wm_data, u32 reg)
+{
+        return __raw_readb(ds1wm_data->map + (reg << ds1wm_data->bus_shift));
+}
+
+
+static irqreturn_t ds1wm_isr(int isr, void *data)
+{
+        struct ds1wm_data *ds1wm_data = data;
+        u8 intr = ds1wm_read_register(ds1wm_data, DS1WM_INT);
+
+        ds1wm_data->slave_present = (intr & DS1WM_INT_PDR) ? 0 : 1;
+
+        if ((intr & DS1WM_INT_PD) && ds1wm_data->reset_complete)
+                complete(ds1wm_data->reset_complete);
+
+        if ((intr & DS1WM_INT_TSRE) && ds1wm_data->write_complete)
+                complete(ds1wm_data->write_complete);
+
+        if (intr & DS1WM_INT_RBF) {
+                ds1wm_data->read_byte = ds1wm_read_register(ds1wm_data,
+                                                            DS1WM_DATA);
+                if (ds1wm_data->read_complete)
+                        complete(ds1wm_data->read_complete);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int ds1wm_reset(struct ds1wm_data *ds1wm_data)
+{
+        unsigned long timeleft;
+        DECLARE_COMPLETION_ONSTACK(reset_done);
+
+        ds1wm_data->reset_complete = &reset_done;
+
+        ds1wm_write_register(ds1wm_data, DS1WM_INT_EN, DS1WM_INTEN_EPD |
+                (ds1wm_data->active_high ? DS1WM_INTEN_IAS : 0));
+
+        ds1wm_write_register(ds1wm_data, DS1WM_CMD, DS1WM_CMD_1W_RESET);
+
+        timeleft = wait_for_completion_timeout(&reset_done, DS1WM_TIMEOUT);
+        ds1wm_data->reset_complete = NULL;
+        if (!timeleft) {
+                dev_dbg(&ds1wm_data->pdev->dev, "reset failed\n");
+                return 1;
+        }
+
+        /* Wait for the end of the reset. According to the specs, the time
+         * from when the interrupt is asserted to the end of the reset is:
+         *     tRSTH  - tPDH  - tPDL - tPDI
+         *     625 us - 60 us - 240 us - 100 ns = 324.9 us
+         *
+         * We'll wait a bit longer just to be sure.
+         */
+        udelay(500);
+
+        ds1wm_write_register(ds1wm_data, DS1WM_INT_EN,
+                DS1WM_INTEN_ERBF | DS1WM_INTEN_ETMT | DS1WM_INTEN_EPD |
+                (ds1wm_data->active_high ? DS1WM_INTEN_IAS : 0));
+
+        if (!ds1wm_data->slave_present) {
+                dev_dbg(&ds1wm_data->pdev->dev, "reset: no devices found\n");
+                return 1;
+        }
+
+        return 0;
+}
+
+static int ds1wm_write(struct ds1wm_data *ds1wm_data, u8 data)
+{
+        DECLARE_COMPLETION_ONSTACK(write_done);
+        ds1wm_data->write_complete = &write_done;
+
+        ds1wm_write_register(ds1wm_data, DS1WM_DATA, data);
+
+        wait_for_completion_timeout(&write_done, DS1WM_TIMEOUT);
+        ds1wm_data->write_complete = NULL;
+
+        return 0;
+}
+
+static int ds1wm_read(struct ds1wm_data *ds1wm_data, unsigned char write_data)
+{
+        DECLARE_COMPLETION_ONSTACK(read_done);
+        ds1wm_data->read_complete = &read_done;
+
+        ds1wm_write(ds1wm_data, write_data);
+        wait_for_completion_timeout(&read_done, DS1WM_TIMEOUT);
+        ds1wm_data->read_complete = NULL;
+
+        return ds1wm_data->read_byte;
+}
+
+static int ds1wm_find_divisor(int gclk)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(freq); i++)
+                if (gclk <= freq[i].freq)
+                        return freq[i].divisor;
+
+        return 0;
+}
+
+static void ds1wm_up(struct ds1wm_data *ds1wm_data)
+{
+        int gclk, divisor;
+
+        if (ds1wm_data->pdata->enable)
+                ds1wm_data->pdata->enable(ds1wm_data->pdev);
+
+        gclk = clk_get_rate(ds1wm_data->clk);
+        clk_enable(ds1wm_data->clk);
+        divisor = ds1wm_find_divisor(gclk);
+        if (divisor == 0) {
+                dev_err(&ds1wm_data->pdev->dev,
+                        "no suitable divisor for %dHz clock\n", gclk);
+                return;
+        }
+        ds1wm_write_register(ds1wm_data, DS1WM_CLKDIV, divisor);
+
+        /* Let the w1 clock stabilize. */
+        msleep(1);
+
+        ds1wm_reset(ds1wm_data);
+}
+
+static void ds1wm_down(struct ds1wm_data *ds1wm_data)
+{
+        ds1wm_reset(ds1wm_data);
+
+        /* Disable interrupts. */
+        ds1wm_write_register(ds1wm_data, DS1WM_INT_EN,
+                             ds1wm_data->active_high ? DS1WM_INTEN_IAS : 0);
+
+        if (ds1wm_data->pdata->disable)
+                ds1wm_data->pdata->disable(ds1wm_data->pdev);
+
+        clk_disable(ds1wm_data->clk);
+}
+
+/* --------------------------------------------------------------------- */
+/* w1 methods */
+
+static u8 ds1wm_read_byte(void *data)
+{
+        struct ds1wm_data *ds1wm_data = data;
+
+        return ds1wm_read(ds1wm_data, 0xff);
+}
+
+static void ds1wm_write_byte(void *data, u8 byte)
+{
+        struct ds1wm_data *ds1wm_data = data;
+
+        ds1wm_write(ds1wm_data, byte);
+}
+
+static u8 ds1wm_reset_bus(void *data)
+{
+        struct ds1wm_data *ds1wm_data = data;
+
+        ds1wm_reset(ds1wm_data);
+
+        return 0;
+}
+
+static void ds1wm_search(void *data, u8 search_type,
+                         w1_slave_found_callback slave_found)
+{
+        struct ds1wm_data *ds1wm_data = data;
+        int i;
+        unsigned long long rom_id;
+
+        /* XXX We need to iterate for multiple devices per the DS1WM docs.
+         * See http://www.maxim-ic.com/appnotes.cfm/appnote_number/120. */
+        if (ds1wm_reset(ds1wm_data))
+                return;
+
+        ds1wm_write(ds1wm_data, search_type);
+        ds1wm_write_register(ds1wm_data, DS1WM_CMD, DS1WM_CMD_SRA);
+
+        for (rom_id = 0, i = 0; i < 16; i++) {
+
+                unsigned char resp, r, d;
+
+                resp = ds1wm_read(ds1wm_data, 0x00);
+
+                r = ((resp & 0x02) >> 1) |
+                    ((resp & 0x08) >> 2) |
+                    ((resp & 0x20) >> 3) |
+                    ((resp & 0x80) >> 4);
+
+                d = ((resp & 0x01) >> 0) |
+                    ((resp & 0x04) >> 1) |
+                    ((resp & 0x10) >> 2) |
+                    ((resp & 0x40) >> 3);
+
+                rom_id |= (unsigned long long) r << (i * 4);
+
+        }
+        dev_dbg(&ds1wm_data->pdev->dev, "found 0x%08llX", rom_id);
+
+        ds1wm_write_register(ds1wm_data, DS1WM_CMD, ~DS1WM_CMD_SRA);
+        ds1wm_reset(ds1wm_data);
+
+        slave_found(ds1wm_data, rom_id);
+}
+
+/* --------------------------------------------------------------------- */
+
+static struct w1_bus_master ds1wm_master = {
+        .read_byte  = ds1wm_read_byte,
+        .write_byte = ds1wm_write_byte,
+        .reset_bus  = ds1wm_reset_bus,
+        .search     = ds1wm_search,
+};
+
+static int ds1wm_probe(struct platform_device *pdev)
+{
+        struct ds1wm_data *ds1wm_data;
+        struct ds1wm_platform_data *plat;
+        struct resource *res;
+        int ret;
+
+        if (!pdev)
+                return -ENODEV;
+
+        ds1wm_data = kzalloc(sizeof (*ds1wm_data), GFP_KERNEL);
+        if (!ds1wm_data)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, ds1wm_data);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                ret = -ENXIO;
+                goto err0;
+        }
+        ds1wm_data->map = ioremap(res->start, res->end - res->start + 1);
+        if (!ds1wm_data->map) {
+                ret = -ENOMEM;
+                goto err0;
+        }
+        plat = pdev->dev.platform_data;
+        ds1wm_data->bus_shift = plat->bus_shift;
+        ds1wm_data->pdev = pdev;
+        ds1wm_data->pdata = plat;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                ret = -ENXIO;
+                goto err1;
+        }
+        ds1wm_data->irq = res->start;
+        ds1wm_data->active_high = (res->flags & IORESOURCE_IRQ_HIGHEDGE) ?
+                1 : 0;
+
+        set_irq_type(ds1wm_data->irq, ds1wm_data->active_high ?
+                        IRQ_TYPE_EDGE_RISING : IRQ_TYPE_EDGE_FALLING);
+
+        ret = request_irq(ds1wm_data->irq, ds1wm_isr, IRQF_DISABLED,
+                          "ds1wm", ds1wm_data);
+        if (ret)
+                goto err1;
+
+        ds1wm_data->clk = clk_get(&pdev->dev, "ds1wm");
+        if (!ds1wm_data->clk) {
+                ret = -ENOENT;
+                goto err2;
+        }
+
+        ds1wm_up(ds1wm_data);
+
+        ds1wm_master.data = (void *)ds1wm_data;
+
+        ret = w1_add_master_device(&ds1wm_master);
+        if (ret)
+                goto err3;
+
+        return 0;
+
+err3:
+        ds1wm_down(ds1wm_data);
+        clk_put(ds1wm_data->clk);
+err2:
+        free_irq(ds1wm_data->irq, ds1wm_data);
+err1:
+        iounmap(ds1wm_data->map);
+err0:
+        kfree(ds1wm_data);
+
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int ds1wm_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct ds1wm_data *ds1wm_data = platform_get_drvdata(pdev);
+
+        ds1wm_down(ds1wm_data);
+
+        return 0;
+}
+
+static int ds1wm_resume(struct platform_device *pdev)
+{
+        struct ds1wm_data *ds1wm_data = platform_get_drvdata(pdev);
+
+        ds1wm_up(ds1wm_data);
+
+        return 0;
+}
+#else
+#define ds1wm_suspend NULL
+#define ds1wm_resume NULL
+#endif
+
+static int ds1wm_remove(struct platform_device *pdev)
+{
+        struct ds1wm_data *ds1wm_data = platform_get_drvdata(pdev);
+
+        w1_remove_master_device(&ds1wm_master);
+        ds1wm_down(ds1wm_data);
+        clk_put(ds1wm_data->clk);
+        free_irq(ds1wm_data->irq, ds1wm_data);
+        iounmap(ds1wm_data->map);
+        kfree(ds1wm_data);
+
+        return 0;
+}
+
+static struct platform_driver ds1wm_driver = {
+        .driver   = {
+                .name = "ds1wm",
+        },
+        .probe    = ds1wm_probe,
+        .remove   = ds1wm_remove,
+        .suspend  = ds1wm_suspend,
+        .resume   = ds1wm_resume
+};
+
+static int __init ds1wm_init(void)
+{
+        printk("DS1WM w1 busmaster driver - (c) 2004 Szabolcs Gyurko\n");
+        return platform_driver_register(&ds1wm_driver);
+}
+
+static void __exit ds1wm_exit(void)
+{
+        platform_driver_unregister(&ds1wm_driver);
+}
+
+module_init(ds1wm_init);
+module_exit(ds1wm_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>, "
+              "Matt Reimer <mreimer@vpop.net>");
+MODULE_DESCRIPTION("DS1WM w1 busmaster driver");
diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c
index 63c07243993c..7d6876dbcc96 100644
--- a/drivers/w1/w1.c
+++ b/drivers/w1/w1.c
@@ -459,7 +459,7 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
                  (unsigned long long) sl->reg_num.id);
 
         dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,
-                &sl->dev.bus_id[0]);
+                &sl->dev.bus_id[0], sl);
 
         err = device_register(&sl->dev);
         if (err < 0) {
diff --git a/drivers/w1/w1_int.c b/drivers/w1/w1_int.c
index 357a2e0f637a..258defdb2efd 100644
--- a/drivers/w1/w1_int.c
+++ b/drivers/w1/w1_int.c
@@ -100,7 +100,8 @@ int w1_add_master_device(struct w1_bus_master *master)
 
         /* validate minimum functionality */
         if (!(master->touch_bit && master->reset_bus) &&
-            !(master->write_bit && master->read_bit)) {
+            !(master->write_bit && master->read_bit) &&
+            !(master->write_byte && master->read_byte && master->reset_bus)) {
                 printk(KERN_ERR "w1_add_master_device: invalid function set\n");
                 return(-EINVAL);
         }