Merge branch 'for-rmk' of git://git.android.com/kernel into devel

271 files changed, 11158 insertions, 4476 deletions

diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index b1c723f9f58d..70f7f60929ca 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -431,7 +431,7 @@ static ssize_t acpi_battery_alarm_store(struct device *dev,
 }
 
 static struct device_attribute alarm_attr = {
-        .attr = {.name = "alarm", .mode = 0644, .owner = THIS_MODULE},
+        .attr = {.name = "alarm", .mode = 0644},
         .show = acpi_battery_alarm_show,
         .store = acpi_battery_alarm_store,
 };
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index 10a36512647c..7b011e7e29fe 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -463,7 +463,7 @@ static ssize_t acpi_battery_alarm_store(struct device *dev,
 }
 
 static struct device_attribute alarm_attr = {
-        .attr = {.name = "alarm", .mode = 0644, .owner = THIS_MODULE},
+        .attr = {.name = "alarm", .mode = 0644},
         .show = acpi_battery_alarm_show,
         .store = acpi_battery_alarm_store,
 };
diff --git a/drivers/acpi/sleep/proc.c b/drivers/acpi/sleep/proc.c
index bf5b04de02d1..631ee2ee2ca0 100644
--- a/drivers/acpi/sleep/proc.c
+++ b/drivers/acpi/sleep/proc.c
@@ -120,13 +120,13 @@ static int acpi_system_alarm_seq_show(struct seq_file *seq, void *offset)
         spin_unlock_irqrestore(&rtc_lock, flags);
 
         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
-                BCD_TO_BIN(sec);
-                BCD_TO_BIN(min);
-                BCD_TO_BIN(hr);
-                BCD_TO_BIN(day);
-                BCD_TO_BIN(mo);
-                BCD_TO_BIN(yr);
-                BCD_TO_BIN(cent);
+                sec = bcd2bin(sec);
+                min = bcd2bin(min);
+                hr = bcd2bin(hr);
+                day = bcd2bin(day);
+                mo = bcd2bin(mo);
+                yr = bcd2bin(yr);
+                cent = bcd2bin(cent);
         }
 
         /* we're trusting the FADT (see above) */
@@ -204,7 +204,7 @@ static u32 cmos_bcd_read(int offset, int rtc_control)
 {
         u32 val = CMOS_READ(offset);
         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
-                BCD_TO_BIN(val);
+                val = bcd2bin(val);
         return val;
 }
 
@@ -212,7 +212,7 @@ static u32 cmos_bcd_read(int offset, int rtc_control)
 static void cmos_bcd_write(u32 val, int offset, int rtc_control)
 {
         if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
-                BIN_TO_BCD(val);
+                val = bin2bcd(val);
         CMOS_WRITE(val, offset);
 }
 
diff --git a/drivers/acpi/system.c b/drivers/acpi/system.c
index 91dec448b3ed..24e80fd927e2 100644
--- a/drivers/acpi/system.c
+++ b/drivers/acpi/system.c
@@ -115,7 +115,6 @@ static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
         table_attr->attr.read = acpi_table_show;
         table_attr->attr.attr.name = table_attr->name;
         table_attr->attr.attr.mode = 0444;
-        table_attr->attr.attr.owner = THIS_MODULE;
 
         return;
 }
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index af0d175c025d..5260e9e0df48 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -21,6 +21,8 @@
 #include <linux/memory_hotplug.h>
 #include <linux/mm.h>
 #include <linux/mutex.h>
+#include <linux/stat.h>
+
 #include <asm/atomic.h>
 #include <asm/uaccess.h>
 
@@ -325,7 +327,7 @@ memory_probe_store(struct class *class, const char *buf, size_t count)
 
         return count;
 }
-static CLASS_ATTR(probe, 0700, NULL, memory_probe_store);
+static CLASS_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
 
 static int memory_probe_init(void)
 {
diff --git a/drivers/base/node.c b/drivers/base/node.c
index 5116b78c6325..f5207090885a 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -13,6 +13,7 @@
 #include <linux/nodemask.h>
 #include <linux/cpu.h>
 #include <linux/device.h>
+#include <linux/swap.h>
 
 static struct sysdev_class node_class = {
         .name = "node",
@@ -61,34 +62,52 @@ static ssize_t node_read_meminfo(struct sys_device * dev,
         si_meminfo_node(&i, nid);
 
         n = sprintf(buf, "\n"
-                       "Node %d MemTotal:     %8lu kB\n"
-                       "Node %d MemFree:      %8lu kB\n"
-                       "Node %d MemUsed:      %8lu kB\n"
-                       "Node %d Active:       %8lu kB\n"
-                       "Node %d Inactive:     %8lu kB\n"
+                       "Node %d MemTotal:       %8lu kB\n"
+                       "Node %d MemFree:        %8lu kB\n"
+                       "Node %d MemUsed:        %8lu kB\n"
+                       "Node %d Active:         %8lu kB\n"
+                       "Node %d Inactive:       %8lu kB\n"
+                       "Node %d Active(anon):   %8lu kB\n"
+                       "Node %d Inactive(anon): %8lu kB\n"
+                       "Node %d Active(file):   %8lu kB\n"
+                       "Node %d Inactive(file): %8lu kB\n"
+#ifdef CONFIG_UNEVICTABLE_LRU
+                       "Node %d Unevictable:    %8lu kB\n"
+                       "Node %d Mlocked:        %8lu kB\n"
+#endif
 #ifdef CONFIG_HIGHMEM
-                       "Node %d HighTotal:    %8lu kB\n"
-                       "Node %d HighFree:     %8lu kB\n"
-                       "Node %d LowTotal:     %8lu kB\n"
-                       "Node %d LowFree:      %8lu kB\n"
+                       "Node %d HighTotal:      %8lu kB\n"
+                       "Node %d HighFree:       %8lu kB\n"
+                       "Node %d LowTotal:       %8lu kB\n"
+                       "Node %d LowFree:        %8lu kB\n"
 #endif
-                       "Node %d Dirty:        %8lu kB\n"
-                       "Node %d Writeback:    %8lu kB\n"
-                       "Node %d FilePages:    %8lu kB\n"
-                       "Node %d Mapped:       %8lu kB\n"
-                       "Node %d AnonPages:    %8lu kB\n"
-                       "Node %d PageTables:   %8lu kB\n"
-                       "Node %d NFS_Unstable: %8lu kB\n"
-                       "Node %d Bounce:       %8lu kB\n"
-                       "Node %d WritebackTmp: %8lu kB\n"
-                       "Node %d Slab:         %8lu kB\n"
-                       "Node %d SReclaimable: %8lu kB\n"
-                       "Node %d SUnreclaim:   %8lu kB\n",
+                       "Node %d Dirty:          %8lu kB\n"
+                       "Node %d Writeback:      %8lu kB\n"
+                       "Node %d FilePages:      %8lu kB\n"
+                       "Node %d Mapped:         %8lu kB\n"
+                       "Node %d AnonPages:      %8lu kB\n"
+                       "Node %d PageTables:     %8lu kB\n"
+                       "Node %d NFS_Unstable:   %8lu kB\n"
+                       "Node %d Bounce:         %8lu kB\n"
+                       "Node %d WritebackTmp:   %8lu kB\n"
+                       "Node %d Slab:           %8lu kB\n"
+                       "Node %d SReclaimable:   %8lu kB\n"
+                       "Node %d SUnreclaim:     %8lu kB\n",
                        nid, K(i.totalram),
                        nid, K(i.freeram),
                        nid, K(i.totalram - i.freeram),
-                       nid, K(node_page_state(nid, NR_ACTIVE)),
-                       nid, K(node_page_state(nid, NR_INACTIVE)),
+                       nid, K(node_page_state(nid, NR_ACTIVE_ANON) +
+                                node_page_state(nid, NR_ACTIVE_FILE)),
+                       nid, K(node_page_state(nid, NR_INACTIVE_ANON) +
+                                node_page_state(nid, NR_INACTIVE_FILE)),
+                       nid, K(node_page_state(nid, NR_ACTIVE_ANON)),
+                       nid, K(node_page_state(nid, NR_INACTIVE_ANON)),
+                       nid, K(node_page_state(nid, NR_ACTIVE_FILE)),
+                       nid, K(node_page_state(nid, NR_INACTIVE_FILE)),
+#ifdef CONFIG_UNEVICTABLE_LRU
+                       nid, K(node_page_state(nid, NR_UNEVICTABLE)),
+                       nid, K(node_page_state(nid, NR_MLOCK)),
+#endif
 #ifdef CONFIG_HIGHMEM
                        nid, K(i.totalhigh),
                        nid, K(i.freehigh),
@@ -173,6 +192,8 @@ int register_node(struct node *node, int num, struct node *parent)
                 sysdev_create_file(&node->sysdev, &attr_meminfo);
                 sysdev_create_file(&node->sysdev, &attr_numastat);
                 sysdev_create_file(&node->sysdev, &attr_distance);
+
+                scan_unevictable_register_node(node);
         }
         return error;
 }
@@ -192,6 +213,8 @@ void unregister_node(struct node *node)
         sysdev_remove_file(&node->sysdev, &attr_numastat);
         sysdev_remove_file(&node->sysdev, &attr_distance);
 
+        scan_unevictable_unregister_node(node);
+
         sysdev_unregister(&node->sysdev);
 }
 
diff --git a/drivers/block/aoe/aoeblk.c b/drivers/block/aoe/aoeblk.c
index b82654e883a7..d876ad861237 100644
--- a/drivers/block/aoe/aoeblk.c
+++ b/drivers/block/aoe/aoeblk.c
@@ -90,7 +90,7 @@ static DEVICE_ATTR(state, S_IRUGO, aoedisk_show_state, NULL);
 static DEVICE_ATTR(mac, S_IRUGO, aoedisk_show_mac, NULL);
 static DEVICE_ATTR(netif, S_IRUGO, aoedisk_show_netif, NULL);
 static struct device_attribute dev_attr_firmware_version = {
-        .attr = { .name = "firmware-version", .mode = S_IRUGO, .owner = THIS_MODULE },
+        .attr = { .name = "firmware-version", .mode = S_IRUGO },
         .show = aoedisk_show_fwver,
 };
 
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 7b3351260d56..9034ca585afd 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -391,7 +391,7 @@ static ssize_t pid_show(struct device *dev,
 }
 
 static struct device_attribute pid_attr = {
-        .attr = { .name = "pid", .mode = S_IRUGO, .owner = THIS_MODULE },
+        .attr = { .name = "pid", .mode = S_IRUGO},
         .show = pid_show,
 };
 
diff --git a/drivers/char/agp/ali-agp.c b/drivers/char/agp/ali-agp.c
index 31dcd9142d54..dc8d1a90971f 100644
--- a/drivers/char/agp/ali-agp.c
+++ b/drivers/char/agp/ali-agp.c
@@ -417,6 +417,6 @@ static void __exit agp_ali_cleanup(void)
 module_init(agp_ali_init);
 module_exit(agp_ali_cleanup);
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
 MODULE_LICENSE("GPL and additional rights");
 
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 2812ee2b165a..52f4361eb6e4 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -772,6 +772,6 @@ module_init(agp_amd64_init);
 module_exit(agp_amd64_cleanup);
 #endif
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>, Andi Kleen");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>, Andi Kleen");
 module_param(agp_try_unsupported, bool, 0);
 MODULE_LICENSE("GPL");
diff --git a/drivers/char/agp/ati-agp.c b/drivers/char/agp/ati-agp.c
index ae2791b926b9..f1537eece07f 100644
--- a/drivers/char/agp/ati-agp.c
+++ b/drivers/char/agp/ati-agp.c
@@ -561,6 +561,6 @@ static void __exit agp_ati_cleanup(void)
 module_init(agp_ati_init);
 module_exit(agp_ati_cleanup);
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
 MODULE_LICENSE("GPL and additional rights");
 
diff --git a/drivers/char/agp/backend.c b/drivers/char/agp/backend.c
index 3a3cc03d401c..8c617ad7497f 100644
--- a/drivers/char/agp/backend.c
+++ b/drivers/char/agp/backend.c
@@ -349,7 +349,7 @@ static __init int agp_setup(char *s)
 __setup("agp=", agp_setup);
 #endif
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
 MODULE_DESCRIPTION("AGP GART driver");
 MODULE_LICENSE("GPL and additional rights");
 MODULE_ALIAS_MISCDEV(AGPGART_MINOR);
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index 1108665913e2..9cf6e9bb017e 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -2390,5 +2390,5 @@ static void __exit agp_intel_cleanup(void)
 module_init(agp_intel_init);
 module_exit(agp_intel_cleanup);
 
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
 MODULE_LICENSE("GPL and additional rights");
diff --git a/drivers/char/agp/nvidia-agp.c b/drivers/char/agp/nvidia-agp.c
index 5bbed3d79db9..16acee2de117 100644
--- a/drivers/char/agp/nvidia-agp.c
+++ b/drivers/char/agp/nvidia-agp.c
@@ -1,7 +1,7 @@
 /*
  * Nvidia AGPGART routines.
  * Based upon a 2.4 agpgart diff by the folks from NVIDIA, and hacked up
- * to work in 2.5 by Dave Jones <davej@codemonkey.org.uk>
+ * to work in 2.5 by Dave Jones <davej@redhat.com>
  */
 
 #include <linux/module.h>
diff --git a/drivers/char/agp/parisc-agp.c b/drivers/char/agp/parisc-agp.c
index f2492ecf0824..db60539bf67a 100644
--- a/drivers/char/agp/parisc-agp.c
+++ b/drivers/char/agp/parisc-agp.c
@@ -20,8 +20,8 @@
 #include <linux/agp_backend.h>
 #include <linux/log2.h>
 
-#include <asm-parisc/parisc-device.h>
-#include <asm-parisc/ropes.h>
+#include <asm/parisc-device.h>
+#include <asm/ropes.h>
 
 #include "agp.h"
 
diff --git a/drivers/char/agp/via-agp.c b/drivers/char/agp/via-agp.c
index 9f4d49e1b59a..d3bd243867fc 100644
--- a/drivers/char/agp/via-agp.c
+++ b/drivers/char/agp/via-agp.c
@@ -595,4 +595,4 @@ module_init(agp_via_init);
 module_exit(agp_via_cleanup);
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
+MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
diff --git a/drivers/char/ds1286.c b/drivers/char/ds1286.c
index 5329d482b582..0a826d7be10e 100644
--- a/drivers/char/ds1286.c
+++ b/drivers/char/ds1286.c
@@ -210,8 +210,8 @@ static int ds1286_ioctl(struct inode *inode, struct file *file,
                 if (sec != 0)
                         return -EINVAL;
 
-                min = BIN2BCD(min);
-                min = BIN2BCD(hrs);
+                min = bin2bcd(min);
+                min = bin2bcd(hrs);
 
                 spin_lock(&ds1286_lock);
                 rtc_write(hrs, RTC_HOURS_ALARM);
@@ -353,7 +353,7 @@ static int ds1286_proc_output(char *buf)
 
         ds1286_get_time(&tm);
         hundredth = rtc_read(RTC_HUNDREDTH_SECOND);
-        BCD_TO_BIN(hundredth);
+        hundredth = bcd2bin(hundredth);
 
         p += sprintf(p,
                      "rtc_time\t: %02d:%02d:%02d.%02d\n"
@@ -477,12 +477,12 @@ static void ds1286_get_time(struct rtc_time *rtc_tm)
         rtc_write(save_control, RTC_CMD);
         spin_unlock_irqrestore(&ds1286_lock, flags);
 
-        BCD_TO_BIN(rtc_tm->tm_sec);
-        BCD_TO_BIN(rtc_tm->tm_min);
-        BCD_TO_BIN(rtc_tm->tm_hour);
-        BCD_TO_BIN(rtc_tm->tm_mday);
-        BCD_TO_BIN(rtc_tm->tm_mon);
-        BCD_TO_BIN(rtc_tm->tm_year);
+        rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
+        rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
+        rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
+        rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
+        rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
+        rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
 
         /*
          * Account for differences between how the RTC uses the values
@@ -531,12 +531,12 @@ static int ds1286_set_time(struct rtc_time *rtc_tm)
         if (yrs >= 100)
                 yrs -= 100;
 
-        BIN_TO_BCD(sec);
-        BIN_TO_BCD(min);
-        BIN_TO_BCD(hrs);
-        BIN_TO_BCD(day);
-        BIN_TO_BCD(mon);
-        BIN_TO_BCD(yrs);
+        sec = bin2bcd(sec);
+        min = bin2bcd(min);
+        hrs = bin2bcd(hrs);
+        day = bin2bcd(day);
+        mon = bin2bcd(mon);
+        yrs = bin2bcd(yrs);
 
         spin_lock_irqsave(&ds1286_lock, flags);
         save_control = rtc_read(RTC_CMD);
@@ -572,8 +572,8 @@ static void ds1286_get_alm_time(struct rtc_time *alm_tm)
         cmd = rtc_read(RTC_CMD);
         spin_unlock_irqrestore(&ds1286_lock, flags);
 
-        BCD_TO_BIN(alm_tm->tm_min);
-        BCD_TO_BIN(alm_tm->tm_hour);
+        alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
+        alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
         alm_tm->tm_sec = 0;
 }
 
diff --git a/drivers/char/ds1302.c b/drivers/char/ds1302.c
index c5e67a623951..170693c93c73 100644
--- a/drivers/char/ds1302.c
+++ b/drivers/char/ds1302.c
@@ -131,12 +131,12 @@ get_rtc_time(struct rtc_time *rtc_tm)
 
         local_irq_restore(flags);
 
-        BCD_TO_BIN(rtc_tm->tm_sec);
-        BCD_TO_BIN(rtc_tm->tm_min);
-        BCD_TO_BIN(rtc_tm->tm_hour);
-        BCD_TO_BIN(rtc_tm->tm_mday);
-        BCD_TO_BIN(rtc_tm->tm_mon);
-        BCD_TO_BIN(rtc_tm->tm_year);
+        rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
+        rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
+        rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
+        rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
+        rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
+        rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
 
         /*
          * Account for differences between how the RTC uses the values
@@ -211,12 +211,12 @@ static long rtc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                         else
                                 yrs -= 1900;    /* RTC (70, 71, ... 99) */
 
-                        BIN_TO_BCD(sec);
-                        BIN_TO_BCD(min);
-                        BIN_TO_BCD(hrs);
-                        BIN_TO_BCD(day);
-                        BIN_TO_BCD(mon);
-                        BIN_TO_BCD(yrs);
+                        sec = bin2bcd(sec);
+                        min = bin2bcd(min);
+                        hrs = bin2bcd(hrs);
+                        day = bin2bcd(day);
+                        mon = bin2bcd(mon);
+                        yrs = bin2bcd(yrs);
 
                         lock_kernel();
                         local_irq_save(flags);
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index 4998b2761e8f..cf2461d34e5f 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -2477,7 +2477,11 @@ static int pc_send_break(struct tty_struct *tty, int msec)
         unsigned long flags;
 
         if (msec == -1)
-                return -EOPNOTSUPP;
+                msec = 0xFFFF;
+        else if (msec > 0xFFFE)
+                msec = 0xFFFE;
+        else if (msec < 1)
+                msec = 1;
 
         spin_lock_irqsave(&epca_lock, flags);
         globalwinon(ch);
diff --git a/drivers/char/hpet.c b/drivers/char/hpet.c
index f3cfb4c76125..408f5f92cb4e 100644
--- a/drivers/char/hpet.c
+++ b/drivers/char/hpet.c
@@ -219,7 +219,7 @@ static void hpet_timer_set_irq(struct hpet_dev *devp)
         for (irq = find_first_bit(&v, HPET_MAX_IRQ); irq < HPET_MAX_IRQ;
                 irq = find_next_bit(&v, HPET_MAX_IRQ, 1 + irq)) {
 
-                if (irq >= NR_IRQS) {
+                if (irq >= nr_irqs) {
                         irq = HPET_MAX_IRQ;
                         break;
                 }
diff --git a/drivers/char/ip27-rtc.c b/drivers/char/ip27-rtc.c
index ec9d0443d92c..2abd881b4cbc 100644
--- a/drivers/char/ip27-rtc.c
+++ b/drivers/char/ip27-rtc.c
@@ -130,12 +130,12 @@ static long rtc_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 if (yrs >= 100)
                         yrs -= 100;
 
-                sec = BIN2BCD(sec);
-                min = BIN2BCD(min);
-                hrs = BIN2BCD(hrs);
-                day = BIN2BCD(day);
-                mon = BIN2BCD(mon);
-                yrs = BIN2BCD(yrs);
+                sec = bin2bcd(sec);
+                min = bin2bcd(min);
+                hrs = bin2bcd(hrs);
+                day = bin2bcd(day);
+                mon = bin2bcd(mon);
+                yrs = bin2bcd(yrs);
 
                 spin_lock_irq(&rtc_lock);
                 rtc->control |= M48T35_RTC_SET;
@@ -311,12 +311,12 @@ static void get_rtc_time(struct rtc_time *rtc_tm)
         rtc->control &= ~M48T35_RTC_READ;
         spin_unlock_irq(&rtc_lock);
 
-        rtc_tm->tm_sec = BCD2BIN(rtc_tm->tm_sec);
-        rtc_tm->tm_min = BCD2BIN(rtc_tm->tm_min);
-        rtc_tm->tm_hour = BCD2BIN(rtc_tm->tm_hour);
-        rtc_tm->tm_mday = BCD2BIN(rtc_tm->tm_mday);
-        rtc_tm->tm_mon = BCD2BIN(rtc_tm->tm_mon);
-        rtc_tm->tm_year = BCD2BIN(rtc_tm->tm_year);
+        rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
+        rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
+        rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
+        rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
+        rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
+        rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
 
         /*
          * Account for differences between how the RTC uses the values
diff --git a/drivers/char/pc8736x_gpio.c b/drivers/char/pc8736x_gpio.c
index b930de50407a..3f7da8cf3a80 100644
--- a/drivers/char/pc8736x_gpio.c
+++ b/drivers/char/pc8736x_gpio.c
@@ -41,7 +41,8 @@ static u8 pc8736x_gpio_shadow[4];
 #define SIO_BASE2       0x4E    /* alt command-reg to check */
 
 #define SIO_SID         0x20    /* SuperI/O ID Register */
-#define SIO_SID_VALUE   0xe9    /* Expected value in SuperI/O ID Register */
+#define SIO_SID_PC87365 0xe5    /* Expected value in ID Register for PC87365 */
+#define SIO_SID_PC87366 0xe9    /* Expected value in ID Register for PC87366 */
 
 #define SIO_CF1         0x21    /* chip config, bit0 is chip enable */
 
@@ -91,13 +92,17 @@ static inline int superio_inb(int addr)
 
 static int pc8736x_superio_present(void)
 {
+        int id;
+
         /* try the 2 possible values, read a hardware reg to verify */
         superio_cmd = SIO_BASE1;
-        if (superio_inb(SIO_SID) == SIO_SID_VALUE)
+        id = superio_inb(SIO_SID);
+        if (id == SIO_SID_PC87365 || id == SIO_SID_PC87366)
                 return superio_cmd;
 
         superio_cmd = SIO_BASE2;
-        if (superio_inb(SIO_SID) == SIO_SID_VALUE)
+        id = superio_inb(SIO_SID);
+        if (id == SIO_SID_PC87365 || id == SIO_SID_PC87366)
                 return superio_cmd;
 
         return 0;
diff --git a/drivers/char/random.c b/drivers/char/random.c
index c8752eaad483..705a839f1796 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -558,9 +558,26 @@ struct timer_rand_state {
         unsigned dont_count_entropy:1;
 };
 
-static struct timer_rand_state input_timer_state;
 static struct timer_rand_state *irq_timer_state[NR_IRQS];
 
+static struct timer_rand_state *get_timer_rand_state(unsigned int irq)
+{
+        if (irq >= nr_irqs)
+                return NULL;
+
+        return irq_timer_state[irq];
+}
+
+static void set_timer_rand_state(unsigned int irq, struct timer_rand_state *state)
+{
+        if (irq >= nr_irqs)
+                return;
+
+        irq_timer_state[irq] = state;
+}
+
+static struct timer_rand_state input_timer_state;
+
 /*
  * This function adds entropy to the entropy "pool" by using timing
  * delays.  It uses the timer_rand_state structure to make an estimate
@@ -648,11 +665,15 @@ EXPORT_SYMBOL_GPL(add_input_randomness);
 
 void add_interrupt_randomness(int irq)
 {
-        if (irq >= NR_IRQS || irq_timer_state[irq] == NULL)
+        struct timer_rand_state *state;
+
+        state = get_timer_rand_state(irq);
+
+        if (state == NULL)
                 return;
 
         DEBUG_ENT("irq event %d\n", irq);
-        add_timer_randomness(irq_timer_state[irq], 0x100 + irq);
+        add_timer_randomness(state, 0x100 + irq);
 }
 
 #ifdef CONFIG_BLOCK
@@ -912,7 +933,12 @@ void rand_initialize_irq(int irq)
 {
         struct timer_rand_state *state;
 
-        if (irq >= NR_IRQS || irq_timer_state[irq])
+        if (irq >= nr_irqs)
+                return;
+
+        state = get_timer_rand_state(irq);
+
+        if (state)
                 return;
 
         /*
@@ -921,7 +947,7 @@ void rand_initialize_irq(int irq)
          */
         state = kzalloc(sizeof(struct timer_rand_state), GFP_KERNEL);
         if (state)
-                irq_timer_state[irq] = state;
+                set_timer_rand_state(irq, state);
 }
 
 #ifdef CONFIG_BLOCK
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index 17683de95717..32dc89720d58 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -518,17 +518,17 @@ static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
                 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) ||
                                                         RTC_ALWAYS_BCD) {
                         if (sec < 60)
-                                BIN_TO_BCD(sec);
+                                sec = bin2bcd(sec);
                         else
                                 sec = 0xff;
 
                         if (min < 60)
-                                BIN_TO_BCD(min);
+                                min = bin2bcd(min);
                         else
                                 min = 0xff;
 
                         if (hrs < 24)
-                                BIN_TO_BCD(hrs);
+                                hrs = bin2bcd(hrs);
                         else
                                 hrs = 0xff;
                 }
@@ -614,12 +614,12 @@ static int rtc_do_ioctl(unsigned int cmd, unsigned long arg, int kernel)
 
                 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
                     || RTC_ALWAYS_BCD) {
-                        BIN_TO_BCD(sec);
-                        BIN_TO_BCD(min);
-                        BIN_TO_BCD(hrs);
-                        BIN_TO_BCD(day);
-                        BIN_TO_BCD(mon);
-                        BIN_TO_BCD(yrs);
+                        sec = bin2bcd(sec);
+                        min = bin2bcd(min);
+                        hrs = bin2bcd(hrs);
+                        day = bin2bcd(day);
+                        mon = bin2bcd(mon);
+                        yrs = bin2bcd(yrs);
                 }
 
                 save_control = CMOS_READ(RTC_CONTROL);
@@ -1099,7 +1099,7 @@ no_irq:
         spin_unlock_irq(&rtc_lock);
 
         if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
-                BCD_TO_BIN(year);       /* This should never happen... */
+                year = bcd2bin(year);       /* This should never happen... */
 
         if (year < 20) {
                 epoch = 2000;
@@ -1352,13 +1352,13 @@ static void rtc_get_rtc_time(struct rtc_time *rtc_tm)
         spin_unlock_irqrestore(&rtc_lock, flags);
 
         if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
-                BCD_TO_BIN(rtc_tm->tm_sec);
-                BCD_TO_BIN(rtc_tm->tm_min);
-                BCD_TO_BIN(rtc_tm->tm_hour);
-                BCD_TO_BIN(rtc_tm->tm_mday);
-                BCD_TO_BIN(rtc_tm->tm_mon);
-                BCD_TO_BIN(rtc_tm->tm_year);
-                BCD_TO_BIN(rtc_tm->tm_wday);
+                rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
+                rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
+                rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
+                rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
+                rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
+                rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
+                rtc_tm->tm_wday = bcd2bin(rtc_tm->tm_wday);
         }
 
 #ifdef CONFIG_MACH_DECSTATION
@@ -1392,9 +1392,9 @@ static void get_rtc_alm_time(struct rtc_time *alm_tm)
         spin_unlock_irq(&rtc_lock);
 
         if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD) {
-                BCD_TO_BIN(alm_tm->tm_sec);
-                BCD_TO_BIN(alm_tm->tm_min);
-                BCD_TO_BIN(alm_tm->tm_hour);
+                alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
+                alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
+                alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
         }
 }
 
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index 5b8d7a1aa3e6..ba4e86281fbf 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -2504,7 +2504,7 @@ static void __devexit sx_remove_card(struct sx_board *board,
                 del_timer(&board->timer);
                 if (pdev) {
 #ifdef CONFIG_PCI
-                        pci_iounmap(pdev, board->base2);
+                        iounmap(board->base2);
                         pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
 #endif
                 } else {
@@ -2677,7 +2677,7 @@ static int __devinit sx_pci_probe(struct pci_dev *pdev,
         }
         board->hw_base = pci_resource_start(pdev, reg);
         board->base2 =
-        board->base = pci_iomap(pdev, reg, WINDOW_LEN(board));
+        board->base = ioremap_nocache(board->hw_base, WINDOW_LEN(board));
         if (!board->base) {
                 dev_err(&pdev->dev, "ioremap failed\n");
                 goto err_reg;
@@ -2703,7 +2703,7 @@ static int __devinit sx_pci_probe(struct pci_dev *pdev,
 
         return 0;
 err_unmap:
-        pci_iounmap(pdev, board->base2);
+        iounmap(board->base2);
 err_reg:
         pci_release_region(pdev, reg);
 err_flag:
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index dce4cc0e6953..ce0d9da52a8a 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -168,7 +168,7 @@ static void sysrq_handle_show_timers(int key, struct tty_struct *tty)
 static struct sysrq_key_op sysrq_show_timers_op = {
         .handler        = sysrq_handle_show_timers,
         .help_msg       = "show-all-timers(Q)",
-        .action_msg     = "Show Pending Timers",
+        .action_msg     = "Show clockevent devices & pending hrtimers (no others)",
 };
 
 static void sysrq_handle_mountro(int key, struct tty_struct *tty)
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index e70d13defde4..9c47dc48c9fd 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -1157,7 +1157,7 @@ EXPORT_SYMBOL_GPL(tpm_dev_vendor_release);
  * Once all references to platform device are down to 0,
  * release all allocated structures.
  */
-static void tpm_dev_release(struct device *dev)
+void tpm_dev_release(struct device *dev)
 {
         struct tpm_chip *chip = dev_get_drvdata(dev);
 
diff --git a/drivers/char/vr41xx_giu.c b/drivers/char/vr41xx_giu.c
index ffe9b4e3072e..54c837288d19 100644
--- a/drivers/char/vr41xx_giu.c
+++ b/drivers/char/vr41xx_giu.c
@@ -641,7 +641,7 @@ static int __devinit giu_probe(struct platform_device *dev)
         }
 
         irq = platform_get_irq(dev, 0);
-        if (irq < 0 || irq >= NR_IRQS)
+        if (irq < 0 || irq >= nr_irqs)
                 return -EBUSY;
 
         return cascade_irq(irq, giu_get_irq);
diff --git a/drivers/clocksource/acpi_pm.c b/drivers/clocksource/acpi_pm.c
index 71d2ac4e3f46..c20171078d1d 100644
--- a/drivers/clocksource/acpi_pm.c
+++ b/drivers/clocksource/acpi_pm.c
@@ -237,9 +237,12 @@ static int __init parse_pmtmr(char *arg)
 
         if (strict_strtoul(arg, 16, &base))
                 return -EINVAL;
-
+#ifdef CONFIG_X86_64
+        if (base > UINT_MAX)
+                return -ERANGE;
+#endif
         printk(KERN_INFO "PMTMR IOPort override: 0x%04x -> 0x%04lx\n",
-               (unsigned int)pmtmr_ioport, base);
+               pmtmr_ioport, base);
         pmtmr_ioport = base;
 
         return 1;
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index cd303901eb5b..904e57558bb5 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -48,13 +48,13 @@ config DW_DMAC
           can be integrated in chips such as the Atmel AT32ap7000.
 
 config FSL_DMA
-        bool "Freescale MPC85xx/MPC83xx DMA support"
-        depends on PPC
+        tristate "Freescale Elo and Elo Plus DMA support"
+        depends on FSL_SOC
         select DMA_ENGINE
         ---help---
-          Enable support for the Freescale DMA engine. Now, it support
-          MPC8560/40, MPC8555, MPC8548 and MPC8641 processors.
-          The MPC8349, MPC8360 is also supported.
+          Enable support for the Freescale Elo and Elo Plus DMA controllers.
+          The Elo is the DMA controller on some 82xx and 83xx parts, and the
+          Elo Plus is the DMA controller on 85xx and 86xx parts.
 
 config MV_XOR
         bool "Marvell XOR engine support"
diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c
index a08d19704743..d1e381e35a9e 100644
--- a/drivers/dma/dmatest.c
+++ b/drivers/dma/dmatest.c
@@ -325,7 +325,12 @@ static enum dma_state_client dmatest_add_channel(struct dma_chan *chan)
         struct dmatest_thread   *thread;
         unsigned int            i;
 
-        dtc = kmalloc(sizeof(struct dmatest_chan), GFP_ATOMIC);
+        /* Have we already been told about this channel? */
+        list_for_each_entry(dtc, &dmatest_channels, node)
+                if (dtc->chan == chan)
+                        return DMA_DUP;
+
+        dtc = kmalloc(sizeof(struct dmatest_chan), GFP_KERNEL);
         if (!dtc) {
                 pr_warning("dmatest: No memory for %s\n", chan->dev.bus_id);
                 return DMA_NAK;
diff --git a/drivers/dma/fsldma.c b/drivers/dma/fsldma.c
index c0059ca58340..0b95dcce447e 100644
--- a/drivers/dma/fsldma.c
+++ b/drivers/dma/fsldma.c
@@ -370,7 +370,10 @@ static int fsl_dma_alloc_chan_resources(struct dma_chan *chan,
                                         struct dma_client *client)
 {
         struct fsl_dma_chan *fsl_chan = to_fsl_chan(chan);
-        LIST_HEAD(tmp_list);
+
+        /* Has this channel already been allocated? */
+        if (fsl_chan->desc_pool)
+                return 1;
 
         /* We need the descriptor to be aligned to 32bytes
          * for meeting FSL DMA specification requirement.
@@ -410,6 +413,8 @@ static void fsl_dma_free_chan_resources(struct dma_chan *chan)
         }
         spin_unlock_irqrestore(&fsl_chan->desc_lock, flags);
         dma_pool_destroy(fsl_chan->desc_pool);
+
+        fsl_chan->desc_pool = NULL;
 }
 
 static struct dma_async_tx_descriptor *
@@ -786,159 +791,29 @@ static void dma_do_tasklet(unsigned long data)
         fsl_chan_ld_cleanup(fsl_chan);
 }
 
-static void fsl_dma_callback_test(void *param)
-{
-        struct fsl_dma_chan *fsl_chan = param;
-        if (fsl_chan)
-                dev_dbg(fsl_chan->dev, "selftest: callback is ok!\n");
-}
-
-static int fsl_dma_self_test(struct fsl_dma_chan *fsl_chan)
-{
-        struct dma_chan *chan;
-        int err = 0;
-        dma_addr_t dma_dest, dma_src;
-        dma_cookie_t cookie;
-        u8 *src, *dest;
-        int i;
-        size_t test_size;
-        struct dma_async_tx_descriptor *tx1, *tx2, *tx3;
-
-        test_size = 4096;
-
-        src = kmalloc(test_size * 2, GFP_KERNEL);
-        if (!src) {
-                dev_err(fsl_chan->dev,
-                                "selftest: Cannot alloc memory for test!\n");
-                return -ENOMEM;
-        }
-
-        dest = src + test_size;
-
-        for (i = 0; i < test_size; i++)
-                src[i] = (u8) i;
-
-        chan = &fsl_chan->common;
-
-        if (fsl_dma_alloc_chan_resources(chan, NULL) < 1) {
-                dev_err(fsl_chan->dev,
-                                "selftest: Cannot alloc resources for DMA\n");
-                err = -ENODEV;
-                goto out;
-        }
-
-        /* TX 1 */
-        dma_src = dma_map_single(fsl_chan->dev, src, test_size / 2,
-                                 DMA_TO_DEVICE);
-        dma_dest = dma_map_single(fsl_chan->dev, dest, test_size / 2,
-                                  DMA_FROM_DEVICE);
-        tx1 = fsl_dma_prep_memcpy(chan, dma_dest, dma_src, test_size / 2, 0);
-        async_tx_ack(tx1);
-
-        cookie = fsl_dma_tx_submit(tx1);
-        fsl_dma_memcpy_issue_pending(chan);
-        msleep(2);
-
-        if (fsl_dma_is_complete(chan, cookie, NULL, NULL) != DMA_SUCCESS) {
-                dev_err(fsl_chan->dev, "selftest: Time out!\n");
-                err = -ENODEV;
-                goto free_resources;
-        }
-
-        /* Test free and re-alloc channel resources */
-        fsl_dma_free_chan_resources(chan);
-
-        if (fsl_dma_alloc_chan_resources(chan, NULL) < 1) {
-                dev_err(fsl_chan->dev,
-                                "selftest: Cannot alloc resources for DMA\n");
-                err = -ENODEV;
-                goto free_resources;
-        }
-
-        /* Continue to test
-         * TX 2
-         */
-        dma_src = dma_map_single(fsl_chan->dev, src + test_size / 2,
-                                        test_size / 4, DMA_TO_DEVICE);
-        dma_dest = dma_map_single(fsl_chan->dev, dest + test_size / 2,
-                                        test_size / 4, DMA_FROM_DEVICE);
-        tx2 = fsl_dma_prep_memcpy(chan, dma_dest, dma_src, test_size / 4, 0);
-        async_tx_ack(tx2);
-
-        /* TX 3 */
-        dma_src = dma_map_single(fsl_chan->dev, src + test_size * 3 / 4,
-                                        test_size / 4, DMA_TO_DEVICE);
-        dma_dest = dma_map_single(fsl_chan->dev, dest + test_size * 3 / 4,
-                                        test_size / 4, DMA_FROM_DEVICE);
-        tx3 = fsl_dma_prep_memcpy(chan, dma_dest, dma_src, test_size / 4, 0);
-        async_tx_ack(tx3);
-
-        /* Interrupt tx test */
-        tx1 = fsl_dma_prep_interrupt(chan, 0);
-        async_tx_ack(tx1);
-        cookie = fsl_dma_tx_submit(tx1);
-
-        /* Test exchanging the prepared tx sort */
-        cookie = fsl_dma_tx_submit(tx3);
-        cookie = fsl_dma_tx_submit(tx2);
-
-        if (dma_has_cap(DMA_INTERRUPT, ((struct fsl_dma_device *)
-            dev_get_drvdata(fsl_chan->dev->parent))->common.cap_mask)) {
-                tx3->callback = fsl_dma_callback_test;
-                tx3->callback_param = fsl_chan;
-        }
-        fsl_dma_memcpy_issue_pending(chan);
-        msleep(2);
-
-        if (fsl_dma_is_complete(chan, cookie, NULL, NULL) != DMA_SUCCESS) {
-                dev_err(fsl_chan->dev, "selftest: Time out!\n");
-                err = -ENODEV;
-                goto free_resources;
-        }
-
-        err = memcmp(src, dest, test_size);
-        if (err) {
-                for (i = 0; (*(src + i) == *(dest + i)) && (i < test_size);
-                                i++);
-                dev_err(fsl_chan->dev, "selftest: Test failed, data %d/%ld is "
-                                "error! src 0x%x, dest 0x%x\n",
-                                i, (long)test_size, *(src + i), *(dest + i));
-        }
-
-free_resources:
-        fsl_dma_free_chan_resources(chan);
-out:
-        kfree(src);
-        return err;
-}
-
-static int __devinit of_fsl_dma_chan_probe(struct of_device *dev,
-                        const struct of_device_id *match)
+static int __devinit fsl_dma_chan_probe(struct fsl_dma_device *fdev,
+        struct device_node *node, u32 feature, const char *compatible)
 {
-        struct fsl_dma_device *fdev;
         struct fsl_dma_chan *new_fsl_chan;
         int err;
 
-        fdev = dev_get_drvdata(dev->dev.parent);
-        BUG_ON(!fdev);
-
         /* alloc channel */
         new_fsl_chan = kzalloc(sizeof(struct fsl_dma_chan), GFP_KERNEL);
         if (!new_fsl_chan) {
-                dev_err(&dev->dev, "No free memory for allocating "
+                dev_err(fdev->dev, "No free memory for allocating "
                                 "dma channels!\n");
                 return -ENOMEM;
         }
 
         /* get dma channel register base */
-        err = of_address_to_resource(dev->node, 0, &new_fsl_chan->reg);
+        err = of_address_to_resource(node, 0, &new_fsl_chan->reg);
         if (err) {
-                dev_err(&dev->dev, "Can't get %s property 'reg'\n",
-                                dev->node->full_name);
+                dev_err(fdev->dev, "Can't get %s property 'reg'\n",
+                                node->full_name);
                 goto err_no_reg;
         }
 
-        new_fsl_chan->feature = *(u32 *)match->data;
+        new_fsl_chan->feature = feature;
 
         if (!fdev->feature)
                 fdev->feature = new_fsl_chan->feature;
@@ -948,13 +823,13 @@ static int __devinit of_fsl_dma_chan_probe(struct of_device *dev,
          */
         WARN_ON(fdev->feature != new_fsl_chan->feature);
 
-        new_fsl_chan->dev = &dev->dev;
+        new_fsl_chan->dev = &new_fsl_chan->common.dev;
         new_fsl_chan->reg_base = ioremap(new_fsl_chan->reg.start,
                         new_fsl_chan->reg.end - new_fsl_chan->reg.start + 1);
 
         new_fsl_chan->id = ((new_fsl_chan->reg.start - 0x100) & 0xfff) >> 7;
         if (new_fsl_chan->id > FSL_DMA_MAX_CHANS_PER_DEVICE) {
-                dev_err(&dev->dev, "There is no %d channel!\n",
+                dev_err(fdev->dev, "There is no %d channel!\n",
                                 new_fsl_chan->id);
                 err = -EINVAL;
                 goto err_no_chan;
@@ -988,29 +863,23 @@ static int __devinit of_fsl_dma_chan_probe(struct of_device *dev,
                         &fdev->common.channels);
         fdev->common.chancnt++;
 
-        new_fsl_chan->irq = irq_of_parse_and_map(dev->node, 0);
+        new_fsl_chan->irq = irq_of_parse_and_map(node, 0);
         if (new_fsl_chan->irq != NO_IRQ) {
                 err = request_irq(new_fsl_chan->irq,
                                         &fsl_dma_chan_do_interrupt, IRQF_SHARED,
                                         "fsldma-channel", new_fsl_chan);
                 if (err) {
-                        dev_err(&dev->dev, "DMA channel %s request_irq error "
-                                "with return %d\n", dev->node->full_name, err);
+                        dev_err(fdev->dev, "DMA channel %s request_irq error "
+                                "with return %d\n", node->full_name, err);
                         goto err_no_irq;
                 }
         }
 
-        err = fsl_dma_self_test(new_fsl_chan);
-        if (err)
-                goto err_self_test;
-
-        dev_info(&dev->dev, "#%d (%s), irq %d\n", new_fsl_chan->id,
-                                match->compatible, new_fsl_chan->irq);
+        dev_info(fdev->dev, "#%d (%s), irq %d\n", new_fsl_chan->id,
+                                compatible, new_fsl_chan->irq);
 
         return 0;
 
-err_self_test:
-        free_irq(new_fsl_chan->irq, new_fsl_chan);
 err_no_irq:
         list_del(&new_fsl_chan->common.device_node);
 err_no_chan:
@@ -1020,38 +889,20 @@ err_no_reg:
         return err;
 }
 
-const u32 mpc8540_dma_ip_feature = FSL_DMA_IP_85XX | FSL_DMA_BIG_ENDIAN;
-const u32 mpc8349_dma_ip_feature = FSL_DMA_IP_83XX | FSL_DMA_LITTLE_ENDIAN;
-
-static struct of_device_id of_fsl_dma_chan_ids[] = {
-        {
-                .compatible = "fsl,eloplus-dma-channel",
-                .data = (void *)&mpc8540_dma_ip_feature,
-        },
-        {
-                .compatible = "fsl,elo-dma-channel",
-                .data = (void *)&mpc8349_dma_ip_feature,
-        },
-        {}
-};
-
-static struct of_platform_driver of_fsl_dma_chan_driver = {
-        .name = "of-fsl-dma-channel",
-        .match_table = of_fsl_dma_chan_ids,
-        .probe = of_fsl_dma_chan_probe,
-};
-
-static __init int of_fsl_dma_chan_init(void)
+static void fsl_dma_chan_remove(struct fsl_dma_chan *fchan)
 {
-        return of_register_platform_driver(&of_fsl_dma_chan_driver);
+        free_irq(fchan->irq, fchan);
+        list_del(&fchan->common.device_node);
+        iounmap(fchan->reg_base);
+        kfree(fchan);
 }
 
 static int __devinit of_fsl_dma_probe(struct of_device *dev,
                         const struct of_device_id *match)
 {
         int err;
-        unsigned int irq;
         struct fsl_dma_device *fdev;
+        struct device_node *child;
 
         fdev = kzalloc(sizeof(struct fsl_dma_device), GFP_KERNEL);
         if (!fdev) {
@@ -1085,9 +936,9 @@ static int __devinit of_fsl_dma_probe(struct of_device *dev,
         fdev->common.device_issue_pending = fsl_dma_memcpy_issue_pending;
         fdev->common.dev = &dev->dev;
 
-        irq = irq_of_parse_and_map(dev->node, 0);
-        if (irq != NO_IRQ) {
-                err = request_irq(irq, &fsl_dma_do_interrupt, IRQF_SHARED,
+        fdev->irq = irq_of_parse_and_map(dev->node, 0);
+        if (fdev->irq != NO_IRQ) {
+                err = request_irq(fdev->irq, &fsl_dma_do_interrupt, IRQF_SHARED,
                                         "fsldma-device", fdev);
                 if (err) {
                         dev_err(&dev->dev, "DMA device request_irq error "
@@ -1097,7 +948,21 @@ static int __devinit of_fsl_dma_probe(struct of_device *dev,
         }
 
         dev_set_drvdata(&(dev->dev), fdev);
-        of_platform_bus_probe(dev->node, of_fsl_dma_chan_ids, &dev->dev);
+
+        /* We cannot use of_platform_bus_probe() because there is no
+         * of_platform_bus_remove.  Instead, we manually instantiate every DMA
+         * channel object.
+         */
+        for_each_child_of_node(dev->node, child) {
+                if (of_device_is_compatible(child, "fsl,eloplus-dma-channel"))
+                        fsl_dma_chan_probe(fdev, child,
+                                FSL_DMA_IP_85XX | FSL_DMA_BIG_ENDIAN,
+                                "fsl,eloplus-dma-channel");
+                if (of_device_is_compatible(child, "fsl,elo-dma-channel"))
+                        fsl_dma_chan_probe(fdev, child,
+                                FSL_DMA_IP_83XX | FSL_DMA_LITTLE_ENDIAN,
+                                "fsl,elo-dma-channel");
+        }
 
         dma_async_device_register(&fdev->common);
         return 0;
@@ -1109,6 +974,30 @@ err_no_reg:
         return err;
 }
 
+static int of_fsl_dma_remove(struct of_device *of_dev)
+{
+        struct fsl_dma_device *fdev;
+        unsigned int i;
+
+        fdev = dev_get_drvdata(&of_dev->dev);
+
+        dma_async_device_unregister(&fdev->common);
+
+        for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++)
+                if (fdev->chan[i])
+                        fsl_dma_chan_remove(fdev->chan[i]);
+
+        if (fdev->irq != NO_IRQ)
+                free_irq(fdev->irq, fdev);
+
+        iounmap(fdev->reg_base);
+
+        kfree(fdev);
+        dev_set_drvdata(&of_dev->dev, NULL);
+
+        return 0;
+}
+
 static struct of_device_id of_fsl_dma_ids[] = {
         { .compatible = "fsl,eloplus-dma", },
         { .compatible = "fsl,elo-dma", },
@@ -1116,15 +1005,32 @@ static struct of_device_id of_fsl_dma_ids[] = {
 };
 
 static struct of_platform_driver of_fsl_dma_driver = {
-        .name = "of-fsl-dma",
+        .name = "fsl-elo-dma",
         .match_table = of_fsl_dma_ids,
         .probe = of_fsl_dma_probe,
+        .remove = of_fsl_dma_remove,
 };
 
 static __init int of_fsl_dma_init(void)
 {
-        return of_register_platform_driver(&of_fsl_dma_driver);
+        int ret;
+
+        pr_info("Freescale Elo / Elo Plus DMA driver\n");
+
+        ret = of_register_platform_driver(&of_fsl_dma_driver);
+        if (ret)
+                pr_err("fsldma: failed to register platform driver\n");
+
+        return ret;
+}
+
+static void __exit of_fsl_dma_exit(void)
+{
+        of_unregister_platform_driver(&of_fsl_dma_driver);
 }
 
-subsys_initcall(of_fsl_dma_chan_init);
 subsys_initcall(of_fsl_dma_init);
+module_exit(of_fsl_dma_exit);
+
+MODULE_DESCRIPTION("Freescale Elo / Elo Plus DMA driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/dma/fsldma.h b/drivers/dma/fsldma.h
index 6faf07ba0d0e..4f21a512d848 100644
--- a/drivers/dma/fsldma.h
+++ b/drivers/dma/fsldma.h
@@ -114,6 +114,7 @@ struct fsl_dma_device {
         struct dma_device common;
         struct fsl_dma_chan *chan[FSL_DMA_MAX_CHANS_PER_DEVICE];
         u32 feature;            /* The same as DMA channels */
+        int irq;                /* Channel IRQ */
 };
 
 /* Define macros for fsl_dma_chan->feature property */
diff --git a/drivers/dma/ioat_dma.c b/drivers/dma/ioat_dma.c
index bc8c6e3470ca..1ef68b315657 100644
--- a/drivers/dma/ioat_dma.c
+++ b/drivers/dma/ioat_dma.c
@@ -971,11 +971,9 @@ static struct ioat_desc_sw *ioat_dma_get_next_descriptor(
         switch (ioat_chan->device->version) {
         case IOAT_VER_1_2:
                 return ioat1_dma_get_next_descriptor(ioat_chan);
-                break;
         case IOAT_VER_2_0:
         case IOAT_VER_3_0:
                 return ioat2_dma_get_next_descriptor(ioat_chan);
-                break;
         }
         return NULL;
 }
diff --git a/drivers/edac/cell_edac.c b/drivers/edac/cell_edac.c
index 0e024fe2d8c4..887072f5dc8b 100644
--- a/drivers/edac/cell_edac.c
+++ b/drivers/edac/cell_edac.c
@@ -142,7 +142,7 @@ static void __devinit cell_edac_init_csrows(struct mem_ctl_info *mci)
                 csrow->nr_pages = (r.end - r.start + 1) >> PAGE_SHIFT;
                 csrow->last_page = csrow->first_page + csrow->nr_pages - 1;
                 csrow->mtype = MEM_XDR;
-                csrow->edac_mode = EDAC_FLAG_EC | EDAC_FLAG_SECDED;
+                csrow->edac_mode = EDAC_SECDED;
                 dev_dbg(mci->dev,
                         "Initialized on node %d, chanmask=0x%x,"
                         " first_page=0x%lx, nr_pages=0x%x\n",
diff --git a/drivers/firmware/iscsi_ibft.c b/drivers/firmware/iscsi_ibft.c
index deb154aa47c4..4353414a0b77 100644
--- a/drivers/firmware/iscsi_ibft.c
+++ b/drivers/firmware/iscsi_ibft.c
@@ -732,7 +732,6 @@ static int __init ibft_create_attribute(struct ibft_kobject *kobj_data,
 
         attr->attr.name = name;
         attr->attr.mode = S_IRUSR;
-        attr->attr.owner = THIS_MODULE;
 
         attr->hdr = hdr;
         attr->show = show;
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 9112830107a5..faa1cc66e9cf 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -248,7 +248,7 @@ static ssize_t gpio_value_show(struct device *dev,
         if (!test_bit(FLAG_EXPORT, &desc->flags))
                 status = -EIO;
         else
-                status = sprintf(buf, "%d\n", gpio_get_value_cansleep(gpio));
+                status = sprintf(buf, "%d\n", !!gpio_get_value_cansleep(gpio));
 
         mutex_unlock(&sysfs_lock);
         return status;
@@ -1105,7 +1105,7 @@ int gpio_get_value_cansleep(unsigned gpio)
 
         might_sleep_if(extra_checks);
         chip = gpio_to_chip(gpio);
-        return chip->get(chip, gpio - chip->base);
+        return chip->get ? chip->get(chip, gpio - chip->base) : 0;
 }
 EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
 
@@ -1143,7 +1143,7 @@ static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 
                 if (!is_out) {
                         int             irq = gpio_to_irq(gpio);
-                        struct irq_desc *desc = irq_desc + irq;
+                        struct irq_desc *desc = irq_to_desc(irq);
 
                         /* This races with request_irq(), set_irq_type(),
                          * and set_irq_wake() ... but those are "rare".
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index 9097500de5f4..a8b33c2ec8d2 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -6,7 +6,7 @@
 #
 menuconfig DRM
         tristate "Direct Rendering Manager (XFree86 4.1.0 and higher DRI support)"
-        depends on (AGP || AGP=n) && PCI && !EMULATED_CMPXCHG && SHMEM
+        depends on (AGP || AGP=n) && PCI && !EMULATED_CMPXCHG && MMU
         help
           Kernel-level support for the Direct Rendering Infrastructure (DRI)
           introduced in XFree86 4.0. If you say Y here, you need to select
diff --git a/drivers/gpu/drm/drm_proc.c b/drivers/gpu/drm/drm_proc.c
index d490db4c0de0..ae73b7f7249a 100644
--- a/drivers/gpu/drm/drm_proc.c
+++ b/drivers/gpu/drm/drm_proc.c
@@ -522,12 +522,12 @@ static int drm_gem_one_name_info(int id, void *ptr, void *data)
         struct drm_gem_object *obj = ptr;
         struct drm_gem_name_info_data   *nid = data;
 
-        DRM_INFO("name %d size %d\n", obj->name, obj->size);
+        DRM_INFO("name %d size %zd\n", obj->name, obj->size);
         if (nid->eof)
                 return 0;
 
         nid->len += sprintf(&nid->buf[nid->len],
-                            "%6d%9d%8d%9d\n",
+                            "%6d %8zd %7d %8d\n",
                             obj->name, obj->size,
                             atomic_read(&obj->handlecount.refcount),
                             atomic_read(&obj->refcount.refcount));
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 9ac73dd1b422..dc2e6fdb6ca3 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -171,6 +171,37 @@ i915_gem_pread_ioctl(struct drm_device *dev, void *data,
         return 0;
 }
 
+/*
+ * Try to write quickly with an atomic kmap. Return true on success.
+ *
+ * If this fails (which includes a partial write), we'll redo the whole
+ * thing with the slow version.
+ *
+ * This is a workaround for the low performance of iounmap (approximate
+ * 10% cpu cost on normal 3D workloads).  kmap_atomic on HIGHMEM kernels
+ * happens to let us map card memory without taking IPIs.  When the vmap
+ * rework lands we should be able to dump this hack.
+ */
+static inline int fast_user_write(unsigned long pfn, char __user *user_data,
+                                  int l, int o)
+{
+#ifdef CONFIG_HIGHMEM
+        unsigned long unwritten;
+        char *vaddr_atomic;
+
+        vaddr_atomic = kmap_atomic_pfn(pfn, KM_USER0);
+#if WATCH_PWRITE
+        DRM_INFO("pwrite i %d o %d l %d pfn %ld vaddr %p\n",
+                 i, o, l, pfn, vaddr_atomic);
+#endif
+        unwritten = __copy_from_user_inatomic_nocache(vaddr_atomic + o, user_data, l);
+        kunmap_atomic(vaddr_atomic, KM_USER0);
+        return !unwritten;
+#else
+        return 0;
+#endif
+}
+
 static int
 i915_gem_gtt_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
                     struct drm_i915_gem_pwrite *args,
@@ -180,12 +211,7 @@ i915_gem_gtt_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
         ssize_t remain;
         loff_t offset;
         char __user *user_data;
-        char __iomem *vaddr;
-        char *vaddr_atomic;
-        int i, o, l;
         int ret = 0;
-        unsigned long pfn;
-        unsigned long unwritten;
 
         user_data = (char __user *) (uintptr_t) args->data_ptr;
         remain = args->size;
@@ -209,6 +235,9 @@ i915_gem_gtt_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
         obj_priv->dirty = 1;
 
         while (remain > 0) {
+                unsigned long pfn;
+                int i, o, l;
+
                 /* Operation in this page
                  *
                  * i = page number
@@ -223,25 +252,10 @@ i915_gem_gtt_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
 
                 pfn = (dev->agp->base >> PAGE_SHIFT) + i;
 
-#ifdef CONFIG_HIGHMEM
-                /* This is a workaround for the low performance of iounmap
-                 * (approximate 10% cpu cost on normal 3D workloads).
-                 * kmap_atomic on HIGHMEM kernels happens to let us map card
-                 * memory without taking IPIs.  When the vmap rework lands
-                 * we should be able to dump this hack.
-                 */
-                vaddr_atomic = kmap_atomic_pfn(pfn, KM_USER0);
-#if WATCH_PWRITE
-                DRM_INFO("pwrite i %d o %d l %d pfn %ld vaddr %p\n",
-                         i, o, l, pfn, vaddr_atomic);
-#endif
-                unwritten = __copy_from_user_inatomic_nocache(vaddr_atomic + o,
-                                                              user_data, l);
-                kunmap_atomic(vaddr_atomic, KM_USER0);
+                if (!fast_user_write(pfn, user_data, l, o)) {
+                        unsigned long unwritten;
+                        char __iomem *vaddr;
 
-                if (unwritten)
-#endif /* CONFIG_HIGHMEM */
-                {
                         vaddr = ioremap_wc(pfn << PAGE_SHIFT, PAGE_SIZE);
 #if WATCH_PWRITE
                         DRM_INFO("pwrite slow i %d o %d l %d "
diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
index b06b8e090a27..bc011da79e14 100644
--- a/drivers/hwmon/applesmc.c
+++ b/drivers/hwmon/applesmc.c
@@ -49,6 +49,9 @@
 
 #define APPLESMC_MAX_DATA_LENGTH 32
 
+#define APPLESMC_MIN_WAIT       0x0040
+#define APPLESMC_MAX_WAIT       0x8000
+
 #define APPLESMC_STATUS_MASK    0x0f
 #define APPLESMC_READ_CMD       0x10
 #define APPLESMC_WRITE_CMD      0x11
@@ -57,8 +60,8 @@
 
 #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 LIGHT_SENSOR_LEFT_KEY   "ALV0" /* r-o {alv (6-10 bytes) */
+#define LIGHT_SENSOR_RIGHT_KEY  "ALV1" /* r-o {alv (6-10 bytes) */
 #define BACKLIGHT_KEY           "LKSB" /* w-o {lkb (2 bytes) */
 
 #define CLAMSHELL_KEY           "MSLD" /* r-o ui8 (unused) */
@@ -104,6 +107,15 @@ static const char* temperature_sensors_sets[][36] = {
 /* Set 6: Macbook3 set */
         { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TTF0", "TW0P", "Th0H",
           "Th0S", "Th1H", NULL },
+/* Set 7: Macbook Air */
+        { "TB0T", "TB1S", "TB1T", "TB2S", "TB2T", "TC0D", "TC0P", "TCFP",
+          "TTF0", "TW0P", "Th0H", "Tp0P", "TpFP", "Ts0P", "Ts0S", NULL },
+/* Set 8: Macbook Pro 4,1 (Penryn) */
+        { "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P", "Th0H",
+          "Th1H", "Th2H", "Tm0P", "Ts0P", NULL },
+/* Set 9: Macbook Pro 3,1 (Santa Rosa) */
+        { "TALP", "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P",
+          "Th0H", "Th1H", "Th2H", "Tm0P", "Ts0P", NULL },
 };
 
 /* List of keys used to read/write fan speeds */
@@ -163,25 +175,25 @@ 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
+ * __wait_status - Wait up to 32ms 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;
+        int us;
 
         val = val & APPLESMC_STATUS_MASK;
 
-        for (i = 0; i < 200; i++) {
+        for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
+                udelay(us);
                 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == val) {
                         if (debug)
                                 printk(KERN_DEBUG
-                                                "Waited %d us for status %x\n",
-                                                i*10, val);
+                                        "Waited %d us for status %x\n",
+                                        2 * us - APPLESMC_MIN_WAIT, val);
                         return 0;
                 }
-                udelay(10);
         }
 
         printk(KERN_WARNING "applesmc: wait status failed: %x != %x\n",
@@ -191,6 +203,25 @@ static int __wait_status(u8 val)
 }
 
 /*
+ * special treatment of command port - on newer macbooks, it seems necessary
+ * to resend the command byte before polling the status again. Callers must
+ * hold applesmc_lock.
+ */
+static int send_command(u8 cmd)
+{
+        int us;
+        for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
+                outb(cmd, APPLESMC_CMD_PORT);
+                udelay(us);
+                if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == 0x0c)
+                        return 0;
+        }
+        printk(KERN_WARNING "applesmc: command failed: %x -> %x\n",
+                cmd, 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.
@@ -205,8 +236,7 @@ static int applesmc_read_key(const char* key, u8* buffer, u8 len)
                 return -EINVAL;
         }
 
-        outb(APPLESMC_READ_CMD, APPLESMC_CMD_PORT);
-        if (__wait_status(0x0c))
+        if (send_command(APPLESMC_READ_CMD))
                 return -EIO;
 
         for (i = 0; i < 4; i++) {
@@ -249,8 +279,7 @@ static int applesmc_write_key(const char* key, u8* buffer, u8 len)
                 return -EINVAL;
         }
 
-        outb(APPLESMC_WRITE_CMD, APPLESMC_CMD_PORT);
-        if (__wait_status(0x0c))
+        if (send_command(APPLESMC_WRITE_CMD))
                 return -EIO;
 
         for (i = 0; i < 4; i++) {
@@ -284,8 +313,7 @@ static int applesmc_get_key_at_index(int index, char* key)
         readkey[2] = index >> 8;
         readkey[3] = index;
 
-        outb(APPLESMC_GET_KEY_BY_INDEX_CMD, APPLESMC_CMD_PORT);
-        if (__wait_status(0x0c))
+        if (send_command(APPLESMC_GET_KEY_BY_INDEX_CMD))
                 return -EIO;
 
         for (i = 0; i < 4; i++) {
@@ -315,8 +343,7 @@ 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))
+        if (send_command(APPLESMC_GET_KEY_TYPE_CMD))
                 return -EIO;
 
         for (i = 0; i < 4; i++) {
@@ -325,7 +352,7 @@ static int applesmc_get_key_type(char* key, char* type)
                         return -EIO;
         }
 
-        outb(5, APPLESMC_DATA_PORT);
+        outb(6, APPLESMC_DATA_PORT);
 
         for (i = 0; i < 6; i++) {
                 if (__wait_status(0x05))
@@ -527,17 +554,27 @@ out:
 static ssize_t applesmc_light_show(struct device *dev,
                                 struct device_attribute *attr, char *sysfsbuf)
 {
+        static int data_length;
         int ret;
         u8 left = 0, right = 0;
-        u8 buffer[6];
+        u8 buffer[10], query[6];
 
         mutex_lock(&applesmc_lock);
 
-        ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, 6);
+        if (!data_length) {
+                ret = applesmc_get_key_type(LIGHT_SENSOR_LEFT_KEY, query);
+                if (ret)
+                        goto out;
+                data_length = clamp_val(query[0], 0, 10);
+                printk(KERN_INFO "applesmc: light sensor data length set to "
+                        "%d\n", data_length);
+        }
+
+        ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length);
         left = buffer[2];
         if (ret)
                 goto out;
-        ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, 6);
+        ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length);
         right = buffer[2];
 
 out:
@@ -1233,39 +1270,57 @@ static __initdata struct dmi_match_data applesmc_dmi_data[] = {
         { .accelerometer = 0, .light = 0, .temperature_set = 5 },
 /* MacBook3: accelerometer and temperature set 6 */
         { .accelerometer = 1, .light = 0, .temperature_set = 6 },
+/* MacBook Air: accelerometer, backlight and temperature set 7 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 7 },
+/* MacBook Pro 4: accelerometer, backlight and temperature set 8 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 8 },
+/* MacBook Pro 3: accelerometer, backlight and temperature set 9 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 9 },
 };
 
 /* 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 Air", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },
+                &applesmc_dmi_data[7]},
+        { applesmc_dmi_match, "Apple MacBook Pro 4", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro4") },
+                &applesmc_dmi_data[8]},
+        { applesmc_dmi_match, "Apple MacBook Pro 3", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3") },
+                &applesmc_dmi_data[9]},
         { 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_data[0]},
         { applesmc_dmi_match, "Apple MacBook (v2)", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook2") },
-                (void*)&applesmc_dmi_data[1]},
+                &applesmc_dmi_data[1]},
         { applesmc_dmi_match, "Apple MacBook (v3)", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook3") },
-                (void*)&applesmc_dmi_data[6]},
+                &applesmc_dmi_data[6]},
         { applesmc_dmi_match, "Apple MacBook", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
-                (void*)&applesmc_dmi_data[2]},
+                &applesmc_dmi_data[2]},
         { applesmc_dmi_match, "Apple Macmini", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"Macmini") },
-                (void*)&applesmc_dmi_data[3]},
+                &applesmc_dmi_data[3]},
         { applesmc_dmi_match, "Apple MacPro2", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacPro2") },
-                (void*)&applesmc_dmi_data[4]},
+                &applesmc_dmi_data[4]},
         { applesmc_dmi_match, "Apple iMac", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"iMac") },
-                (void*)&applesmc_dmi_data[5]},
+                &applesmc_dmi_data[5]},
         { .ident = NULL }
 };
 
diff --git a/drivers/hwmon/pc87360.c b/drivers/hwmon/pc87360.c
index 9b462bb13fa3..5fbfa34c110e 100644
--- a/drivers/hwmon/pc87360.c
+++ b/drivers/hwmon/pc87360.c
@@ -75,7 +75,8 @@ MODULE_PARM_DESC(force_id, "Override the detected device ID");
 #define FSCM    0x09    /* Logical device: fans */
 #define VLM     0x0d    /* Logical device: voltages */
 #define TMS     0x0e    /* Logical device: temperatures */
-static const u8 logdev[3] = { FSCM, VLM, TMS };
+#define LDNI_MAX 3
+static const u8 logdev[LDNI_MAX] = { FSCM, VLM, TMS };
 
 #define LD_FAN          0
 #define LD_IN           1
@@ -489,11 +490,66 @@ static struct sensor_device_attribute in_max[] = {
         SENSOR_ATTR(in10_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 10),
 };
 
+/* (temp & vin) channel status register alarm bits (pdf sec.11.5.12) */
+#define CHAN_ALM_MIN    0x02    /* min limit crossed */
+#define CHAN_ALM_MAX    0x04    /* max limit exceeded */
+#define TEMP_ALM_CRIT   0x08    /* temp crit exceeded (temp only) */
+
+/* show_in_min/max_alarm() reads data from the per-channel status
+   register (sec 11.5.12), not the vin event status registers (sec
+   11.5.2) that (legacy) show_in_alarm() resds (via data->in_alarms) */
+
+static ssize_t show_in_min_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN));
+}
+static ssize_t show_in_max_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX));
+}
+
+static struct sensor_device_attribute in_min_alarm[] = {
+        SENSOR_ATTR(in0_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 0),
+        SENSOR_ATTR(in1_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 1),
+        SENSOR_ATTR(in2_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 2),
+        SENSOR_ATTR(in3_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 3),
+        SENSOR_ATTR(in4_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 4),
+        SENSOR_ATTR(in5_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 5),
+        SENSOR_ATTR(in6_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 6),
+        SENSOR_ATTR(in7_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 7),
+        SENSOR_ATTR(in8_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 8),
+        SENSOR_ATTR(in9_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 9),
+        SENSOR_ATTR(in10_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 10),
+};
+static struct sensor_device_attribute in_max_alarm[] = {
+        SENSOR_ATTR(in0_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 0),
+        SENSOR_ATTR(in1_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 1),
+        SENSOR_ATTR(in2_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 2),
+        SENSOR_ATTR(in3_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 3),
+        SENSOR_ATTR(in4_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 4),
+        SENSOR_ATTR(in5_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 5),
+        SENSOR_ATTR(in6_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 6),
+        SENSOR_ATTR(in7_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 7),
+        SENSOR_ATTR(in8_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 8),
+        SENSOR_ATTR(in9_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 9),
+        SENSOR_ATTR(in10_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 10),
+};
+
 #define VIN_UNIT_ATTRS(X) \
         &in_input[X].dev_attr.attr,     \
         &in_status[X].dev_attr.attr,    \
         &in_min[X].dev_attr.attr,       \
-        &in_max[X].dev_attr.attr
+        &in_max[X].dev_attr.attr,       \
+        &in_min_alarm[X].dev_attr.attr, \
+        &in_max_alarm[X].dev_attr.attr
 
 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -658,12 +714,68 @@ static struct sensor_device_attribute therm_crit[] = {
                     show_therm_crit, set_therm_crit, 2+11),
 };
 
+/* show_therm_min/max_alarm() reads data from the per-channel voltage
+   status register (sec 11.5.12) */
+
+static ssize_t show_therm_min_alarm(struct device *dev,
+                                struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN));
+}
+static ssize_t show_therm_max_alarm(struct device *dev,
+                                struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX));
+}
+static ssize_t show_therm_crit_alarm(struct device *dev,
+                                struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & TEMP_ALM_CRIT));
+}
+
+static struct sensor_device_attribute therm_min_alarm[] = {
+        SENSOR_ATTR(temp4_min_alarm, S_IRUGO,
+                    show_therm_min_alarm, NULL, 0+11),
+        SENSOR_ATTR(temp5_min_alarm, S_IRUGO,
+                    show_therm_min_alarm, NULL, 1+11),
+        SENSOR_ATTR(temp6_min_alarm, S_IRUGO,
+                    show_therm_min_alarm, NULL, 2+11),
+};
+static struct sensor_device_attribute therm_max_alarm[] = {
+        SENSOR_ATTR(temp4_max_alarm, S_IRUGO,
+                    show_therm_max_alarm, NULL, 0+11),
+        SENSOR_ATTR(temp5_max_alarm, S_IRUGO,
+                    show_therm_max_alarm, NULL, 1+11),
+        SENSOR_ATTR(temp6_max_alarm, S_IRUGO,
+                    show_therm_max_alarm, NULL, 2+11),
+};
+static struct sensor_device_attribute therm_crit_alarm[] = {
+        SENSOR_ATTR(temp4_crit_alarm, S_IRUGO,
+                    show_therm_crit_alarm, NULL, 0+11),
+        SENSOR_ATTR(temp5_crit_alarm, S_IRUGO,
+                    show_therm_crit_alarm, NULL, 1+11),
+        SENSOR_ATTR(temp6_crit_alarm, S_IRUGO,
+                    show_therm_crit_alarm, NULL, 2+11),
+};
+
 #define THERM_UNIT_ATTRS(X) \
         &therm_input[X].dev_attr.attr,  \
         &therm_status[X].dev_attr.attr, \
         &therm_min[X].dev_attr.attr,    \
         &therm_max[X].dev_attr.attr,    \
-        &therm_crit[X].dev_attr.attr
+        &therm_crit[X].dev_attr.attr,   \
+        &therm_min_alarm[X].dev_attr.attr, \
+        &therm_max_alarm[X].dev_attr.attr, \
+        &therm_crit_alarm[X].dev_attr.attr
 
 static struct attribute * pc8736x_therm_attr_array[] = {
         THERM_UNIT_ATTRS(0),
@@ -790,12 +902,76 @@ static ssize_t show_temp_alarms(struct device *dev, struct device_attribute *att
 }
 static DEVICE_ATTR(alarms_temp, S_IRUGO, show_temp_alarms, NULL);
 
+/* show_temp_min/max_alarm() reads data from the per-channel status
+   register (sec 12.3.7), not the temp event status registers (sec
+   12.3.2) that show_temp_alarm() reads (via data->temp_alarms) */
+
+static ssize_t show_temp_min_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MIN));
+}
+static ssize_t show_temp_max_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MAX));
+}
+static ssize_t show_temp_crit_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_ALM_CRIT));
+}
+
+static struct sensor_device_attribute temp_min_alarm[] = {
+        SENSOR_ATTR(temp1_min_alarm, S_IRUGO, show_temp_min_alarm, NULL, 0),
+        SENSOR_ATTR(temp2_min_alarm, S_IRUGO, show_temp_min_alarm, NULL, 1),
+        SENSOR_ATTR(temp3_min_alarm, S_IRUGO, show_temp_min_alarm, NULL, 2),
+};
+static struct sensor_device_attribute temp_max_alarm[] = {
+        SENSOR_ATTR(temp1_max_alarm, S_IRUGO, show_temp_max_alarm, NULL, 0),
+        SENSOR_ATTR(temp2_max_alarm, S_IRUGO, show_temp_max_alarm, NULL, 1),
+        SENSOR_ATTR(temp3_max_alarm, S_IRUGO, show_temp_max_alarm, NULL, 2),
+};
+static struct sensor_device_attribute temp_crit_alarm[] = {
+        SENSOR_ATTR(temp1_crit_alarm, S_IRUGO, show_temp_crit_alarm, NULL, 0),
+        SENSOR_ATTR(temp2_crit_alarm, S_IRUGO, show_temp_crit_alarm, NULL, 1),
+        SENSOR_ATTR(temp3_crit_alarm, S_IRUGO, show_temp_crit_alarm, NULL, 2),
+};
+
+#define TEMP_FAULT      0x40    /* open diode */
+static ssize_t show_temp_fault(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_FAULT));
+}
+static struct sensor_device_attribute temp_fault[] = {
+        SENSOR_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0),
+        SENSOR_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1),
+        SENSOR_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2),
+};
+
 #define TEMP_UNIT_ATTRS(X) \
         &temp_input[X].dev_attr.attr,   \
         &temp_status[X].dev_attr.attr,  \
         &temp_min[X].dev_attr.attr,     \
         &temp_max[X].dev_attr.attr,     \
-        &temp_crit[X].dev_attr.attr
+        &temp_crit[X].dev_attr.attr,    \
+        &temp_min_alarm[X].dev_attr.attr, \
+        &temp_max_alarm[X].dev_attr.attr, \
+        &temp_crit_alarm[X].dev_attr.attr, \
+        &temp_fault[X].dev_attr.attr
 
 static struct attribute * pc8736x_temp_attr_array[] = {
         TEMP_UNIT_ATTRS(0),
@@ -809,8 +985,8 @@ static const struct attribute_group pc8736x_temp_group = {
         .attrs = pc8736x_temp_attr_array,
 };
 
-static ssize_t show_name(struct device *dev, struct device_attribute
-                         *devattr, char *buf)
+static ssize_t show_name(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
 {
         struct pc87360_data *data = dev_get_drvdata(dev);
         return sprintf(buf, "%s\n", data->name);
@@ -955,7 +1131,7 @@ static int __devinit pc87360_probe(struct platform_device *pdev)
         mutex_init(&data->update_lock);
         platform_set_drvdata(pdev, data);
 
-        for (i = 0; i < 3; i++) {
+        for (i = 0; i < LDNI_MAX; i++) {
                 if (((data->address[i] = extra_isa[i]))
                  && !request_region(extra_isa[i], PC87360_EXTENT,
                                     pc87360_driver.driver.name)) {
@@ -1031,7 +1207,15 @@ static int __devinit pc87360_probe(struct platform_device *pdev)
                             || (err = device_create_file(dev,
                                         &temp_crit[i].dev_attr))
                             || (err = device_create_file(dev,
-                                        &temp_status[i].dev_attr)))
+                                        &temp_status[i].dev_attr))
+                            || (err = device_create_file(dev,
+                                        &temp_min_alarm[i].dev_attr))
+                            || (err = device_create_file(dev,
+                                        &temp_max_alarm[i].dev_attr))
+                            || (err = device_create_file(dev,
+                                        &temp_crit_alarm[i].dev_attr))
+                            || (err = device_create_file(dev,
+                                        &temp_fault[i].dev_attr)))
                                 goto ERROR3;
                 }
                 if ((err = device_create_file(dev, &dev_attr_alarms_temp)))
@@ -1131,6 +1315,16 @@ static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
         mutex_unlock(&(data->lock));
 }
 
+/* (temp & vin) channel conversion status register flags (pdf sec.11.5.12) */
+#define CHAN_CNVRTD     0x80    /* new data ready */
+#define CHAN_ENA        0x01    /* enabled channel (temp or vin) */
+#define CHAN_ALM_ENA    0x10    /* propagate to alarms-reg ?? (chk val!) */
+#define CHAN_READY      (CHAN_ENA|CHAN_CNVRTD) /* sample ready mask */
+
+#define TEMP_OTS_OE     0x20    /* OTS Output Enable */
+#define VIN_RW1C_MASK   (CHAN_READY|CHAN_ALM_MAX|CHAN_ALM_MIN)   /* 0x87 */
+#define TEMP_RW1C_MASK  (VIN_RW1C_MASK|TEMP_ALM_CRIT|TEMP_FAULT) /* 0xCF */
+
 static void pc87360_init_device(struct platform_device *pdev,
                                 int use_thermistors)
 {
@@ -1152,11 +1346,12 @@ static void pc87360_init_device(struct platform_device *pdev,
 
         nr = data->innr < 11 ? data->innr : 11;
         for (i = 0; i < nr; i++) {
+                reg = pc87360_read_value(data, LD_IN, i,
+                                         PC87365_REG_IN_STATUS);
+                dev_dbg(&pdev->dev, "bios in%d status:0x%02x\n", i, reg);
                 if (init >= init_in[i]) {
                         /* Forcibly enable voltage channel */
-                        reg = pc87360_read_value(data, LD_IN, i,
-                                                 PC87365_REG_IN_STATUS);
-                        if (!(reg & 0x01)) {
+                        if (!(reg & CHAN_ENA)) {
                                 dev_dbg(&pdev->dev, "Forcibly "
                                         "enabling in%d\n", i);
                                 pc87360_write_value(data, LD_IN, i,
@@ -1168,19 +1363,24 @@ static void pc87360_init_device(struct platform_device *pdev,
 
         /* We can't blindly trust the Super-I/O space configuration bit,
            most BIOS won't set it properly */
+        dev_dbg(&pdev->dev, "bios thermistors:%d\n", use_thermistors);
         for (i = 11; i < data->innr; i++) {
                 reg = pc87360_read_value(data, LD_IN, i,
                                          PC87365_REG_TEMP_STATUS);
-                use_thermistors = use_thermistors || (reg & 0x01);
+                use_thermistors = use_thermistors || (reg & CHAN_ENA);
+                /* thermistors are temp[4-6], measured on vin[11-14] */
+                dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i-7, reg);
         }
+        dev_dbg(&pdev->dev, "using thermistors:%d\n", use_thermistors);
 
         i = use_thermistors ? 2 : 0;
         for (; i < data->tempnr; i++) {
+                reg = pc87360_read_value(data, LD_TEMP, i,
+                                         PC87365_REG_TEMP_STATUS);
+                dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i+1, reg);
                 if (init >= init_temp[i]) {
                         /* Forcibly enable temperature channel */
-                        reg = pc87360_read_value(data, LD_TEMP, i,
-                                                 PC87365_REG_TEMP_STATUS);
-                        if (!(reg & 0x01)) {
+                        if (!(reg & CHAN_ENA)) {
                                 dev_dbg(&pdev->dev, "Forcibly "
                                         "enabling temp%d\n", i+1);
                                 pc87360_write_value(data, LD_TEMP, i,
@@ -1197,7 +1397,7 @@ static void pc87360_init_device(struct platform_device *pdev,
                                    diodes */
                                 reg = pc87360_read_value(data, LD_TEMP,
                                       (i-11)/2, PC87365_REG_TEMP_STATUS);
-                                if (reg & 0x01) {
+                                if (reg & CHAN_ENA) {
                                         dev_dbg(&pdev->dev, "Skipping "
                                                 "temp%d, pin already in use "
                                                 "by temp%d\n", i-7, (i-11)/2);
@@ -1207,7 +1407,7 @@ static void pc87360_init_device(struct platform_device *pdev,
                                 /* Forcibly enable thermistor channel */
                                 reg = pc87360_read_value(data, LD_IN, i,
                                                          PC87365_REG_IN_STATUS);
-                                if (!(reg & 0x01)) {
+                                if (!(reg & CHAN_ENA)) {
                                         dev_dbg(&pdev->dev, "Forcibly "
                                                 "enabling temp%d\n", i-7);
                                         pc87360_write_value(data, LD_IN, i,
@@ -1221,7 +1421,8 @@ static void pc87360_init_device(struct platform_device *pdev,
         if (data->innr) {
                 reg = pc87360_read_value(data, LD_IN, NO_BANK,
                                          PC87365_REG_IN_CONFIG);
-                if (reg & 0x01) {
+                dev_dbg(&pdev->dev, "bios vin-cfg:0x%02x\n", reg);
+                if (reg & CHAN_ENA) {
                         dev_dbg(&pdev->dev, "Forcibly "
                                 "enabling monitoring (VLM)\n");
                         pc87360_write_value(data, LD_IN, NO_BANK,
@@ -1233,7 +1434,8 @@ static void pc87360_init_device(struct platform_device *pdev,
         if (data->tempnr) {
                 reg = pc87360_read_value(data, LD_TEMP, NO_BANK,
                                          PC87365_REG_TEMP_CONFIG);
-                if (reg & 0x01) {
+                dev_dbg(&pdev->dev, "bios temp-cfg:0x%02x\n", reg);
+                if (reg & CHAN_ENA) {
                         dev_dbg(&pdev->dev, "Forcibly enabling "
                                 "monitoring (TMS)\n");
                         pc87360_write_value(data, LD_TEMP, NO_BANK,
@@ -1336,11 +1538,11 @@ static struct pc87360_data *pc87360_update_device(struct device *dev)
                         pc87360_write_value(data, LD_IN, i,
                                             PC87365_REG_IN_STATUS,
                                             data->in_status[i]);
-                        if ((data->in_status[i] & 0x81) == 0x81) {
+                        if ((data->in_status[i] & CHAN_READY) == CHAN_READY) {
                                 data->in[i] = pc87360_read_value(data, LD_IN,
                                               i, PC87365_REG_IN);
                         }
-                        if (data->in_status[i] & 0x01) {
+                        if (data->in_status[i] & CHAN_ENA) {
                                 data->in_min[i] = pc87360_read_value(data,
                                                   LD_IN, i,
                                                   PC87365_REG_IN_MIN);
@@ -1373,12 +1575,12 @@ static struct pc87360_data *pc87360_update_device(struct device *dev)
                         pc87360_write_value(data, LD_TEMP, i,
                                             PC87365_REG_TEMP_STATUS,
                                             data->temp_status[i]);
-                        if ((data->temp_status[i] & 0x81) == 0x81) {
+                        if ((data->temp_status[i] & CHAN_READY) == CHAN_READY) {
                                 data->temp[i] = pc87360_read_value(data,
                                                 LD_TEMP, i,
                                                 PC87365_REG_TEMP);
                         }
-                        if (data->temp_status[i] & 0x01) {
+                        if (data->temp_status[i] & CHAN_ENA) {
                                 data->temp_min[i] = pc87360_read_value(data,
                                                     LD_TEMP, i,
                                                     PC87365_REG_TEMP_MIN);
diff --git a/drivers/i2c/busses/i2c-amd756.c b/drivers/i2c/busses/i2c-amd756.c
index 1ea39254dac6..424dad6f18d8 100644
--- a/drivers/i2c/busses/i2c-amd756.c
+++ b/drivers/i2c/busses/i2c-amd756.c
@@ -332,10 +332,6 @@ static int __devinit amd756_probe(struct pci_dev *pdev,
         int error;
         u8 temp;
         
-        /* driver_data might come from user-space, so check it */
-        if (id->driver_data >= ARRAY_SIZE(chipname))
-                return -EINVAL;
-
         if (amd756_ioport) {
                 dev_err(&pdev->dev, "Only one device supported "
                        "(you have a strange motherboard, btw)\n");
@@ -412,7 +408,6 @@ static struct pci_driver amd756_driver = {
         .id_table       = amd756_ids,
         .probe          = amd756_probe,
         .remove         = __devexit_p(amd756_remove),
-        .dynids.use_driver_data = 1,
 };
 
 static int __init amd756_init(void)
diff --git a/drivers/i2c/busses/i2c-viapro.c b/drivers/i2c/busses/i2c-viapro.c
index 73dc52e114eb..9f194d9efd91 100644
--- a/drivers/i2c/busses/i2c-viapro.c
+++ b/drivers/i2c/busses/i2c-viapro.c
@@ -332,10 +332,6 @@ static int __devinit vt596_probe(struct pci_dev *pdev,
         unsigned char temp;
         int error = -ENODEV;
 
-        /* driver_data might come from user-space, so check it */
-        if (id->driver_data & 1 || id->driver_data > 0xff)
-                return -EINVAL;
-
         /* Determine the address of the SMBus areas */
         if (force_addr) {
                 vt596_smba = force_addr & 0xfff0;
@@ -483,7 +479,6 @@ static struct pci_driver vt596_driver = {
         .name           = "vt596_smbus",
         .id_table       = vt596_ids,
         .probe          = vt596_probe,
-        .dynids.use_driver_data = 1,
 };
 
 static int __init i2c_vt596_init(void)
diff --git a/drivers/i2c/chips/at24.c b/drivers/i2c/chips/at24.c
index 2a4acb269569..d4775528abc6 100644
--- a/drivers/i2c/chips/at24.c
+++ b/drivers/i2c/chips/at24.c
@@ -460,7 +460,6 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
          */
         at24->bin.attr.name = "eeprom";
         at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR;
-        at24->bin.attr.owner = THIS_MODULE;
         at24->bin.read = at24_bin_read;
         at24->bin.size = chip.byte_len;
 
diff --git a/drivers/i2c/chips/ds1682.c b/drivers/i2c/chips/ds1682.c
index 23be4d42cb02..f3ee4a1abb77 100644
--- a/drivers/i2c/chips/ds1682.c
+++ b/drivers/i2c/chips/ds1682.c
@@ -190,7 +190,6 @@ static struct bin_attribute ds1682_eeprom_attr = {
         .attr = {
                 .name = "eeprom",
                 .mode = S_IRUGO | S_IWUSR,
-                .owner = THIS_MODULE,
         },
         .size = DS1682_EEPROM_SIZE,
         .read = ds1682_eeprom_read,
diff --git a/drivers/i2c/chips/menelaus.c b/drivers/i2c/chips/menelaus.c
index 176126d3a01d..4b364bae6b3e 100644
--- a/drivers/i2c/chips/menelaus.c
+++ b/drivers/i2c/chips/menelaus.c
@@ -832,52 +832,52 @@ static irqreturn_t menelaus_irq(int irq, void *_menelaus)
 
 static void menelaus_to_time(char *regs, struct rtc_time *t)
 {
-        t->tm_sec = BCD2BIN(regs[0]);
-        t->tm_min = BCD2BIN(regs[1]);
+        t->tm_sec = bcd2bin(regs[0]);
+        t->tm_min = bcd2bin(regs[1]);
         if (the_menelaus->rtc_control & RTC_CTRL_MODE12) {
-                t->tm_hour = BCD2BIN(regs[2] & 0x1f) - 1;
+                t->tm_hour = bcd2bin(regs[2] & 0x1f) - 1;
                 if (regs[2] & RTC_HR_PM)
                         t->tm_hour += 12;
         } else
-                t->tm_hour = BCD2BIN(regs[2] & 0x3f);
-        t->tm_mday = BCD2BIN(regs[3]);
-        t->tm_mon = BCD2BIN(regs[4]) - 1;
-        t->tm_year = BCD2BIN(regs[5]) + 100;
+                t->tm_hour = bcd2bin(regs[2] & 0x3f);
+        t->tm_mday = bcd2bin(regs[3]);
+        t->tm_mon = bcd2bin(regs[4]) - 1;
+        t->tm_year = bcd2bin(regs[5]) + 100;
 }
 
 static int time_to_menelaus(struct rtc_time *t, int regnum)
 {
         int     hour, status;
 
-        status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_sec));
+        status = menelaus_write_reg(regnum++, bin2bcd(t->tm_sec));
         if (status < 0)
                 goto fail;
 
-        status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_min));
+        status = menelaus_write_reg(regnum++, bin2bcd(t->tm_min));
         if (status < 0)
                 goto fail;
 
         if (the_menelaus->rtc_control & RTC_CTRL_MODE12) {
                 hour = t->tm_hour + 1;
                 if (hour > 12)
-                        hour = RTC_HR_PM | BIN2BCD(hour - 12);
+                        hour = RTC_HR_PM | bin2bcd(hour - 12);
                 else
-                        hour = BIN2BCD(hour);
+                        hour = bin2bcd(hour);
         } else
-                hour = BIN2BCD(t->tm_hour);
+                hour = bin2bcd(t->tm_hour);
         status = menelaus_write_reg(regnum++, hour);
         if (status < 0)
                 goto fail;
 
-        status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_mday));
+        status = menelaus_write_reg(regnum++, bin2bcd(t->tm_mday));
         if (status < 0)
                 goto fail;
 
-        status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_mon + 1));
+        status = menelaus_write_reg(regnum++, bin2bcd(t->tm_mon + 1));
         if (status < 0)
                 goto fail;
 
-        status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_year - 100));
+        status = menelaus_write_reg(regnum++, bin2bcd(t->tm_year - 100));
         if (status < 0)
                 goto fail;
 
@@ -914,7 +914,7 @@ static int menelaus_read_time(struct device *dev, struct rtc_time *t)
         }
 
         menelaus_to_time(regs, t);
-        t->tm_wday = BCD2BIN(regs[6]);
+        t->tm_wday = bcd2bin(regs[6]);
 
         return 0;
 }
@@ -927,7 +927,7 @@ static int menelaus_set_time(struct device *dev, struct rtc_time *t)
         status = time_to_menelaus(t, MENELAUS_RTC_SEC);
         if (status < 0)
                 return status;
-        status = menelaus_write_reg(MENELAUS_RTC_WKDAY, BIN2BCD(t->tm_wday));
+        status = menelaus_write_reg(MENELAUS_RTC_WKDAY, bin2bcd(t->tm_wday));
         if (status < 0) {
                 dev_err(&the_menelaus->client->dev, "rtc write reg %02x "
                                 "err %d\n", MENELAUS_RTC_WKDAY, status);
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index 74a369a6116f..a820ca6fc327 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -84,21 +84,40 @@ config BLK_DEV_IDE_SATA
 
           If unsure, say N.
 
-config BLK_DEV_IDEDISK
-        tristate "Include IDE/ATA-2 DISK support"
-        ---help---
-          This will include enhanced support for MFM/RLL/IDE hard disks.  If
-          you have a MFM/RLL/IDE disk, and there is no special reason to use
-          the old hard disk driver instead, say Y.  If you have an SCSI-only
-          system, you can say N here.
+config IDE_GD
+        tristate "generic ATA/ATAPI disk support"
+        default y
+        help
+          Support for ATA/ATAPI disks (including ATAPI floppy drives).
 
-          To compile this driver as a module, choose M here: the
-          module will be called ide-disk.
-          Do not compile this driver as a module if your root file system
-          (the one containing the directory /) is located on the IDE disk.
+          To compile this driver as a module, choose M here.
+          The module will be called ide-gd_mod.
+
+          If unsure, say Y.
+
+config IDE_GD_ATA
+        bool "ATA disk support"
+        depends on IDE_GD
+        default y
+        help
+          This will include support for ATA hard disks.
 
           If unsure, say Y.
 
+config IDE_GD_ATAPI
+        bool "ATAPI floppy support"
+        depends on IDE_GD
+        select IDE_ATAPI
+        help
+          This will include support for ATAPI floppy drives
+          (i.e. Iomega ZIP or MKE LS-120).
+
+          For information about jumper settings and the question
+          of when a ZIP drive uses a partition table, see
+          <http://www.win.tue.nl/~aeb/linux/zip/zip-1.html>.
+
+          If unsure, say N.
+
 config BLK_DEV_IDECS
         tristate "PCMCIA IDE support"
         depends on PCMCIA
@@ -163,29 +182,6 @@ config BLK_DEV_IDETAPE
           To compile this driver as a module, choose M here: the
           module will be called ide-tape.
 
-config BLK_DEV_IDEFLOPPY
-        tristate "Include IDE/ATAPI FLOPPY support"
-        select IDE_ATAPI
-        ---help---
-          If you have an IDE floppy drive which uses the ATAPI protocol,
-          answer Y.  ATAPI is a newer protocol used by IDE CD-ROM/tape/floppy
-          drives, similar to the SCSI protocol.
-
-          The LS-120 and the IDE/ATAPI Iomega ZIP drive are also supported by
-          this driver. For information about jumper settings and the question
-          of when a ZIP drive uses a partition table, see
-          <http://www.win.tue.nl/~aeb/linux/zip/zip-1.html>.
-          (ATAPI PD-CD/CDR drives are not supported by this driver; support
-          for PD-CD/CDR drives is available if you answer Y to
-          "SCSI emulation support", below).
-
-          If you say Y here, the FLOPPY drive will be identified along with
-          other IDE devices, as "hdb" or "hdc", or something similar (check
-          the boot messages with dmesg).
-
-          To compile this driver as a module, choose M here: the
-          module will be called ide-floppy.
-
 config BLK_DEV_IDESCSI
         tristate "SCSI emulation support (DEPRECATED)"
         depends on SCSI
@@ -332,7 +328,7 @@ config IDEPCI_PCIBUS_ORDER
 # TODO: split it on per host driver config options (or module parameters)
 config BLK_DEV_OFFBOARD
         bool "Boot off-board chipsets first support (DEPRECATED)"
-        depends on BLK_DEV_IDEPCI && (BLK_DEV_AEC62XX || BLK_DEV_GENERIC || BLK_DEV_HPT34X || BLK_DEV_HPT366 || BLK_DEV_PDC202XX_NEW || BLK_DEV_PDC202XX_OLD || BLK_DEV_TC86C001)
+        depends on BLK_DEV_IDEPCI && (BLK_DEV_AEC62XX || BLK_DEV_GENERIC || BLK_DEV_HPT366 || BLK_DEV_PDC202XX_NEW || BLK_DEV_PDC202XX_OLD || BLK_DEV_TC86C001)
         help
           Normally, IDE controllers built into the motherboard (on-board
           controllers) are assigned to ide0 and ide1 while those on add-in PCI
@@ -482,28 +478,6 @@ config BLK_DEV_CS5535
 
           It is safe to say Y to this question.
 
-config BLK_DEV_HPT34X
-        tristate "HPT34X chipset support"
-        depends on BROKEN
-        select BLK_DEV_IDEDMA_PCI
-        help
-          This driver adds up to 4 more EIDE devices sharing a single
-          interrupt. The HPT343 chipset in its current form is a non-bootable
-          controller; the HPT345/HPT363 chipset is a bootable (needs BIOS FIX)
-          PCI UDMA controllers. This driver requires dynamic tuning of the
-          chipset during the ide-probe at boot time. It is reported to support
-          DVD II drives, by the manufacturer.
-
-config HPT34X_AUTODMA
-        bool "HPT34X AUTODMA support (EXPERIMENTAL)"
-        depends on BLK_DEV_HPT34X && EXPERIMENTAL
-        help
-          This is a dangerous thing to attempt currently! Please read the
-          comments at the top of <file:drivers/ide/pci/hpt34x.c>.  If you say Y
-          here, then say Y to "Use DMA by default when available" as well.
-
-          If unsure, say N.
-
 config BLK_DEV_HPT366
         tristate "HPT36X/37X chipset support"
         select BLK_DEV_IDEDMA_PCI
diff --git a/drivers/ide/Makefile b/drivers/ide/Makefile
index ceaf779054ea..093d3248ca89 100644
--- a/drivers/ide/Makefile
+++ b/drivers/ide/Makefile
@@ -37,18 +37,25 @@ obj-$(CONFIG_IDE_H8300)			+= h8300/
 obj-$(CONFIG_IDE_GENERIC)               += ide-generic.o
 obj-$(CONFIG_BLK_DEV_IDEPNP)            += ide-pnp.o
 
-ide-disk_mod-y += ide-disk.o ide-disk_ioctl.o
+ide-gd_mod-y += ide-gd.o
 ide-cd_mod-y += ide-cd.o ide-cd_ioctl.o ide-cd_verbose.o
-ide-floppy_mod-y += ide-floppy.o ide-floppy_ioctl.o
 
+ifeq ($(CONFIG_IDE_GD_ATA), y)
+        ide-gd_mod-y += ide-disk.o ide-disk_ioctl.o
 ifeq ($(CONFIG_IDE_PROC_FS), y)
-        ide-disk_mod-y += ide-disk_proc.o
-        ide-floppy_mod-y += ide-floppy_proc.o
+        ide-gd_mod-y += ide-disk_proc.o
+endif
+endif
+
+ifeq ($(CONFIG_IDE_GD_ATAPI), y)
+        ide-gd_mod-y += ide-floppy.o ide-floppy_ioctl.o
+ifeq ($(CONFIG_IDE_PROC_FS), y)
+        ide-gd_mod-y += ide-floppy_proc.o
+endif
 endif
 
-obj-$(CONFIG_BLK_DEV_IDEDISK)           += ide-disk_mod.o
+obj-$(CONFIG_IDE_GD)                    += ide-gd_mod.o
 obj-$(CONFIG_BLK_DEV_IDECD)             += ide-cd_mod.o
-obj-$(CONFIG_BLK_DEV_IDEFLOPPY)         += ide-floppy_mod.o
 obj-$(CONFIG_BLK_DEV_IDETAPE)           += ide-tape.o
 
 ifeq ($(CONFIG_BLK_DEV_IDECS), y)
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index 2e305714c209..4e58b9e7a58a 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -191,7 +191,7 @@ int ide_set_media_lock(ide_drive_t *drive, struct gendisk *disk, int on)
 {
         struct ide_atapi_pc pc;
 
-        if (drive->atapi_flags & IDE_AFLAG_NO_DOORLOCK)
+        if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
                 return 0;
 
         ide_init_pc(&pc);
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 3308b1cd3a33..13265a8827da 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -99,7 +99,7 @@ static void ide_cd_put(struct cdrom_info *cd)
 /* Mark that we've seen a media change and invalidate our internal buffers. */
 static void cdrom_saw_media_change(ide_drive_t *drive)
 {
-        drive->atapi_flags |= IDE_AFLAG_MEDIA_CHANGED;
+        drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
         drive->atapi_flags &= ~IDE_AFLAG_TOC_VALID;
 }
 
@@ -340,8 +340,8 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
         }
 
         ide_debug_log(IDE_DBG_RQ, "%s: stat: 0x%x, good_stat: 0x%x, "
-                      "rq->cmd_type: 0x%x, err: 0x%x\n", __func__, stat,
-                      good_stat, rq->cmd_type, err);
+                      "rq->cmd[0]: 0x%x, rq->cmd_type: 0x%x, err: 0x%x\n",
+                      __func__, stat, good_stat, rq->cmd[0], rq->cmd_type, err);
 
         if (blk_sense_request(rq)) {
                 /*
@@ -843,13 +843,10 @@ static void ide_cd_restore_request(ide_drive_t *drive, struct request *rq)
         rq->q->prep_rq_fn(rq->q, rq);
 }
 
-/*
- * All other packet commands.
- */
 static void ide_cd_request_sense_fixup(ide_drive_t *drive, struct request *rq)
 {
-
-        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
+        ide_debug_log(IDE_DBG_FUNC, "Call %s, rq->cmd[0]: 0x%x\n",
+                      __func__, rq->cmd[0]);
 
         /*
          * Some of the trailing request sense fields are optional,
@@ -876,7 +873,7 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
         if (!sense)
                 sense = &local_sense;
 
-        ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd[0]: 0x%x, write: 0x%x, "
+        ide_debug_log(IDE_DBG_PC, "Call %s, cmd[0]: 0x%x, write: 0x%x, "
                       "timeout: %d, cmd_flags: 0x%x\n", __func__, cmd[0], write,
                       timeout, cmd_flags);
 
@@ -1177,8 +1174,9 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
         unsigned short sectors_per_frame =
                 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
 
-        ide_debug_log(IDE_DBG_RQ, "Call %s, write: 0x%x, secs_per_frame: %u\n",
-                      __func__, write, sectors_per_frame);
+        ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd[0]: 0x%x, write: 0x%x, "
+                      "secs_per_frame: %u\n",
+                      __func__, rq->cmd[0], write, sectors_per_frame);
 
         if (write) {
                 /* disk has become write protected */
@@ -1221,7 +1219,8 @@ static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
 static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
 {
 
-        ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd_type: 0x%x\n", __func__,
+        ide_debug_log(IDE_DBG_PC, "Call %s, rq->cmd[0]: 0x%x, "
+                      "rq->cmd_type: 0x%x\n", __func__, rq->cmd[0],
                       rq->cmd_type);
 
         if (blk_pc_request(rq))
@@ -1257,9 +1256,6 @@ static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
         }
 }
 
-/*
- * cdrom driver request routine.
- */
 static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
                                         sector_t block)
 {
@@ -1267,8 +1263,10 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
         ide_handler_t *fn;
         int xferlen;
 
-        ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd_type: 0x%x, block: %llu\n",
-                      __func__, rq->cmd_type, (unsigned long long)block);
+        ide_debug_log(IDE_DBG_RQ, "Call %s, rq->cmd[0]: 0x%x, "
+                      "rq->cmd_type: 0x%x, block: %llu\n",
+                      __func__, rq->cmd[0], rq->cmd_type,
+                      (unsigned long long)block);
 
         if (blk_fs_request(rq)) {
                 if (drive->atapi_flags & IDE_AFLAG_SEEKING) {
@@ -1412,6 +1410,10 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
 
         *capacity = 1 + be32_to_cpu(capbuf.lba);
         *sectors_per_frame = blocklen >> SECTOR_BITS;
+
+        ide_debug_log(IDE_DBG_PROBE, "%s: cap: %lu, sectors_per_frame: %lu\n",
+                      __func__, *capacity, *sectors_per_frame);
+
         return 0;
 }
 
@@ -1643,6 +1645,9 @@ void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
                 maxspeed = be16_to_cpup((__be16 *)&buf[8 + 8]);
         }
 
+        ide_debug_log(IDE_DBG_PROBE, "%s: curspeed: %u, maxspeed: %u\n",
+                      __func__, curspeed, maxspeed);
+
         cd->current_speed = (curspeed + (176/2)) / 176;
         cd->max_speed = (maxspeed + (176/2)) / 176;
 }
@@ -1732,7 +1737,7 @@ static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
                 return 0;
 
         if ((buf[8 + 6] & 0x01) == 0)
-                drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
         if (buf[8 + 6] & 0x08)
                 drive->atapi_flags &= ~IDE_AFLAG_NO_EJECT;
         if (buf[8 + 3] & 0x01)
@@ -1777,7 +1782,7 @@ static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
         if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
                 printk(KERN_CONT " DVD%s%s",
                                  (cdi->mask & CDC_DVD_R) ? "" : "-R",
-                                 (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
+                                 (cdi->mask & CDC_DVD_RAM) ? "" : "/RAM");
 
         if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
                 printk(KERN_CONT " CD%s%s",
@@ -1908,6 +1913,16 @@ static const struct ide_proc_devset idecd_settings[] = {
         IDE_PROC_DEVSET(dsc_overlap, 0, 1),
         { 0 },
 };
+
+static ide_proc_entry_t *ide_cd_proc_entries(ide_drive_t *drive)
+{
+        return idecd_proc;
+}
+
+static const struct ide_proc_devset *ide_cd_proc_devsets(ide_drive_t *drive)
+{
+        return idecd_settings;
+}
 #endif
 
 static const struct cd_list_entry ide_cd_quirks_list[] = {
@@ -1986,8 +2001,8 @@ static int ide_cdrom_setup(ide_drive_t *drive)
         if (!drive->queue->unplug_delay)
                 drive->queue->unplug_delay = 1;
 
-        drive->atapi_flags = IDE_AFLAG_MEDIA_CHANGED | IDE_AFLAG_NO_EJECT |
-                       ide_cd_flags(id);
+        drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
+        drive->atapi_flags = IDE_AFLAG_NO_EJECT | ide_cd_flags(id);
 
         if ((drive->atapi_flags & IDE_AFLAG_VERTOS_300_SSD) &&
             fw_rev[4] == '1' && fw_rev[6] <= '2')
@@ -2069,8 +2084,8 @@ static ide_driver_t ide_cdrom_driver = {
         .end_request            = ide_end_request,
         .error                  = __ide_error,
 #ifdef CONFIG_IDE_PROC_FS
-        .proc                   = idecd_proc,
-        .settings               = idecd_settings,
+        .proc_entries           = ide_cd_proc_entries,
+        .proc_devsets           = ide_cd_proc_devsets,
 #endif
 };
 
diff --git a/drivers/ide/ide-cd_ioctl.c b/drivers/ide/ide-cd_ioctl.c
index 74231b41f611..df3df0041eb6 100644
--- a/drivers/ide/ide-cd_ioctl.c
+++ b/drivers/ide/ide-cd_ioctl.c
@@ -86,8 +86,8 @@ int ide_cdrom_check_media_change_real(struct cdrom_device_info *cdi,
 
         if (slot_nr == CDSL_CURRENT) {
                 (void) cdrom_check_status(drive, NULL);
-                retval = (drive->atapi_flags & IDE_AFLAG_MEDIA_CHANGED) ? 1 : 0;
-                drive->atapi_flags &= ~IDE_AFLAG_MEDIA_CHANGED;
+                retval = (drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED) ? 1 : 0;
+                drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
                 return retval;
         } else {
                 return -EINVAL;
@@ -136,7 +136,7 @@ int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
                 sense = &my_sense;
 
         /* If the drive cannot lock the door, just pretend. */
-        if (drive->atapi_flags & IDE_AFLAG_NO_DOORLOCK) {
+        if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0) {
                 stat = 0;
         } else {
                 unsigned char cmd[BLK_MAX_CDB];
@@ -157,7 +157,7 @@ int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
             (sense->asc == 0x24 || sense->asc == 0x20)) {
                 printk(KERN_ERR "%s: door locking not supported\n",
                         drive->name);
-                drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
                 stat = 0;
         }
 
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 3853bde8eedc..223750c1b5a6 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -14,9 +14,6 @@
  * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
  */
 
-#define IDEDISK_VERSION "1.18"
-
-#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
@@ -39,46 +36,8 @@
 #include <asm/io.h>
 #include <asm/div64.h>
 
-#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
-#define IDE_DISK_MINORS         (1 << PARTN_BITS)
-#else
-#define IDE_DISK_MINORS         0
-#endif
-
 #include "ide-disk.h"
 
-static DEFINE_MUTEX(idedisk_ref_mutex);
-
-#define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
-
-static void ide_disk_release(struct kref *);
-
-static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
-{
-        struct ide_disk_obj *idkp = NULL;
-
-        mutex_lock(&idedisk_ref_mutex);
-        idkp = ide_disk_g(disk);
-        if (idkp) {
-                if (ide_device_get(idkp->drive))
-                        idkp = NULL;
-                else
-                        kref_get(&idkp->kref);
-        }
-        mutex_unlock(&idedisk_ref_mutex);
-        return idkp;
-}
-
-static void ide_disk_put(struct ide_disk_obj *idkp)
-{
-        ide_drive_t *drive = idkp->drive;
-
-        mutex_lock(&idedisk_ref_mutex);
-        kref_put(&idkp->kref, ide_disk_release);
-        ide_device_put(drive);
-        mutex_unlock(&idedisk_ref_mutex);
-}
-
 static const u8 ide_rw_cmds[] = {
         ATA_CMD_READ_MULTI,
         ATA_CMD_WRITE_MULTI,
@@ -374,7 +333,7 @@ static void idedisk_check_hpa(ide_drive_t *drive)
         }
 }
 
-static void init_idedisk_capacity(ide_drive_t *drive)
+static int ide_disk_get_capacity(ide_drive_t *drive)
 {
         u16 *id = drive->id;
         int lba;
@@ -403,11 +362,28 @@ static void init_idedisk_capacity(ide_drive_t *drive)
                 if (ata_id_hpa_enabled(id))
                         idedisk_check_hpa(drive);
         }
-}
 
-sector_t ide_disk_capacity(ide_drive_t *drive)
-{
-        return drive->capacity64;
+        /* limit drive capacity to 137GB if LBA48 cannot be used */
+        if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
+            drive->capacity64 > 1ULL << 28) {
+                printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
+                       "%llu sectors (%llu MB)\n",
+                       drive->name, (unsigned long long)drive->capacity64,
+                       sectors_to_MB(drive->capacity64));
+                drive->capacity64 = 1ULL << 28;
+        }
+
+        if ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
+            (drive->dev_flags & IDE_DFLAG_LBA48)) {
+                if (drive->capacity64 > 1ULL << 28) {
+                        printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
+                                         " will be used for accessing sectors "
+                                         "> %u\n", drive->name, 1 << 28);
+                } else
+                        drive->dev_flags &= ~IDE_DFLAG_LBA48;
+        }
+
+        return 0;
 }
 
 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
@@ -508,7 +484,7 @@ static void update_ordered(ide_drive_t *drive)
                  * time we have trimmed the drive capacity if LBA48 is
                  * not available so we don't need to recheck that.
                  */
-                capacity = ide_disk_capacity(drive);
+                capacity = ide_gd_capacity(drive);
                 barrier = ata_id_flush_enabled(id) &&
                         (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 &&
                         ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 ||
@@ -616,7 +592,12 @@ ide_ext_devset_rw(wcache, wcache);
 
 ide_ext_devset_rw_sync(nowerr, nowerr);
 
-static void idedisk_setup(ide_drive_t *drive)
+static int ide_disk_check(ide_drive_t *drive, const char *s)
+{
+        return 1;
+}
+
+static void ide_disk_setup(ide_drive_t *drive)
 {
         struct ide_disk_obj *idkp = drive->driver_data;
         ide_hwif_t *hwif = drive->hwif;
@@ -652,33 +633,13 @@ static void idedisk_setup(ide_drive_t *drive)
                          drive->queue->max_sectors / 2);
 
         /* calculate drive capacity, and select LBA if possible */
-        init_idedisk_capacity(drive);
-
-        /* limit drive capacity to 137GB if LBA48 cannot be used */
-        if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
-            drive->capacity64 > 1ULL << 28) {
-                printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
-                       "%llu sectors (%llu MB)\n",
-                       drive->name, (unsigned long long)drive->capacity64,
-                       sectors_to_MB(drive->capacity64));
-                drive->capacity64 = 1ULL << 28;
-        }
-
-        if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
-            (drive->dev_flags & IDE_DFLAG_LBA48)) {
-                if (drive->capacity64 > 1ULL << 28) {
-                        printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
-                                         " will be used for accessing sectors "
-                                         "> %u\n", drive->name, 1 << 28);
-                } else
-                        drive->dev_flags &= ~IDE_DFLAG_LBA48;
-        }
+        ide_disk_get_capacity(drive);
 
         /*
          * if possible, give fdisk access to more of the drive,
          * by correcting bios_cyls:
          */
-        capacity = ide_disk_capacity(drive);
+        capacity = ide_gd_capacity(drive);
 
         if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
                 if (ata_id_lba48_enabled(drive->id)) {
@@ -718,9 +679,17 @@ static void idedisk_setup(ide_drive_t *drive)
                 drive->dev_flags |= IDE_DFLAG_WCACHE;
 
         set_wcache(drive, 1);
+
+        if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
+            (drive->head == 0 || drive->head > 16)) {
+                printk(KERN_ERR "%s: invalid geometry: %d physical heads?\n",
+                        drive->name, drive->head);
+                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
+        } else
+                drive->dev_flags |= IDE_DFLAG_ATTACH;
 }
 
-static void ide_cacheflush_p(ide_drive_t *drive)
+static void ide_disk_flush(ide_drive_t *drive)
 {
         if (ata_id_flush_enabled(drive->id) == 0 ||
             (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
@@ -730,267 +699,40 @@ static void ide_cacheflush_p(ide_drive_t *drive)
                 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
 }
 
-static void ide_disk_remove(ide_drive_t *drive)
-{
-        struct ide_disk_obj *idkp = drive->driver_data;
-        struct gendisk *g = idkp->disk;
-
-        ide_proc_unregister_driver(drive, idkp->driver);
-
-        del_gendisk(g);
-
-        ide_cacheflush_p(drive);
-
-        ide_disk_put(idkp);
-}
-
-static void ide_disk_release(struct kref *kref)
-{
-        struct ide_disk_obj *idkp = to_ide_disk(kref);
-        ide_drive_t *drive = idkp->drive;
-        struct gendisk *g = idkp->disk;
-
-        drive->driver_data = NULL;
-        g->private_data = NULL;
-        put_disk(g);
-        kfree(idkp);
-}
-
-static int ide_disk_probe(ide_drive_t *drive);
-
-/*
- * On HPA drives the capacity needs to be
- * reinitilized on resume otherwise the disk
- * can not be used and a hard reset is required
- */
-static void ide_disk_resume(ide_drive_t *drive)
+static int ide_disk_init_media(ide_drive_t *drive, struct gendisk *disk)
 {
-        if (ata_id_hpa_enabled(drive->id))
-                init_idedisk_capacity(drive);
-}
-
-static void ide_device_shutdown(ide_drive_t *drive)
-{
-#ifdef  CONFIG_ALPHA
-        /* On Alpha, halt(8) doesn't actually turn the machine off,
-           it puts you into the sort of firmware monitor. Typically,
-           it's used to boot another kernel image, so it's not much
-           different from reboot(8). Therefore, we don't need to
-           spin down the disk in this case, especially since Alpha
-           firmware doesn't handle disks in standby mode properly.
-           On the other hand, it's reasonably safe to turn the power
-           off when the shutdown process reaches the firmware prompt,
-           as the firmware initialization takes rather long time -
-           at least 10 seconds, which should be sufficient for
-           the disk to expire its write cache. */
-        if (system_state != SYSTEM_POWER_OFF) {
-#else
-        if (system_state == SYSTEM_RESTART) {
-#endif
-                ide_cacheflush_p(drive);
-                return;
-        }
-
-        printk(KERN_INFO "Shutdown: %s\n", drive->name);
-
-        drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
+        return 0;
 }
 
-static ide_driver_t idedisk_driver = {
-        .gen_driver = {
-                .owner          = THIS_MODULE,
-                .name           = "ide-disk",
-                .bus            = &ide_bus_type,
-        },
-        .probe                  = ide_disk_probe,
-        .remove                 = ide_disk_remove,
-        .resume                 = ide_disk_resume,
-        .shutdown               = ide_device_shutdown,
-        .version                = IDEDISK_VERSION,
-        .do_request             = ide_do_rw_disk,
-        .end_request            = ide_end_request,
-        .error                  = __ide_error,
-#ifdef CONFIG_IDE_PROC_FS
-        .proc                   = ide_disk_proc,
-        .settings               = ide_disk_settings,
-#endif
-};
-
-static int idedisk_set_doorlock(ide_drive_t *drive, int on)
+static int ide_disk_set_doorlock(ide_drive_t *drive, struct gendisk *disk,
+                                 int on)
 {
         ide_task_t task;
+        int ret;
+
+        if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
+                return 0;
 
         memset(&task, 0, sizeof(task));
         task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 
-        return ide_no_data_taskfile(drive, &task);
-}
-
-static int idedisk_open(struct inode *inode, struct file *filp)
-{
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_disk_obj *idkp;
-        ide_drive_t *drive;
-
-        idkp = ide_disk_get(disk);
-        if (idkp == NULL)
-                return -ENXIO;
-
-        drive = idkp->drive;
-
-        idkp->openers++;
-
-        if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
-                check_disk_change(inode->i_bdev);
-                /*
-                 * Ignore the return code from door_lock,
-                 * since the open() has already succeeded,
-                 * and the door_lock is irrelevant at this point.
-                 */
-                if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
-                    idedisk_set_doorlock(drive, 1))
-                        drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
-        }
-        return 0;
-}
-
-static int idedisk_release(struct inode *inode, struct file *filp)
-{
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_disk_obj *idkp = ide_disk_g(disk);
-        ide_drive_t *drive = idkp->drive;
-
-        if (idkp->openers == 1)
-                ide_cacheflush_p(drive);
-
-        if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
-                if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
-                    idedisk_set_doorlock(drive, 0))
-                        drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
-        }
+        ret = ide_no_data_taskfile(drive, &task);
 
-        idkp->openers--;
+        if (ret)
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
 
-        ide_disk_put(idkp);
-
-        return 0;
-}
-
-static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
-{
-        struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
-        ide_drive_t *drive = idkp->drive;
-
-        geo->heads = drive->bios_head;
-        geo->sectors = drive->bios_sect;
-        geo->cylinders = (u16)drive->bios_cyl; /* truncate */
-        return 0;
+        return ret;
 }
 
-static int idedisk_media_changed(struct gendisk *disk)
-{
-        struct ide_disk_obj *idkp = ide_disk_g(disk);
-        ide_drive_t *drive = idkp->drive;
-
-        /* do not scan partitions twice if this is a removable device */
-        if (drive->dev_flags & IDE_DFLAG_ATTACH) {
-                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
-                return 0;
-        }
-
-        /* if removable, always assume it was changed */
-        return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE);
-}
-
-static int idedisk_revalidate_disk(struct gendisk *disk)
-{
-        struct ide_disk_obj *idkp = ide_disk_g(disk);
-        set_capacity(disk, ide_disk_capacity(idkp->drive));
-        return 0;
-}
-
-static struct block_device_operations idedisk_ops = {
-        .owner                  = THIS_MODULE,
-        .open                   = idedisk_open,
-        .release                = idedisk_release,
-        .ioctl                  = ide_disk_ioctl,
-        .getgeo                 = idedisk_getgeo,
-        .media_changed          = idedisk_media_changed,
-        .revalidate_disk        = idedisk_revalidate_disk
+const struct ide_disk_ops ide_ata_disk_ops = {
+        .check          = ide_disk_check,
+        .get_capacity   = ide_disk_get_capacity,
+        .setup          = ide_disk_setup,
+        .flush          = ide_disk_flush,
+        .init_media     = ide_disk_init_media,
+        .set_doorlock   = ide_disk_set_doorlock,
+        .do_request     = ide_do_rw_disk,
+        .end_request    = ide_end_request,
+        .ioctl          = ide_disk_ioctl,
 };
-
-MODULE_DESCRIPTION("ATA DISK Driver");
-
-static int ide_disk_probe(ide_drive_t *drive)
-{
-        struct ide_disk_obj *idkp;
-        struct gendisk *g;
-
-        /* strstr("foo", "") is non-NULL */
-        if (!strstr("ide-disk", drive->driver_req))
-                goto failed;
-
-        if (drive->media != ide_disk)
-                goto failed;
-
-        idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
-        if (!idkp)
-                goto failed;
-
-        g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
-        if (!g)
-                goto out_free_idkp;
-
-        ide_init_disk(g, drive);
-
-        kref_init(&idkp->kref);
-
-        idkp->drive = drive;
-        idkp->driver = &idedisk_driver;
-        idkp->disk = g;
-
-        g->private_data = &idkp->driver;
-
-        drive->driver_data = idkp;
-
-        idedisk_setup(drive);
-        if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
-            (drive->head == 0 || drive->head > 16)) {
-                printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
-                        drive->name, drive->head);
-                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
-        } else
-                drive->dev_flags |= IDE_DFLAG_ATTACH;
-
-        g->minors = IDE_DISK_MINORS;
-        g->driverfs_dev = &drive->gendev;
-        g->flags |= GENHD_FL_EXT_DEVT;
-        if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
-                g->flags = GENHD_FL_REMOVABLE;
-        set_capacity(g, ide_disk_capacity(drive));
-        g->fops = &idedisk_ops;
-        add_disk(g);
-        return 0;
-
-out_free_idkp:
-        kfree(idkp);
-failed:
-        return -ENODEV;
-}
-
-static void __exit idedisk_exit(void)
-{
-        driver_unregister(&idedisk_driver.gen_driver);
-}
-
-static int __init idedisk_init(void)
-{
-        return driver_register(&idedisk_driver.gen_driver);
-}
-
-MODULE_ALIAS("ide:*m-disk*");
-MODULE_ALIAS("ide-disk");
-module_init(idedisk_init);
-module_exit(idedisk_exit);
-MODULE_LICENSE("GPL");
diff --git a/drivers/ide/ide-disk.h b/drivers/ide/ide-disk.h
index a82fa4355665..b234b0feaf7b 100644
--- a/drivers/ide/ide-disk.h
+++ b/drivers/ide/ide-disk.h
@@ -1,19 +1,11 @@
 #ifndef __IDE_DISK_H
 #define __IDE_DISK_H
 
-struct ide_disk_obj {
-        ide_drive_t     *drive;
-        ide_driver_t    *driver;
-        struct gendisk  *disk;
-        struct kref     kref;
-        unsigned int    openers;        /* protected by BKL for now */
-};
-
-#define ide_disk_g(disk) \
-        container_of((disk)->private_data, struct ide_disk_obj, driver)
+#include "ide-gd.h"
 
+#ifdef CONFIG_IDE_GD_ATA
 /* ide-disk.c */
-sector_t ide_disk_capacity(ide_drive_t *);
+extern const struct ide_disk_ops ide_ata_disk_ops;
 ide_decl_devset(address);
 ide_decl_devset(multcount);
 ide_decl_devset(nowerr);
@@ -21,12 +13,17 @@ ide_decl_devset(wcache);
 ide_decl_devset(acoustic);
 
 /* ide-disk_ioctl.c */
-int ide_disk_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
+int ide_disk_ioctl(ide_drive_t *, struct inode *, struct file *, unsigned int,
+                   unsigned long);
 
 #ifdef CONFIG_IDE_PROC_FS
 /* ide-disk_proc.c */
 extern ide_proc_entry_t ide_disk_proc[];
 extern const struct ide_proc_devset ide_disk_settings[];
 #endif
+#else
+#define ide_disk_proc           NULL
+#define ide_disk_settings       NULL
+#endif
 
 #endif /* __IDE_DISK_H */
diff --git a/drivers/ide/ide-disk_ioctl.c b/drivers/ide/ide-disk_ioctl.c
index a6cf1a03a806..a49698bcf966 100644
--- a/drivers/ide/ide-disk_ioctl.c
+++ b/drivers/ide/ide-disk_ioctl.c
@@ -13,12 +13,10 @@ static const struct ide_ioctl_devset ide_disk_ioctl_settings[] = {
 { 0 }
 };
 
-int ide_disk_ioctl(struct inode *inode, struct file *file,
+int ide_disk_ioctl(ide_drive_t *drive, struct inode *inode, struct file *file,
                    unsigned int cmd, unsigned long arg)
 {
         struct block_device *bdev = inode->i_bdev;
-        struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
-        ide_drive_t *drive = idkp->drive;
         int err;
 
         err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings);
diff --git a/drivers/ide/ide-disk_proc.c b/drivers/ide/ide-disk_proc.c
index 4724976afe71..1146f4204c6e 100644
--- a/drivers/ide/ide-disk_proc.c
+++ b/drivers/ide/ide-disk_proc.c
@@ -56,7 +56,7 @@ static int proc_idedisk_read_capacity
         ide_drive_t*drive = (ide_drive_t *)data;
         int len;
 
-        len = sprintf(page, "%llu\n", (long long)ide_disk_capacity(drive));
+        len = sprintf(page, "%llu\n", (long long)ide_gd_capacity(drive));
 
         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
diff --git a/drivers/ide/ide-dma-sff.c b/drivers/ide/ide-dma-sff.c
index 0903782689e9..cac431f0df17 100644
--- a/drivers/ide/ide-dma-sff.c
+++ b/drivers/ide/ide-dma-sff.c
@@ -130,7 +130,7 @@ int ide_build_dmatable(ide_drive_t *drive, struct request *rq)
                         xcount = bcount & 0xffff;
                         if (is_trm290)
                                 xcount = ((xcount >> 2) - 1) << 16;
-                        if (xcount == 0x0000) {
+                        else if (xcount == 0x0000) {
                                 if (count++ >= PRD_ENTRIES)
                                         goto use_pio_instead;
                                 *table++ = cpu_to_le32(0x8000);
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index cf0aa25470ee..aeb1ad782f54 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -15,12 +15,6 @@
  * Documentation/ide/ChangeLog.ide-floppy.1996-2002
  */
 
-#define DRV_NAME "ide-floppy"
-#define PFX DRV_NAME ": "
-
-#define IDEFLOPPY_VERSION "1.00"
-
-#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
@@ -49,19 +43,6 @@
 
 #include "ide-floppy.h"
 
-/* module parameters */
-static unsigned long debug_mask;
-module_param(debug_mask, ulong, 0644);
-
-/* define to see debug info */
-#define IDEFLOPPY_DEBUG_LOG     0
-
-#if IDEFLOPPY_DEBUG_LOG
-#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, args)
-#else
-#define ide_debug_log(lvl, fmt, args...) do {} while (0)
-#endif
-
 /*
  * After each failed packet command we issue a request sense command and retry
  * the packet command IDEFLOPPY_MAX_PC_RETRIES times.
@@ -83,43 +64,13 @@ module_param(debug_mask, ulong, 0644);
 /* Error code returned in rq->errors to the higher part of the driver. */
 #define IDEFLOPPY_ERROR_GENERAL         101
 
-static DEFINE_MUTEX(idefloppy_ref_mutex);
-
-static void idefloppy_cleanup_obj(struct kref *);
-
-static struct ide_floppy_obj *ide_floppy_get(struct gendisk *disk)
-{
-        struct ide_floppy_obj *floppy = NULL;
-
-        mutex_lock(&idefloppy_ref_mutex);
-        floppy = ide_drv_g(disk, ide_floppy_obj);
-        if (floppy) {
-                if (ide_device_get(floppy->drive))
-                        floppy = NULL;
-                else
-                        kref_get(&floppy->kref);
-        }
-        mutex_unlock(&idefloppy_ref_mutex);
-        return floppy;
-}
-
-static void ide_floppy_put(struct ide_floppy_obj *floppy)
-{
-        ide_drive_t *drive = floppy->drive;
-
-        mutex_lock(&idefloppy_ref_mutex);
-        kref_put(&floppy->kref, idefloppy_cleanup_obj);
-        ide_device_put(drive);
-        mutex_unlock(&idefloppy_ref_mutex);
-}
-
 /*
  * Used to finish servicing a request. For read/write requests, we will call
  * ide_end_request to pass to the next buffer.
  */
-static int idefloppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
+static int ide_floppy_end_request(ide_drive_t *drive, int uptodate, int nsecs)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct request *rq = HWGROUP(drive)->rq;
         int error;
 
@@ -161,12 +112,12 @@ static void idefloppy_update_buffers(ide_drive_t *drive,
         struct bio *bio = rq->bio;
 
         while ((bio = rq->bio) != NULL)
-                idefloppy_end_request(drive, 1, 0);
+                ide_floppy_end_request(drive, 1, 0);
 }
 
 static void ide_floppy_callback(ide_drive_t *drive, int dsc)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc *pc = drive->pc;
         int uptodate = pc->error ? 0 : 1;
 
@@ -200,10 +151,10 @@ static void ide_floppy_callback(ide_drive_t *drive, int dsc)
                                "Aborting request!\n");
         }
 
-        idefloppy_end_request(drive, uptodate, 0);
+        ide_floppy_end_request(drive, uptodate, 0);
 }
 
-static void ide_floppy_report_error(idefloppy_floppy_t *floppy,
+static void ide_floppy_report_error(struct ide_disk_obj *floppy,
                                     struct ide_atapi_pc *pc)
 {
         /* supress error messages resulting from Medium not present */
@@ -222,7 +173,7 @@ static void ide_floppy_report_error(idefloppy_floppy_t *floppy,
 static ide_startstop_t idefloppy_issue_pc(ide_drive_t *drive,
                 struct ide_atapi_pc *pc)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
 
         if (floppy->failed_pc == NULL &&
             pc->c[0] != GPCMD_REQUEST_SENSE)
@@ -286,7 +237,7 @@ static void idefloppy_create_rw_cmd(ide_drive_t *drive,
                                     struct ide_atapi_pc *pc, struct request *rq,
                                     unsigned long sector)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         int block = sector / floppy->bs_factor;
         int blocks = rq->nr_sectors / floppy->bs_factor;
         int cmd = rq_data_dir(rq);
@@ -310,7 +261,7 @@ static void idefloppy_create_rw_cmd(ide_drive_t *drive,
         pc->flags |= PC_FLAG_DMA_OK;
 }
 
-static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy,
+static void idefloppy_blockpc_cmd(struct ide_disk_obj *floppy,
                 struct ide_atapi_pc *pc, struct request *rq)
 {
         ide_init_pc(pc);
@@ -329,13 +280,12 @@ static void idefloppy_blockpc_cmd(idefloppy_floppy_t *floppy,
         pc->req_xfer = pc->buf_size = rq->data_len;
 }
 
-static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
-                struct request *rq, sector_t block_s)
+static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
+                                             struct request *rq, sector_t block)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         ide_hwif_t *hwif = drive->hwif;
         struct ide_atapi_pc *pc;
-        unsigned long block = (unsigned long)block_s;
 
         ide_debug_log(IDE_DBG_FUNC, "%s: dev: %s, cmd: 0x%x, cmd_type: %x, "
                       "errors: %d\n",
@@ -353,7 +303,7 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
                 else
                         printk(KERN_ERR PFX "%s: I/O error\n", drive->name);
 
-                idefloppy_end_request(drive, 0, 0);
+                ide_floppy_end_request(drive, 0, 0);
                 return ide_stopped;
         }
         if (blk_fs_request(rq)) {
@@ -361,11 +311,11 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
                     (rq->nr_sectors % floppy->bs_factor)) {
                         printk(KERN_ERR PFX "%s: unsupported r/w rq size\n",
                                 drive->name);
-                        idefloppy_end_request(drive, 0, 0);
+                        ide_floppy_end_request(drive, 0, 0);
                         return ide_stopped;
                 }
                 pc = &floppy->queued_pc;
-                idefloppy_create_rw_cmd(drive, pc, rq, block);
+                idefloppy_create_rw_cmd(drive, pc, rq, (unsigned long)block);
         } else if (blk_special_request(rq)) {
                 pc = (struct ide_atapi_pc *) rq->buffer;
         } else if (blk_pc_request(rq)) {
@@ -373,7 +323,7 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
                 idefloppy_blockpc_cmd(floppy, pc, rq);
         } else {
                 blk_dump_rq_flags(rq, PFX "unsupported command in queue");
-                idefloppy_end_request(drive, 0, 0);
+                ide_floppy_end_request(drive, 0, 0);
                 return ide_stopped;
         }
 
@@ -394,7 +344,7 @@ static ide_startstop_t idefloppy_do_request(ide_drive_t *drive,
  */
 static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct gendisk *disk = floppy->disk;
         struct ide_atapi_pc pc;
         u8 *page;
@@ -410,11 +360,11 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
         }
 
         if (pc.buf[3] & 0x80)
-                drive->atapi_flags |= IDE_AFLAG_WP;
+                drive->dev_flags |= IDE_DFLAG_WP;
         else
-                drive->atapi_flags &= ~IDE_AFLAG_WP;
+                drive->dev_flags &= ~IDE_DFLAG_WP;
 
-        set_disk_ro(disk, !!(drive->atapi_flags & IDE_AFLAG_WP));
+        set_disk_ro(disk, !!(drive->dev_flags & IDE_DFLAG_WP));
 
         page = &pc.buf[8];
 
@@ -445,7 +395,9 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
                         drive->name, lba_capacity, capacity);
                 floppy->blocks = floppy->block_size ?
                         capacity / floppy->block_size : 0;
+                drive->capacity64 = floppy->blocks * floppy->bs_factor;
         }
+
         return 0;
 }
 
@@ -455,7 +407,7 @@ static int ide_floppy_get_flexible_disk_page(ide_drive_t *drive)
  */
 static int ide_floppy_get_capacity(ide_drive_t *drive)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct gendisk *disk = floppy->disk;
         struct ide_atapi_pc pc;
         u8 *cap_desc;
@@ -466,7 +418,7 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
         drive->bios_head = drive->bios_sect = 0;
         floppy->blocks = 0;
         floppy->bs_factor = 1;
-        set_capacity(floppy->disk, 0);
+        drive->capacity64 = 0;
 
         ide_floppy_create_read_capacity_cmd(&pc);
         if (ide_queue_pc_tail(drive, disk, &pc)) {
@@ -523,6 +475,8 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
                                                "non 512 bytes block size not "
                                                "fully supported\n",
                                                drive->name);
+                                drive->capacity64 =
+                                        floppy->blocks * floppy->bs_factor;
                                 rc = 0;
                         }
                         break;
@@ -547,21 +501,12 @@ static int ide_floppy_get_capacity(ide_drive_t *drive)
         if (!(drive->atapi_flags & IDE_AFLAG_CLIK_DRIVE))
                 (void) ide_floppy_get_flexible_disk_page(drive);
 
-        set_capacity(disk, floppy->blocks * floppy->bs_factor);
-
         return rc;
 }
 
-sector_t ide_floppy_capacity(ide_drive_t *drive)
-{
-        idefloppy_floppy_t *floppy = drive->driver_data;
-        unsigned long capacity = floppy->blocks * floppy->bs_factor;
-
-        return capacity;
-}
-
-static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy)
+static void ide_floppy_setup(ide_drive_t *drive)
 {
+        struct ide_disk_obj *floppy = drive->driver_data;
         u16 *id = drive->id;
 
         drive->pc_callback       = ide_floppy_callback;
@@ -592,252 +537,42 @@ static void idefloppy_setup(ide_drive_t *drive, idefloppy_floppy_t *floppy)
                 blk_queue_max_sectors(drive->queue, 64);
                 drive->atapi_flags |= IDE_AFLAG_CLIK_DRIVE;
                 /* IOMEGA Clik! drives do not support lock/unlock commands */
-                drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
         }
 
         (void) ide_floppy_get_capacity(drive);
 
         ide_proc_register_driver(drive, floppy->driver);
-}
 
-static void ide_floppy_remove(ide_drive_t *drive)
-{
-        idefloppy_floppy_t *floppy = drive->driver_data;
-        struct gendisk *g = floppy->disk;
-
-        ide_proc_unregister_driver(drive, floppy->driver);
-
-        del_gendisk(g);
-
-        ide_floppy_put(floppy);
+        drive->dev_flags |= IDE_DFLAG_ATTACH;
 }
 
-static void idefloppy_cleanup_obj(struct kref *kref)
+static void ide_floppy_flush(ide_drive_t *drive)
 {
-        struct ide_floppy_obj *floppy = to_ide_drv(kref, ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
-        struct gendisk *g = floppy->disk;
-
-        drive->driver_data = NULL;
-        g->private_data = NULL;
-        put_disk(g);
-        kfree(floppy);
 }
 
-static int ide_floppy_probe(ide_drive_t *);
-
-static ide_driver_t idefloppy_driver = {
-        .gen_driver = {
-                .owner          = THIS_MODULE,
-                .name           = "ide-floppy",
-                .bus            = &ide_bus_type,
-        },
-        .probe                  = ide_floppy_probe,
-        .remove                 = ide_floppy_remove,
-        .version                = IDEFLOPPY_VERSION,
-        .do_request             = idefloppy_do_request,
-        .end_request            = idefloppy_end_request,
-        .error                  = __ide_error,
-#ifdef CONFIG_IDE_PROC_FS
-        .proc                   = ide_floppy_proc,
-        .settings               = ide_floppy_settings,
-#endif
-};
-
-static int idefloppy_open(struct inode *inode, struct file *filp)
+static int ide_floppy_init_media(ide_drive_t *drive, struct gendisk *disk)
 {
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_floppy_obj *floppy;
-        ide_drive_t *drive;
         int ret = 0;
 
-        floppy = ide_floppy_get(disk);
-        if (!floppy)
-                return -ENXIO;
-
-        drive = floppy->drive;
-
-        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
-
-        floppy->openers++;
-
-        if (floppy->openers == 1) {
-                drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
-                /* Just in case */
-
-                if (ide_do_test_unit_ready(drive, disk))
-                        ide_do_start_stop(drive, disk, 1);
-
-                if (ide_floppy_get_capacity(drive)
-                   && (filp->f_flags & O_NDELAY) == 0
-                    /*
-                     * Allow O_NDELAY to open a drive without a disk, or with an
-                     * unreadable disk, so that we can get the format capacity
-                     * of the drive or begin the format - Sam
-                     */
-                    ) {
-                        ret = -EIO;
-                        goto out_put_floppy;
-                }
-
-                if ((drive->atapi_flags & IDE_AFLAG_WP) && (filp->f_mode & 2)) {
-                        ret = -EROFS;
-                        goto out_put_floppy;
-                }
-
-                drive->atapi_flags |= IDE_AFLAG_MEDIA_CHANGED;
-                ide_set_media_lock(drive, disk, 1);
-                check_disk_change(inode->i_bdev);
-        } else if (drive->atapi_flags & IDE_AFLAG_FORMAT_IN_PROGRESS) {
-                ret = -EBUSY;
-                goto out_put_floppy;
-        }
-        return 0;
-
-out_put_floppy:
-        floppy->openers--;
-        ide_floppy_put(floppy);
-        return ret;
-}
-
-static int idefloppy_release(struct inode *inode, struct file *filp)
-{
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_floppy_obj *floppy = ide_drv_g(disk, ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
-
-        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
-
-        if (floppy->openers == 1) {
-                ide_set_media_lock(drive, disk, 0);
-                drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
-        }
-
-        floppy->openers--;
-
-        ide_floppy_put(floppy);
-
-        return 0;
-}
-
-static int idefloppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)
-{
-        struct ide_floppy_obj *floppy = ide_drv_g(bdev->bd_disk,
-                                                     ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
+        if (ide_do_test_unit_ready(drive, disk))
+                ide_do_start_stop(drive, disk, 1);
 
-        geo->heads = drive->bios_head;
-        geo->sectors = drive->bios_sect;
-        geo->cylinders = (u16)drive->bios_cyl; /* truncate */
-        return 0;
-}
+        ret = ide_floppy_get_capacity(drive);
 
-static int idefloppy_media_changed(struct gendisk *disk)
-{
-        struct ide_floppy_obj *floppy = ide_drv_g(disk, ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
-        int ret;
+        set_capacity(disk, ide_gd_capacity(drive));
 
-        /* do not scan partitions twice if this is a removable device */
-        if (drive->dev_flags & IDE_DFLAG_ATTACH) {
-                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
-                return 0;
-        }
-        ret = !!(drive->atapi_flags & IDE_AFLAG_MEDIA_CHANGED);
-        drive->atapi_flags &= ~IDE_AFLAG_MEDIA_CHANGED;
         return ret;
 }
 
-static int idefloppy_revalidate_disk(struct gendisk *disk)
-{
-        struct ide_floppy_obj *floppy = ide_drv_g(disk, ide_floppy_obj);
-        set_capacity(disk, ide_floppy_capacity(floppy->drive));
-        return 0;
-}
-
-static struct block_device_operations idefloppy_ops = {
-        .owner                  = THIS_MODULE,
-        .open                   = idefloppy_open,
-        .release                = idefloppy_release,
-        .ioctl                  = ide_floppy_ioctl,
-        .getgeo                 = idefloppy_getgeo,
-        .media_changed          = idefloppy_media_changed,
-        .revalidate_disk        = idefloppy_revalidate_disk
+const struct ide_disk_ops ide_atapi_disk_ops = {
+        .check          = ide_check_atapi_device,
+        .get_capacity   = ide_floppy_get_capacity,
+        .setup          = ide_floppy_setup,
+        .flush          = ide_floppy_flush,
+        .init_media     = ide_floppy_init_media,
+        .set_doorlock   = ide_set_media_lock,
+        .do_request     = ide_floppy_do_request,
+        .end_request    = ide_floppy_end_request,
+        .ioctl          = ide_floppy_ioctl,
 };
-
-static int ide_floppy_probe(ide_drive_t *drive)
-{
-        idefloppy_floppy_t *floppy;
-        struct gendisk *g;
-
-        if (!strstr("ide-floppy", drive->driver_req))
-                goto failed;
-
-        if (drive->media != ide_floppy)
-                goto failed;
-
-        if (!ide_check_atapi_device(drive, DRV_NAME)) {
-                printk(KERN_ERR PFX "%s: not supported by this version of "
-                       DRV_NAME "\n", drive->name);
-                goto failed;
-        }
-        floppy = kzalloc(sizeof(idefloppy_floppy_t), GFP_KERNEL);
-        if (!floppy) {
-                printk(KERN_ERR PFX "%s: Can't allocate a floppy structure\n",
-                       drive->name);
-                goto failed;
-        }
-
-        g = alloc_disk(1 << PARTN_BITS);
-        if (!g)
-                goto out_free_floppy;
-
-        ide_init_disk(g, drive);
-
-        kref_init(&floppy->kref);
-
-        floppy->drive = drive;
-        floppy->driver = &idefloppy_driver;
-        floppy->disk = g;
-
-        g->private_data = &floppy->driver;
-
-        drive->driver_data = floppy;
-
-        drive->debug_mask = debug_mask;
-
-        idefloppy_setup(drive, floppy);
-        drive->dev_flags |= IDE_DFLAG_ATTACH;
-
-        g->minors = 1 << PARTN_BITS;
-        g->driverfs_dev = &drive->gendev;
-        if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
-                g->flags = GENHD_FL_REMOVABLE;
-        g->fops = &idefloppy_ops;
-        add_disk(g);
-        return 0;
-
-out_free_floppy:
-        kfree(floppy);
-failed:
-        return -ENODEV;
-}
-
-static void __exit idefloppy_exit(void)
-{
-        driver_unregister(&idefloppy_driver.gen_driver);
-}
-
-static int __init idefloppy_init(void)
-{
-        printk(KERN_INFO DRV_NAME " driver " IDEFLOPPY_VERSION "\n");
-        return driver_register(&idefloppy_driver.gen_driver);
-}
-
-MODULE_ALIAS("ide:*m-floppy*");
-MODULE_ALIAS("ide-floppy");
-module_init(idefloppy_init);
-module_exit(idefloppy_exit);
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
-
diff --git a/drivers/ide/ide-floppy.h b/drivers/ide/ide-floppy.h
index 17cf865e583d..c17124dd6079 100644
--- a/drivers/ide/ide-floppy.h
+++ b/drivers/ide/ide-floppy.h
@@ -1,37 +1,9 @@
 #ifndef __IDE_FLOPPY_H
 #define __IDE_FLOPPY_H
 
-/*
- * Most of our global data which we need to save even as we leave the driver
- * due to an interrupt or a timer event is stored in a variable of type
- * idefloppy_floppy_t, defined below.
- */
-typedef struct ide_floppy_obj {
-        ide_drive_t     *drive;
-        ide_driver_t    *driver;
-        struct gendisk  *disk;
-        struct kref     kref;
-        unsigned int    openers;        /* protected by BKL for now */
-
-        /* Last failed packet command */
-        struct ide_atapi_pc *failed_pc;
-        /* used for blk_{fs,pc}_request() requests */
-        struct ide_atapi_pc queued_pc;
-
-        /* Last error information */
-        u8 sense_key, asc, ascq;
-
-        int progress_indication;
-
-        /* Device information */
-        /* Current format */
-        int blocks, block_size, bs_factor;
-        /* Last format capacity descriptor */
-        u8 cap_desc[8];
-        /* Copy of the flexible disk page */
-        u8 flexible_disk_page[32];
-} idefloppy_floppy_t;
+#include "ide-gd.h"
 
+#ifdef CONFIG_IDE_GD_ATAPI
 /*
  * Pages of the SELECT SENSE / MODE SENSE packet commands.
  * See SFF-8070i spec.
@@ -46,17 +18,22 @@ typedef struct ide_floppy_obj {
 #define IDEFLOPPY_IOCTL_FORMAT_GET_PROGRESS     0x4603
 
 /* ide-floppy.c */
+extern const struct ide_disk_ops ide_atapi_disk_ops;
 void ide_floppy_create_mode_sense_cmd(struct ide_atapi_pc *, u8);
 void ide_floppy_create_read_capacity_cmd(struct ide_atapi_pc *);
-sector_t ide_floppy_capacity(ide_drive_t *);
 
 /* ide-floppy_ioctl.c */
-int ide_floppy_ioctl(struct inode *, struct file *, unsigned, unsigned long);
+int ide_floppy_ioctl(ide_drive_t *, struct inode *, struct file *, unsigned int,
+                     unsigned long);
 
 #ifdef CONFIG_IDE_PROC_FS
 /* ide-floppy_proc.c */
 extern ide_proc_entry_t ide_floppy_proc[];
 extern const struct ide_proc_devset ide_floppy_settings[];
 #endif
+#else
+#define ide_floppy_proc         NULL
+#define ide_floppy_settings     NULL
+#endif
 
 #endif /*__IDE_FLOPPY_H */
diff --git a/drivers/ide/ide-floppy_ioctl.c b/drivers/ide/ide-floppy_ioctl.c
index a3a7a0809e2b..409e4c15f9b7 100644
--- a/drivers/ide/ide-floppy_ioctl.c
+++ b/drivers/ide/ide-floppy_ioctl.c
@@ -33,7 +33,7 @@
 
 static int ide_floppy_get_format_capacities(ide_drive_t *drive, int __user *arg)
 {
-        struct ide_floppy_obj *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc pc;
         u8 header_len, desc_cnt;
         int i, blocks, length, u_array_size, u_index;
@@ -113,7 +113,7 @@ static void ide_floppy_create_format_unit_cmd(struct ide_atapi_pc *pc, int b,
 
 static int ide_floppy_get_sfrp_bit(ide_drive_t *drive)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc pc;
 
         drive->atapi_flags &= ~IDE_AFLAG_SRFP;
@@ -132,17 +132,17 @@ static int ide_floppy_get_sfrp_bit(ide_drive_t *drive)
 
 static int ide_floppy_format_unit(ide_drive_t *drive, int __user *arg)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc pc;
         int blocks, length, flags, err = 0;
 
         if (floppy->openers > 1) {
                 /* Don't format if someone is using the disk */
-                drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
+                drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
                 return -EBUSY;
         }
 
-        drive->atapi_flags |= IDE_AFLAG_FORMAT_IN_PROGRESS;
+        drive->dev_flags |= IDE_DFLAG_FORMAT_IN_PROGRESS;
 
         /*
          * Send ATAPI_FORMAT_UNIT to the drive.
@@ -174,7 +174,7 @@ static int ide_floppy_format_unit(ide_drive_t *drive, int __user *arg)
 
 out:
         if (err)
-                drive->atapi_flags &= ~IDE_AFLAG_FORMAT_IN_PROGRESS;
+                drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
         return err;
 }
 
@@ -190,7 +190,7 @@ out:
 
 static int ide_floppy_get_format_progress(ide_drive_t *drive, int __user *arg)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct ide_atapi_pc pc;
         int progress_indication = 0x10000;
 
@@ -226,7 +226,7 @@ static int ide_floppy_get_format_progress(ide_drive_t *drive, int __user *arg)
 static int ide_floppy_lockdoor(ide_drive_t *drive, struct ide_atapi_pc *pc,
                                unsigned long arg, unsigned int cmd)
 {
-        idefloppy_floppy_t *floppy = drive->driver_data;
+        struct ide_disk_obj *floppy = drive->driver_data;
         struct gendisk *disk = floppy->disk;
         int prevent = (arg && cmd != CDROMEJECT) ? 1 : 0;
 
@@ -260,13 +260,10 @@ static int ide_floppy_format_ioctl(ide_drive_t *drive, struct file *file,
         }
 }
 
-int ide_floppy_ioctl(struct inode *inode, struct file *file,
-                    unsigned int cmd, unsigned long arg)
+int ide_floppy_ioctl(ide_drive_t *drive, struct inode *inode,
+                     struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct block_device *bdev = inode->i_bdev;
-        struct ide_floppy_obj *floppy = ide_drv_g(bdev->bd_disk,
-                                                     ide_floppy_obj);
-        ide_drive_t *drive = floppy->drive;
         struct ide_atapi_pc pc;
         void __user *argp = (void __user *)arg;
         int err;
diff --git a/drivers/ide/ide-floppy_proc.c b/drivers/ide/ide-floppy_proc.c
index 76f0c6c4eca3..3ec762cb60ab 100644
--- a/drivers/ide/ide-floppy_proc.c
+++ b/drivers/ide/ide-floppy_proc.c
@@ -9,7 +9,7 @@ static int proc_idefloppy_read_capacity(char *page, char **start, off_t off,
         ide_drive_t*drive = (ide_drive_t *)data;
         int len;
 
-        len = sprintf(page, "%llu\n", (long long)ide_floppy_capacity(drive));
+        len = sprintf(page, "%llu\n", (long long)ide_gd_capacity(drive));
         PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
 }
 
diff --git a/drivers/ide/ide-gd.c b/drivers/ide/ide-gd.c
new file mode 100644
index 000000000000..d44898f46c33
--- /dev/null
+++ b/drivers/ide/ide-gd.c
@@ -0,0 +1,398 @@
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/genhd.h>
+#include <linux/mutex.h>
+#include <linux/ide.h>
+#include <linux/hdreg.h>
+
+#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
+#define IDE_DISK_MINORS         (1 << PARTN_BITS)
+#else
+#define IDE_DISK_MINORS         0
+#endif
+
+#include "ide-disk.h"
+#include "ide-floppy.h"
+
+#define IDE_GD_VERSION  "1.18"
+
+/* module parameters */
+static unsigned long debug_mask;
+module_param(debug_mask, ulong, 0644);
+
+static DEFINE_MUTEX(ide_disk_ref_mutex);
+
+static void ide_disk_release(struct kref *);
+
+static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
+{
+        struct ide_disk_obj *idkp = NULL;
+
+        mutex_lock(&ide_disk_ref_mutex);
+        idkp = ide_drv_g(disk, ide_disk_obj);
+        if (idkp) {
+                if (ide_device_get(idkp->drive))
+                        idkp = NULL;
+                else
+                        kref_get(&idkp->kref);
+        }
+        mutex_unlock(&ide_disk_ref_mutex);
+        return idkp;
+}
+
+static void ide_disk_put(struct ide_disk_obj *idkp)
+{
+        ide_drive_t *drive = idkp->drive;
+
+        mutex_lock(&ide_disk_ref_mutex);
+        kref_put(&idkp->kref, ide_disk_release);
+        ide_device_put(drive);
+        mutex_unlock(&ide_disk_ref_mutex);
+}
+
+sector_t ide_gd_capacity(ide_drive_t *drive)
+{
+        return drive->capacity64;
+}
+
+static int ide_gd_probe(ide_drive_t *);
+
+static void ide_gd_remove(ide_drive_t *drive)
+{
+        struct ide_disk_obj *idkp = drive->driver_data;
+        struct gendisk *g = idkp->disk;
+
+        ide_proc_unregister_driver(drive, idkp->driver);
+
+        del_gendisk(g);
+
+        drive->disk_ops->flush(drive);
+
+        ide_disk_put(idkp);
+}
+
+static void ide_disk_release(struct kref *kref)
+{
+        struct ide_disk_obj *idkp = to_ide_drv(kref, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+        struct gendisk *g = idkp->disk;
+
+        drive->disk_ops = NULL;
+        drive->driver_data = NULL;
+        g->private_data = NULL;
+        put_disk(g);
+        kfree(idkp);
+}
+
+/*
+ * On HPA drives the capacity needs to be
+ * reinitilized on resume otherwise the disk
+ * can not be used and a hard reset is required
+ */
+static void ide_gd_resume(ide_drive_t *drive)
+{
+        if (ata_id_hpa_enabled(drive->id))
+                (void)drive->disk_ops->get_capacity(drive);
+}
+
+static void ide_gd_shutdown(ide_drive_t *drive)
+{
+#ifdef  CONFIG_ALPHA
+        /* On Alpha, halt(8) doesn't actually turn the machine off,
+           it puts you into the sort of firmware monitor. Typically,
+           it's used to boot another kernel image, so it's not much
+           different from reboot(8). Therefore, we don't need to
+           spin down the disk in this case, especially since Alpha
+           firmware doesn't handle disks in standby mode properly.
+           On the other hand, it's reasonably safe to turn the power
+           off when the shutdown process reaches the firmware prompt,
+           as the firmware initialization takes rather long time -
+           at least 10 seconds, which should be sufficient for
+           the disk to expire its write cache. */
+        if (system_state != SYSTEM_POWER_OFF) {
+#else
+        if (system_state == SYSTEM_RESTART) {
+#endif
+                drive->disk_ops->flush(drive);
+                return;
+        }
+
+        printk(KERN_INFO "Shutdown: %s\n", drive->name);
+
+        drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
+}
+
+#ifdef CONFIG_IDE_PROC_FS
+static ide_proc_entry_t *ide_disk_proc_entries(ide_drive_t *drive)
+{
+        return (drive->media == ide_disk) ? ide_disk_proc : ide_floppy_proc;
+}
+
+static const struct ide_proc_devset *ide_disk_proc_devsets(ide_drive_t *drive)
+{
+        return (drive->media == ide_disk) ? ide_disk_settings
+                                          : ide_floppy_settings;
+}
+#endif
+
+static ide_startstop_t ide_gd_do_request(ide_drive_t *drive,
+                                         struct request *rq, sector_t sector)
+{
+        return drive->disk_ops->do_request(drive, rq, sector);
+}
+
+static int ide_gd_end_request(ide_drive_t *drive, int uptodate, int nrsecs)
+{
+        return drive->disk_ops->end_request(drive, uptodate, nrsecs);
+}
+
+static ide_driver_t ide_gd_driver = {
+        .gen_driver = {
+                .owner          = THIS_MODULE,
+                .name           = "ide-gd",
+                .bus            = &ide_bus_type,
+        },
+        .probe                  = ide_gd_probe,
+        .remove                 = ide_gd_remove,
+        .resume                 = ide_gd_resume,
+        .shutdown               = ide_gd_shutdown,
+        .version                = IDE_GD_VERSION,
+        .do_request             = ide_gd_do_request,
+        .end_request            = ide_gd_end_request,
+        .error                  = __ide_error,
+#ifdef CONFIG_IDE_PROC_FS
+        .proc_entries           = ide_disk_proc_entries,
+        .proc_devsets           = ide_disk_proc_devsets,
+#endif
+};
+
+static int ide_gd_open(struct inode *inode, struct file *filp)
+{
+        struct gendisk *disk = inode->i_bdev->bd_disk;
+        struct ide_disk_obj *idkp;
+        ide_drive_t *drive;
+        int ret = 0;
+
+        idkp = ide_disk_get(disk);
+        if (idkp == NULL)
+                return -ENXIO;
+
+        drive = idkp->drive;
+
+        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
+
+        idkp->openers++;
+
+        if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
+                drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
+                /* Just in case */
+
+                ret = drive->disk_ops->init_media(drive, disk);
+
+                /*
+                 * Allow O_NDELAY to open a drive without a disk, or with an
+                 * unreadable disk, so that we can get the format capacity
+                 * of the drive or begin the format - Sam
+                 */
+                if (ret && (filp->f_flags & O_NDELAY) == 0) {
+                        ret = -EIO;
+                        goto out_put_idkp;
+                }
+
+                if ((drive->dev_flags & IDE_DFLAG_WP) && (filp->f_mode & 2)) {
+                        ret = -EROFS;
+                        goto out_put_idkp;
+                }
+
+                /*
+                 * Ignore the return code from door_lock,
+                 * since the open() has already succeeded,
+                 * and the door_lock is irrelevant at this point.
+                 */
+                drive->disk_ops->set_doorlock(drive, disk, 1);
+                drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
+                check_disk_change(inode->i_bdev);
+        } else if (drive->dev_flags & IDE_DFLAG_FORMAT_IN_PROGRESS) {
+                ret = -EBUSY;
+                goto out_put_idkp;
+        }
+        return 0;
+
+out_put_idkp:
+        idkp->openers--;
+        ide_disk_put(idkp);
+        return ret;
+}
+
+static int ide_gd_release(struct inode *inode, struct file *filp)
+{
+        struct gendisk *disk = inode->i_bdev->bd_disk;
+        struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+
+        ide_debug_log(IDE_DBG_FUNC, "Call %s\n", __func__);
+
+        if (idkp->openers == 1)
+                drive->disk_ops->flush(drive);
+
+        if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
+                drive->disk_ops->set_doorlock(drive, disk, 0);
+                drive->dev_flags &= ~IDE_DFLAG_FORMAT_IN_PROGRESS;
+        }
+
+        idkp->openers--;
+
+        ide_disk_put(idkp);
+
+        return 0;
+}
+
+static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
+{
+        struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+
+        geo->heads = drive->bios_head;
+        geo->sectors = drive->bios_sect;
+        geo->cylinders = (u16)drive->bios_cyl; /* truncate */
+        return 0;
+}
+
+static int ide_gd_media_changed(struct gendisk *disk)
+{
+        struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+        int ret;
+
+        /* do not scan partitions twice if this is a removable device */
+        if (drive->dev_flags & IDE_DFLAG_ATTACH) {
+                drive->dev_flags &= ~IDE_DFLAG_ATTACH;
+                return 0;
+        }
+
+        ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED);
+        drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
+
+        return ret;
+}
+
+static int ide_gd_revalidate_disk(struct gendisk *disk)
+{
+        struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
+        set_capacity(disk, ide_gd_capacity(idkp->drive));
+        return 0;
+}
+
+static int ide_gd_ioctl(struct inode *inode, struct file *file,
+                             unsigned int cmd, unsigned long arg)
+{
+        struct block_device *bdev = inode->i_bdev;
+        struct ide_disk_obj *idkp = ide_drv_g(bdev->bd_disk, ide_disk_obj);
+        ide_drive_t *drive = idkp->drive;
+
+        return drive->disk_ops->ioctl(drive, inode, file, cmd, arg);
+}
+
+static struct block_device_operations ide_gd_ops = {
+        .owner                  = THIS_MODULE,
+        .open                   = ide_gd_open,
+        .release                = ide_gd_release,
+        .ioctl                  = ide_gd_ioctl,
+        .getgeo                 = ide_gd_getgeo,
+        .media_changed          = ide_gd_media_changed,
+        .revalidate_disk        = ide_gd_revalidate_disk
+};
+
+static int ide_gd_probe(ide_drive_t *drive)
+{
+        const struct ide_disk_ops *disk_ops = NULL;
+        struct ide_disk_obj *idkp;
+        struct gendisk *g;
+
+        /* strstr("foo", "") is non-NULL */
+        if (!strstr("ide-gd", drive->driver_req))
+                goto failed;
+
+#ifdef CONFIG_IDE_GD_ATA
+        if (drive->media == ide_disk)
+                disk_ops = &ide_ata_disk_ops;
+#endif
+#ifdef CONFIG_IDE_GD_ATAPI
+        if (drive->media == ide_floppy)
+                disk_ops = &ide_atapi_disk_ops;
+#endif
+        if (disk_ops == NULL)
+                goto failed;
+
+        if (disk_ops->check(drive, DRV_NAME) == 0) {
+                printk(KERN_ERR PFX "%s: not supported by this driver\n",
+                        drive->name);
+                goto failed;
+        }
+
+        idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
+        if (!idkp) {
+                printk(KERN_ERR PFX "%s: can't allocate a disk structure\n",
+                        drive->name);
+                goto failed;
+        }
+
+        g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
+        if (!g)
+                goto out_free_idkp;
+
+        ide_init_disk(g, drive);
+
+        kref_init(&idkp->kref);
+
+        idkp->drive = drive;
+        idkp->driver = &ide_gd_driver;
+        idkp->disk = g;
+
+        g->private_data = &idkp->driver;
+
+        drive->driver_data = idkp;
+        drive->debug_mask = debug_mask;
+        drive->disk_ops = disk_ops;
+
+        disk_ops->setup(drive);
+
+        set_capacity(g, ide_gd_capacity(drive));
+
+        g->minors = IDE_DISK_MINORS;
+        g->driverfs_dev = &drive->gendev;
+        g->flags |= GENHD_FL_EXT_DEVT;
+        if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
+                g->flags = GENHD_FL_REMOVABLE;
+        g->fops = &ide_gd_ops;
+        add_disk(g);
+        return 0;
+
+out_free_idkp:
+        kfree(idkp);
+failed:
+        return -ENODEV;
+}
+
+static int __init ide_gd_init(void)
+{
+        printk(KERN_INFO DRV_NAME " driver " IDE_GD_VERSION "\n");
+        return driver_register(&ide_gd_driver.gen_driver);
+}
+
+static void __exit ide_gd_exit(void)
+{
+        driver_unregister(&ide_gd_driver.gen_driver);
+}
+
+MODULE_ALIAS("ide:*m-disk*");
+MODULE_ALIAS("ide-disk");
+MODULE_ALIAS("ide:*m-floppy*");
+MODULE_ALIAS("ide-floppy");
+module_init(ide_gd_init);
+module_exit(ide_gd_exit);
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("generic ATA/ATAPI disk driver");
diff --git a/drivers/ide/ide-gd.h b/drivers/ide/ide-gd.h
new file mode 100644
index 000000000000..7d3d101713e0
--- /dev/null
+++ b/drivers/ide/ide-gd.h
@@ -0,0 +1,44 @@
+#ifndef __IDE_GD_H
+#define __IDE_GD_H
+
+#define DRV_NAME "ide-gd"
+#define PFX DRV_NAME ": "
+
+/* define to see debug info */
+#define IDE_GD_DEBUG_LOG        0
+
+#if IDE_GD_DEBUG_LOG
+#define ide_debug_log(lvl, fmt, args...) __ide_debug_log(lvl, fmt, args)
+#else
+#define ide_debug_log(lvl, fmt, args...) do {} while (0)
+#endif
+
+struct ide_disk_obj {
+        ide_drive_t     *drive;
+        ide_driver_t    *driver;
+        struct gendisk  *disk;
+        struct kref     kref;
+        unsigned int    openers;        /* protected by BKL for now */
+
+        /* Last failed packet command */
+        struct ide_atapi_pc *failed_pc;
+        /* used for blk_{fs,pc}_request() requests */
+        struct ide_atapi_pc queued_pc;
+
+        /* Last error information */
+        u8 sense_key, asc, ascq;
+
+        int progress_indication;
+
+        /* Device information */
+        /* Current format */
+        int blocks, block_size, bs_factor;
+        /* Last format capacity descriptor */
+        u8 cap_desc[8];
+        /* Copy of the flexible disk page */
+        u8 flexible_disk_page[32];
+};
+
+sector_t ide_gd_capacity(ide_drive_t *);
+
+#endif /* __IDE_GD_H */
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index b762deb2dacb..bb7a1ed8094e 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -755,7 +755,7 @@ int ide_config_drive_speed(ide_drive_t *drive, u8 speed)
          
         udelay(1);
         SELECT_DRIVE(drive);
-        SELECT_MASK(drive, 0);
+        SELECT_MASK(drive, 1);
         udelay(1);
         tp_ops->set_irq(hwif, 0);
 
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 19f8c7770a25..1649ea54f76c 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -208,6 +208,7 @@ static inline void do_identify (ide_drive_t *drive, u8 cmd)
                 drive->ready_stat = 0;
                 if (ata_id_cdb_intr(id))
                         drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
+                drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
                 /* we don't do head unloading on ATAPI devices */
                 drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
                 return;
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index b26926487cc0..c31d0dd7a532 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -567,10 +567,10 @@ static void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t
 void ide_proc_register_driver(ide_drive_t *drive, ide_driver_t *driver)
 {
         mutex_lock(&ide_setting_mtx);
-        drive->settings = driver->settings;
+        drive->settings = driver->proc_devsets(drive);
         mutex_unlock(&ide_setting_mtx);
 
-        ide_add_proc_entries(drive->proc, driver->proc, drive);
+        ide_add_proc_entries(drive->proc, driver->proc_entries(drive), drive);
 }
 
 EXPORT_SYMBOL(ide_proc_register_driver);
@@ -591,7 +591,7 @@ void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver)
 {
         unsigned long flags;
 
-        ide_remove_proc_entries(drive->proc, driver->proc);
+        ide_remove_proc_entries(drive->proc, driver->proc_entries(drive));
 
         mutex_lock(&ide_setting_mtx);
         spin_lock_irqsave(&ide_lock, flags);
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index d879c7797cde..b2b2e5e8d38e 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -2108,7 +2108,7 @@ static void idetape_get_mode_sense_results(ide_drive_t *drive)
 
         /* device lacks locking support according to capabilities page */
         if ((caps[6] & 1) == 0)
-                drive->atapi_flags |= IDE_AFLAG_NO_DOORLOCK;
+                drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
 
         if (caps[7] & 0x02)
                 tape->blk_size = 512;
@@ -2298,6 +2298,16 @@ static ide_proc_entry_t idetape_proc[] = {
         { "name",       S_IFREG|S_IRUGO,        proc_idetape_read_name, NULL },
         { NULL, 0, NULL, NULL }
 };
+
+static ide_proc_entry_t *ide_tape_proc_entries(ide_drive_t *drive)
+{
+        return idetape_proc;
+}
+
+static const struct ide_proc_devset *ide_tape_proc_devsets(ide_drive_t *drive)
+{
+        return idetape_settings;
+}
 #endif
 
 static int ide_tape_probe(ide_drive_t *);
@@ -2315,8 +2325,8 @@ static ide_driver_t idetape_driver = {
         .end_request            = idetape_end_request,
         .error                  = __ide_error,
 #ifdef CONFIG_IDE_PROC_FS
-        .proc                   = idetape_proc,
-        .settings               = idetape_settings,
+        .proc_entries           = ide_tape_proc_entries,
+        .proc_devsets           = ide_tape_proc_devsets,
 #endif
 };
 
diff --git a/drivers/ide/pci/Makefile b/drivers/ide/pci/Makefile
index 02e6ee7d751d..ab44a1f5f5a9 100644
--- a/drivers/ide/pci/Makefile
+++ b/drivers/ide/pci/Makefile
@@ -11,7 +11,6 @@ obj-$(CONFIG_BLK_DEV_CS5535)		+= cs5535.o
 obj-$(CONFIG_BLK_DEV_SC1200)            += sc1200.o
 obj-$(CONFIG_BLK_DEV_CY82C693)          += cy82c693.o
 obj-$(CONFIG_BLK_DEV_DELKIN)            += delkin_cb.o
-obj-$(CONFIG_BLK_DEV_HPT34X)            += hpt34x.o
 obj-$(CONFIG_BLK_DEV_HPT366)            += hpt366.o
 obj-$(CONFIG_BLK_DEV_IT8213)            += it8213.o
 obj-$(CONFIG_BLK_DEV_IT821X)            += it821x.o
diff --git a/drivers/ide/pci/delkin_cb.c b/drivers/ide/pci/delkin_cb.c
index 8689a706f537..8f1b2d9f0513 100644
--- a/drivers/ide/pci/delkin_cb.c
+++ b/drivers/ide/pci/delkin_cb.c
@@ -46,10 +46,27 @@ static const struct ide_port_ops delkin_cb_port_ops = {
         .quirkproc              = ide_undecoded_slave,
 };
 
+static unsigned int delkin_cb_init_chipset(struct pci_dev *dev)
+{
+        unsigned long base = pci_resource_start(dev, 0);
+        int i;
+
+        outb(0x02, base + 0x1e);        /* set nIEN to block interrupts */
+        inb(base + 0x17);               /* read status to clear interrupts */
+
+        for (i = 0; i < sizeof(setup); ++i) {
+                if (setup[i])
+                        outb(setup[i], base + i);
+        }
+
+        return 0;
+}
+
 static const struct ide_port_info delkin_cb_port_info = {
         .port_ops               = &delkin_cb_port_ops,
         .host_flags             = IDE_HFLAG_IO_32BIT | IDE_HFLAG_UNMASK_IRQS |
                                   IDE_HFLAG_NO_DMA,
+        .init_chipset           = delkin_cb_init_chipset,
 };
 
 static int __devinit
@@ -57,7 +74,7 @@ delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id)
 {
         struct ide_host *host;
         unsigned long base;
-        int i, rc;
+        int rc;
         hw_regs_t hw, *hws[] = { &hw, NULL, NULL, NULL };
 
         rc = pci_enable_device(dev);
@@ -72,12 +89,8 @@ delkin_cb_probe (struct pci_dev *dev, const struct pci_device_id *id)
                 return rc;
         }
         base = pci_resource_start(dev, 0);
-        outb(0x02, base + 0x1e);        /* set nIEN to block interrupts */
-        inb(base + 0x17);               /* read status to clear interrupts */
-        for (i = 0; i < sizeof(setup); ++i) {
-                if (setup[i])
-                        outb(setup[i], base + i);
-        }
+
+        delkin_cb_init_chipset(dev);
 
         memset(&hw, 0, sizeof(hw));
         ide_std_init_ports(&hw, base + 0x10, base + 0x1e);
@@ -110,6 +123,40 @@ delkin_cb_remove (struct pci_dev *dev)
         pci_disable_device(dev);
 }
 
+#ifdef CONFIG_PM
+static int delkin_cb_suspend(struct pci_dev *dev, pm_message_t state)
+{
+        pci_save_state(dev);
+        pci_disable_device(dev);
+        pci_set_power_state(dev, pci_choose_state(dev, state));
+
+        return 0;
+}
+
+static int delkin_cb_resume(struct pci_dev *dev)
+{
+        struct ide_host *host = pci_get_drvdata(dev);
+        int rc;
+
+        pci_set_power_state(dev, PCI_D0);
+
+        rc = pci_enable_device(dev);
+        if (rc)
+                return rc;
+
+        pci_restore_state(dev);
+        pci_set_master(dev);
+
+        if (host->init_chipset)
+                host->init_chipset(dev);
+
+        return 0;
+}
+#else
+#define delkin_cb_suspend NULL
+#define delkin_cb_resume NULL
+#endif
+
 static struct pci_device_id delkin_cb_pci_tbl[] __devinitdata = {
         { 0x1145, 0xf021, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         { 0x1145, 0xf024, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
@@ -122,6 +169,8 @@ static struct pci_driver delkin_cb_pci_driver = {
         .id_table       = delkin_cb_pci_tbl,
         .probe          = delkin_cb_probe,
         .remove         = delkin_cb_remove,
+        .suspend        = delkin_cb_suspend,
+        .resume         = delkin_cb_resume,
 };
 
 static int __init delkin_cb_init(void)
diff --git a/drivers/ide/pci/hpt34x.c b/drivers/ide/pci/hpt34x.c
deleted file mode 100644
index fb1a3aa57f07..000000000000
--- a/drivers/ide/pci/hpt34x.c
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (C) 1998-2000      Andre Hedrick <andre@linux-ide.org>
- *
- * May be copied or modified under the terms of the GNU General Public License
- *
- *
- * 00:12.0 Unknown mass storage controller:
- * Triones Technologies, Inc.
- * Unknown device 0003 (rev 01)
- *
- * hde: UDMA 2 (0x0000 0x0002) (0x0000 0x0010)
- * hdf: UDMA 2 (0x0002 0x0012) (0x0010 0x0030)
- * hde: DMA 2  (0x0000 0x0002) (0x0000 0x0010)
- * hdf: DMA 2  (0x0002 0x0012) (0x0010 0x0030)
- * hdg: DMA 1  (0x0012 0x0052) (0x0030 0x0070)
- * hdh: DMA 1  (0x0052 0x0252) (0x0070 0x00f0)
- *
- * ide-pci.c reference
- *
- * Since there are two cards that report almost identically,
- * the only discernable difference is the values reported in pcicmd.
- * Booting-BIOS card or HPT363 :: pcicmd == 0x07
- * Non-bootable card or HPT343 :: pcicmd == 0x05
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/ioport.h>
-#include <linux/interrupt.h>
-#include <linux/pci.h>
-#include <linux/init.h>
-#include <linux/ide.h>
-
-#define DRV_NAME "hpt34x"
-
-#define HPT343_DEBUG_DRIVE_INFO         0
-
-static void hpt34x_set_mode(ide_drive_t *drive, const u8 speed)
-{
-        struct pci_dev *dev = to_pci_dev(drive->hwif->dev);
-        u32 reg1= 0, tmp1 = 0, reg2 = 0, tmp2 = 0;
-        u8                      hi_speed, lo_speed;
-
-        hi_speed = speed >> 4;
-        lo_speed = speed & 0x0f;
-
-        if (hi_speed & 7) {
-                hi_speed = (hi_speed & 4) ? 0x01 : 0x10;
-        } else {
-                lo_speed <<= 5;
-                lo_speed >>= 5;
-        }
-
-        pci_read_config_dword(dev, 0x44, &reg1);
-        pci_read_config_dword(dev, 0x48, &reg2);
-        tmp1 = ((lo_speed << (3*drive->dn)) | (reg1 & ~(7 << (3*drive->dn))));
-        tmp2 = ((hi_speed << drive->dn) | (reg2 & ~(0x11 << drive->dn)));
-        pci_write_config_dword(dev, 0x44, tmp1);
-        pci_write_config_dword(dev, 0x48, tmp2);
-
-#if HPT343_DEBUG_DRIVE_INFO
-        printk("%s: %s drive%d (0x%04x 0x%04x) (0x%04x 0x%04x)" \
-                " (0x%02x 0x%02x)\n",
-                drive->name, ide_xfer_verbose(speed),
-                drive->dn, reg1, tmp1, reg2, tmp2,
-                hi_speed, lo_speed);
-#endif /* HPT343_DEBUG_DRIVE_INFO */
-}
-
-static void hpt34x_set_pio_mode(ide_drive_t *drive, const u8 pio)
-{
-        hpt34x_set_mode(drive, XFER_PIO_0 + pio);
-}
-
-/*
- * If the BIOS does not set the IO base addaress to XX00, 343 will fail.
- */
-#define HPT34X_PCI_INIT_REG             0x80
-
-static unsigned int init_chipset_hpt34x(struct pci_dev *dev)
-{
-        int i = 0;
-        unsigned long hpt34xIoBase = pci_resource_start(dev, 4);
-        unsigned long hpt_addr[4] = { 0x20, 0x34, 0x28, 0x3c };
-        unsigned long hpt_addr_len[4] = { 7, 3, 7, 3 };
-        u16 cmd;
-        unsigned long flags;
-
-        local_irq_save(flags);
-
-        pci_write_config_byte(dev, HPT34X_PCI_INIT_REG, 0x00);
-        pci_read_config_word(dev, PCI_COMMAND, &cmd);
-
-        if (cmd & PCI_COMMAND_MEMORY)
-                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xF0);
-        else
-                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x20);
-
-        /*
-         * Since 20-23 can be assigned and are R/W, we correct them.
-         */
-        pci_write_config_word(dev, PCI_COMMAND, cmd & ~PCI_COMMAND_IO);
-        for(i=0; i<4; i++) {
-                dev->resource[i].start = (hpt34xIoBase + hpt_addr[i]);
-                dev->resource[i].end = dev->resource[i].start + hpt_addr_len[i];
-                dev->resource[i].flags = IORESOURCE_IO;
-                pci_write_config_dword(dev,
-                                (PCI_BASE_ADDRESS_0 + (i * 4)),
-                                dev->resource[i].start);
-        }
-        pci_write_config_word(dev, PCI_COMMAND, cmd);
-
-        local_irq_restore(flags);
-
-        return dev->irq;
-}
-
-static const struct ide_port_ops hpt34x_port_ops = {
-        .set_pio_mode           = hpt34x_set_pio_mode,
-        .set_dma_mode           = hpt34x_set_mode,
-};
-
-#define IDE_HFLAGS_HPT34X \
-        (IDE_HFLAG_NO_ATAPI_DMA | \
-         IDE_HFLAG_NO_DSC | \
-         IDE_HFLAG_NO_AUTODMA)
-
-static const struct ide_port_info hpt34x_chipsets[] __devinitdata = {
-        { /* 0: HPT343 */
-                .name           = DRV_NAME,
-                .init_chipset   = init_chipset_hpt34x,
-                .port_ops       = &hpt34x_port_ops,
-                .host_flags     = IDE_HFLAGS_HPT34X | IDE_HFLAG_NON_BOOTABLE,
-                .pio_mask       = ATA_PIO5,
-        },
-        { /* 1: HPT345 */
-                .name           = DRV_NAME,
-                .init_chipset   = init_chipset_hpt34x,
-                .port_ops       = &hpt34x_port_ops,
-                .host_flags     = IDE_HFLAGS_HPT34X | IDE_HFLAG_OFF_BOARD,
-                .pio_mask       = ATA_PIO5,
-#ifdef CONFIG_HPT34X_AUTODMA
-                .swdma_mask     = ATA_SWDMA2,
-                .mwdma_mask     = ATA_MWDMA2,
-                .udma_mask      = ATA_UDMA2,
-#endif
-        }
-};
-
-static int __devinit hpt34x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
-{
-        const struct ide_port_info *d;
-        u16 pcicmd = 0;
-
-        pci_read_config_word(dev, PCI_COMMAND, &pcicmd);
-
-        d = &hpt34x_chipsets[(pcicmd & PCI_COMMAND_MEMORY) ? 1 : 0];
-
-        return ide_pci_init_one(dev, d, NULL);
-}
-
-static const struct pci_device_id hpt34x_pci_tbl[] = {
-        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT343), 0 },
-        { 0, },
-};
-MODULE_DEVICE_TABLE(pci, hpt34x_pci_tbl);
-
-static struct pci_driver hpt34x_pci_driver = {
-        .name           = "HPT34x_IDE",
-        .id_table       = hpt34x_pci_tbl,
-        .probe          = hpt34x_init_one,
-        .remove         = ide_pci_remove,
-        .suspend        = ide_pci_suspend,
-        .resume         = ide_pci_resume,
-};
-
-static int __init hpt34x_ide_init(void)
-{
-        return ide_pci_register_driver(&hpt34x_pci_driver);
-}
-
-static void __exit hpt34x_ide_exit(void)
-{
-        pci_unregister_driver(&hpt34x_pci_driver);
-}
-
-module_init(hpt34x_ide_init);
-module_exit(hpt34x_ide_exit);
-
-MODULE_AUTHOR("Andre Hedrick");
-MODULE_DESCRIPTION("PCI driver module for Highpoint 34x IDE");
-MODULE_LICENSE("GPL");
diff --git a/drivers/ide/pci/hpt366.c b/drivers/ide/pci/hpt366.c
index 9cf171cb9376..a7909e9c720e 100644
--- a/drivers/ide/pci/hpt366.c
+++ b/drivers/ide/pci/hpt366.c
@@ -3,7 +3,7 @@
  * Portions Copyright (C) 2001          Sun Microsystems, Inc.
  * Portions Copyright (C) 2003          Red Hat Inc
  * Portions Copyright (C) 2007          Bartlomiej Zolnierkiewicz
- * Portions Copyright (C) 2005-2007     MontaVista Software, Inc.
+ * Portions Copyright (C) 2005-2008     MontaVista Software, Inc.
  *
  * Thanks to HighPoint Technologies for their assistance, and hardware.
  * Special Thanks to Jon Burchmore in SanDiego for the deep pockets, his
@@ -748,26 +748,24 @@ static void hpt3xx_maskproc(ide_drive_t *drive, int mask)
         struct pci_dev  *dev    = to_pci_dev(hwif->dev);
         struct hpt_info *info   = hpt3xx_get_info(hwif->dev);
 
-        if (drive->quirk_list) {
-                if (info->chip_type >= HPT370) {
-                        u8 scr1 = 0;
-
-                        pci_read_config_byte(dev, 0x5a, &scr1);
-                        if (((scr1 & 0x10) >> 4) != mask) {
-                                if (mask)
-                                        scr1 |=  0x10;
-                                else
-                                        scr1 &= ~0x10;
-                                pci_write_config_byte(dev, 0x5a, scr1);
-                        }
-                } else {
+        if (drive->quirk_list == 0)
+                return;
+
+        if (info->chip_type >= HPT370) {
+                u8 scr1 = 0;
+
+                pci_read_config_byte(dev, 0x5a, &scr1);
+                if (((scr1 & 0x10) >> 4) != mask) {
                         if (mask)
-                                disable_irq(hwif->irq);
+                                scr1 |=  0x10;
                         else
-                                enable_irq (hwif->irq);
+                                scr1 &= ~0x10;
+                        pci_write_config_byte(dev, 0x5a, scr1);
                 }
-        } else
-                outb(ATA_DEVCTL_OBS | (mask ? 2 : 0), hwif->io_ports.ctl_addr);
+        } else if (mask)
+                disable_irq(hwif->irq);
+        else
+                enable_irq(hwif->irq);
 }
 
 /*
@@ -1289,7 +1287,6 @@ static u8 hpt3xx_cable_detect(ide_hwif_t *hwif)
 
 static void __devinit init_hwif_hpt366(ide_hwif_t *hwif)
 {
-        struct pci_dev *dev     = to_pci_dev(hwif->dev);
         struct hpt_info *info   = hpt3xx_get_info(hwif->dev);
         int serialize           = HPT_SERIALIZE_IO;
         u8  chip_type           = info->chip_type;
diff --git a/drivers/ide/pci/scc_pata.c b/drivers/ide/pci/scc_pata.c
index 9ce1d8059921..49f163aa51e3 100644
--- a/drivers/ide/pci/scc_pata.c
+++ b/drivers/ide/pci/scc_pata.c
@@ -617,7 +617,6 @@ static int __devinit init_setup_scc(struct pci_dev *dev,
         unsigned long intmask_port;
         unsigned long mode_port;
         unsigned long ecmode_port;
-        unsigned long dma_status_port;
         u32 reg = 0;
         struct scc_ports *ports;
         int rc;
@@ -637,7 +636,6 @@ static int __devinit init_setup_scc(struct pci_dev *dev,
         intmask_port = dma_base + 0x010;
         mode_port = ctl_base + 0x024;
         ecmode_port = ctl_base + 0xf00;
-        dma_status_port = dma_base + 0x004;
 
         /* controller initialization */
         reg = 0;
@@ -843,8 +841,6 @@ static u8 scc_cable_detect(ide_hwif_t *hwif)
 
 static void __devinit init_hwif_scc(ide_hwif_t *hwif)
 {
-        struct scc_ports *ports = ide_get_hwifdata(hwif);
-
         /* PTERADD */
         out_be32((void __iomem *)(hwif->dma_base + 0x018), hwif->dmatable_dma);
 
diff --git a/drivers/ide/pci/sgiioc4.c b/drivers/ide/pci/sgiioc4.c
index dd634541ce36..8af9b23499fd 100644
--- a/drivers/ide/pci/sgiioc4.c
+++ b/drivers/ide/pci/sgiioc4.c
@@ -101,18 +101,8 @@ sgiioc4_init_hwif_ports(hw_regs_t * hw, unsigned long data_port,
         for (i = 0; i <= 7; i++)
                 hw->io_ports_array[i] = reg + i * 4;
 
-        if (ctrl_port)
-                hw->io_ports.ctl_addr = ctrl_port;
-
-        if (irq_port)
-                hw->io_ports.irq_addr = irq_port;
-}
-
-static void
-sgiioc4_maskproc(ide_drive_t * drive, int mask)
-{
-        writeb(ATA_DEVCTL_OBS | (mask ? 2 : 0),
-               (void __iomem *)drive->hwif->io_ports.ctl_addr);
+        hw->io_ports.ctl_addr = ctrl_port;
+        hw->io_ports.irq_addr = irq_port;
 }
 
 static int
@@ -310,16 +300,14 @@ static u8 sgiioc4_read_status(ide_hwif_t *hwif)
         unsigned long port = hwif->io_ports.status_addr;
         u8 reg = (u8) readb((void __iomem *) port);
 
-        if ((port & 0xFFF) == 0x11C) {  /* Status register of IOC4 */
-                if (!(reg & ATA_BUSY)) { /* Not busy... check for interrupt */
-                        unsigned long other_ir = port - 0x110;
-                        unsigned int intr_reg = (u32) readl((void __iomem *) other_ir);
+        if (!(reg & ATA_BUSY)) {        /* Not busy... check for interrupt */
+                unsigned long other_ir = port - 0x110;
+                unsigned int intr_reg = (u32) readl((void __iomem *) other_ir);
 
-                        /* Clear the Interrupt, Error bits on the IOC4 */
-                        if (intr_reg & 0x03) {
-                                writel(0x03, (void __iomem *) other_ir);
-                                intr_reg = (u32) readl((void __iomem *) other_ir);
-                        }
+                /* Clear the Interrupt, Error bits on the IOC4 */
+                if (intr_reg & 0x03) {
+                        writel(0x03, (void __iomem *) other_ir);
+                        intr_reg = (u32) readl((void __iomem *) other_ir);
                 }
         }
 
@@ -332,13 +320,9 @@ ide_dma_sgiioc4(ide_hwif_t *hwif, const struct ide_port_info *d)
 {
         struct pci_dev *dev = to_pci_dev(hwif->dev);
         unsigned long dma_base = pci_resource_start(dev, 0) + IOC4_DMA_OFFSET;
-        void __iomem *virt_dma_base;
         int num_ports = sizeof (ioc4_dma_regs_t);
         void *pad;
 
-        if (dma_base == 0)
-                return -1;
-
         printk(KERN_INFO "    %s: MMIO-DMA\n", hwif->name);
 
         if (request_mem_region(dma_base, num_ports, hwif->name) == NULL) {
@@ -348,14 +332,8 @@ ide_dma_sgiioc4(ide_hwif_t *hwif, const struct ide_port_info *d)
                 return -1;
         }
 
-        virt_dma_base = ioremap(dma_base, num_ports);
-        if (virt_dma_base == NULL) {
-                printk(KERN_ERR "%s(%s) -- ERROR: unable to map addresses "
-                       "0x%lx to 0x%lx\n", __func__, hwif->name,
-                       dma_base, dma_base + num_ports - 1);
-                goto dma_remap_failure;
-        }
-        hwif->dma_base = (unsigned long) virt_dma_base;
+        hwif->dma_base = (unsigned long)hwif->io_ports.irq_addr +
+                         IOC4_DMA_OFFSET;
 
         hwif->sg_max_nents = IOC4_PRD_ENTRIES;
 
@@ -379,9 +357,6 @@ ide_dma_sgiioc4(ide_hwif_t *hwif, const struct ide_port_info *d)
         printk(KERN_INFO "%s: changing from DMA to PIO mode", hwif->name);
 
 dma_pci_alloc_failure:
-        iounmap(virt_dma_base);
-
-dma_remap_failure:
         release_mem_region(dma_base, num_ports);
 
         return -1;
@@ -563,8 +538,6 @@ static const struct ide_port_ops sgiioc4_port_ops = {
         .set_dma_mode           = sgiioc4_set_dma_mode,
         /* reset DMA engine, clear IRQs */
         .resetproc              = sgiioc4_resetproc,
-        /* mask on/off NIEN register */
-        .maskproc               = sgiioc4_maskproc,
 };
 
 static const struct ide_dma_ops sgiioc4_dma_ops = {
diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c
index a78d35aecee3..f1e82a92e61e 100644
--- a/drivers/infiniband/core/cm.c
+++ b/drivers/infiniband/core/cm.c
@@ -122,7 +122,7 @@ struct cm_counter_attribute {
 
 #define CM_COUNTER_ATTR(_name, _index) \
 struct cm_counter_attribute cm_##_name##_counter_attr = { \
-        .attr = { .name = __stringify(_name), .mode = 0444, .owner = THIS_MODULE }, \
+        .attr = { .name = __stringify(_name), .mode = 0444 }, \
         .index = _index \
 }
 
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index dff4adca6475..3d1ab8fa9acc 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -223,7 +223,7 @@ config TOUCHSCREEN_ATMEL_TSADCC
 
 config TOUCHSCREEN_UCB1400
         tristate "Philips UCB1400 touchscreen"
-        select AC97_BUS
+        depends on AC97_BUS
         depends on UCB1400_CORE
         help
           This enables support for the Philips UCB1400 touchscreen interface.
diff --git a/drivers/input/touchscreen/hp680_ts_input.c b/drivers/input/touchscreen/hp680_ts_input.c
index c38d4e0f95c6..a89700e7ace4 100644
--- a/drivers/input/touchscreen/hp680_ts_input.c
+++ b/drivers/input/touchscreen/hp680_ts_input.c
@@ -5,7 +5,7 @@
 #include <asm/io.h>
 #include <asm/delay.h>
 #include <asm/adc.h>
-#include <asm/hp6xx.h>
+#include <mach/hp6xx.h>
 
 #define MODNAME "hp680_ts_input"
 
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index e3e40427e00e..c7ff1e11ea85 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -179,7 +179,7 @@ config LEDS_TRIGGER_TIMER
 
 config LEDS_TRIGGER_IDE_DISK
         bool "LED IDE Disk Trigger"
-        depends on LEDS_TRIGGERS && BLK_DEV_IDEDISK
+        depends on LEDS_TRIGGERS && IDE_GD_ATA
         help
           This allows LEDs to be controlled by IDE disk activity.
           If unsure, say Y.
diff --git a/drivers/leds/leds-hp6xx.c b/drivers/leds/leds-hp6xx.c
index 844d5979c904..e8fb1baf8a50 100644
--- a/drivers/leds/leds-hp6xx.c
+++ b/drivers/leds/leds-hp6xx.c
@@ -15,7 +15,7 @@
 #include <linux/platform_device.h>
 #include <linux/leds.h>
 #include <asm/hd64461.h>
-#include <asm/hp6xx.h>
+#include <mach/hp6xx.h>
 
 static void hp6xxled_green_set(struct led_classdev *led_cdev,
                                enum led_brightness value)
diff --git a/drivers/media/dvb/ttpci/av7110.c b/drivers/media/dvb/ttpci/av7110.c
index c7c770c28988..aa1ff524256e 100644
--- a/drivers/media/dvb/ttpci/av7110.c
+++ b/drivers/media/dvb/ttpci/av7110.c
@@ -36,7 +36,6 @@
 #include <linux/fs.h>
 #include <linux/timer.h>
 #include <linux/poll.h>
-#include <linux/byteorder/swabb.h>
 #include <linux/smp_lock.h>
 
 #include <linux/kernel.h>
@@ -52,6 +51,7 @@
 #include <linux/i2c.h>
 #include <linux/kthread.h>
 #include <asm/unaligned.h>
+#include <asm/byteorder.h>
 
 #include <asm/system.h>
 
diff --git a/drivers/media/video/cx18/cx18-driver.h b/drivers/media/video/cx18/cx18-driver.h
index fa8be0731a3f..a4b1708fafe7 100644
--- a/drivers/media/video/cx18/cx18-driver.h
+++ b/drivers/media/video/cx18/cx18-driver.h
@@ -41,6 +41,7 @@
 #include <linux/pagemap.h>
 #include <linux/workqueue.h>
 #include <linux/mutex.h>
+#include <asm/byteorder.h>
 
 #include <linux/dvb/video.h>
 #include <linux/dvb/audio.h>
diff --git a/drivers/media/video/ivtv/ivtv-driver.h b/drivers/media/video/ivtv/ivtv-driver.h
index bc29436e8a3c..3733b2afec5f 100644
--- a/drivers/media/video/ivtv/ivtv-driver.h
+++ b/drivers/media/video/ivtv/ivtv-driver.h
@@ -55,6 +55,7 @@
 #include <linux/mutex.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
+#include <asm/byteorder.h>
 
 #include <linux/dvb/video.h>
 #include <linux/dvb/audio.h>
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index 6e291bf8237a..5263913e0c69 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -1044,7 +1044,6 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
 
                 s_attr->dev_attr.attr.name = s_attr->name;
                 s_attr->dev_attr.attr.mode = S_IRUGO;
-                s_attr->dev_attr.attr.owner = THIS_MODULE;
                 s_attr->dev_attr.show = mspro_block_attr_show(s_attr->id);
 
                 if (!rc)
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 5eff8ad834d6..5a79d2d4cdae 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -52,6 +52,8 @@ config HTC_PASIC3
 
 config UCB1400_CORE
         tristate "Philips UCB1400 Core driver"
+        depends on AC97_BUS
+        depends on GPIOLIB
         help
           This enables support for the Philips UCB1400 core functions.
           The UCB1400 is an AC97 audio codec.
@@ -59,6 +61,20 @@ config UCB1400_CORE
           To compile this driver as a module, choose M here: the
           module will be called ucb1400_core.
 
+config TWL4030_CORE
+        bool "Texas Instruments TWL4030/TPS659x0 Support"
+        depends on I2C=y && GENERIC_HARDIRQS && (ARCH_OMAP2 || ARCH_OMAP3)
+        help
+          Say yes here if you have TWL4030 family chip on your board.
+          This core driver provides register access and IRQ handling
+          facilities, and registers devices for the various functions
+          so that function-specific drivers can bind to them.
+
+          These multi-function chips are found on many OMAP2 and OMAP3
+          boards, providing power management, RTC, GPIO, keypad, a
+          high speed USB OTG transceiver, an audio codec (on most
+          versions) and many other features.
+
 config MFD_TMIO
         bool
         default n
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 759b1fe1c891..68e237b830ad 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -17,6 +17,8 @@ wm8350-objs			:= wm8350-core.o wm8350-regmap.o wm8350-gpio.o
 obj-$(CONFIG_MFD_WM8350)        += wm8350.o
 obj-$(CONFIG_MFD_WM8350_I2C)    += wm8350-i2c.o
 
+obj-$(CONFIG_TWL4030_CORE)      += twl4030-core.o
+
 obj-$(CONFIG_MFD_CORE)          += mfd-core.o
 
 obj-$(CONFIG_MCP)               += mcp-core.o
diff --git a/drivers/mfd/asic3.c b/drivers/mfd/asic3.c
index ba5aa2008273..e4c0db4dc7b1 100644
--- a/drivers/mfd/asic3.c
+++ b/drivers/mfd/asic3.c
@@ -123,7 +123,7 @@ static void asic3_irq_demux(unsigned int irq, struct irq_desc *desc)
                                         irqnr = asic->irq_base +
                                                 (ASIC3_GPIOS_PER_BANK * bank)
                                                 + i;
-                                        desc = irq_desc + irqnr;
+                                        desc = irq_to_desc(irqnr);
                                         desc->handle_irq(irqnr, desc);
                                         if (asic->irq_bothedge[bank] & bit)
                                                 asic3_irq_flip_edge(asic, base,
@@ -136,7 +136,7 @@ static void asic3_irq_demux(unsigned int irq, struct irq_desc *desc)
                 for (i = ASIC3_NUM_GPIOS; i < ASIC3_NR_IRQS; i++) {
                         /* They start at bit 4 and go up */
                         if (status & (1 << (i - ASIC3_NUM_GPIOS + 4))) {
-                                desc = irq_desc + asic->irq_base + i;
+                                desc = irq_to_desc(asic->irq_base + i);
                                 desc->handle_irq(asic->irq_base + i,
                                                  desc);
                         }
diff --git a/drivers/mfd/da903x.c b/drivers/mfd/da903x.c
new file mode 100644
index 000000000000..b57326ae464d
--- /dev/null
+++ b/drivers/mfd/da903x.c
@@ -0,0 +1,563 @@
+/*
+ * Base driver for Dialog Semiconductor DA9030/DA9034
+ *
+ * Copyright (C) 2008 Compulab, Ltd.
+ *      Mike Rapoport <mike@compulab.co.il>
+ *
+ * Copyright (C) 2006-2008 Marvell International Ltd.
+ *      Eric Miao <eric.miao@marvell.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/mfd/da903x.h>
+
+#define DA9030_CHIP_ID          0x00
+#define DA9030_EVENT_A          0x01
+#define DA9030_EVENT_B          0x02
+#define DA9030_EVENT_C          0x03
+#define DA9030_STATUS           0x04
+#define DA9030_IRQ_MASK_A       0x05
+#define DA9030_IRQ_MASK_B       0x06
+#define DA9030_IRQ_MASK_C       0x07
+#define DA9030_SYS_CTRL_A       0x08
+#define DA9030_SYS_CTRL_B       0x09
+#define DA9030_FAULT_LOG        0x0a
+
+#define DA9034_CHIP_ID          0x00
+#define DA9034_EVENT_A          0x01
+#define DA9034_EVENT_B          0x02
+#define DA9034_EVENT_C          0x03
+#define DA9034_EVENT_D          0x04
+#define DA9034_STATUS_A         0x05
+#define DA9034_STATUS_B         0x06
+#define DA9034_IRQ_MASK_A       0x07
+#define DA9034_IRQ_MASK_B       0x08
+#define DA9034_IRQ_MASK_C       0x09
+#define DA9034_IRQ_MASK_D       0x0a
+#define DA9034_SYS_CTRL_A       0x0b
+#define DA9034_SYS_CTRL_B       0x0c
+#define DA9034_FAULT_LOG        0x0d
+
+struct da903x_chip;
+
+struct da903x_chip_ops {
+        int     (*init_chip)(struct da903x_chip *);
+        int     (*unmask_events)(struct da903x_chip *, unsigned int events);
+        int     (*mask_events)(struct da903x_chip *, unsigned int events);
+        int     (*read_events)(struct da903x_chip *, unsigned int *events);
+        int     (*read_status)(struct da903x_chip *, unsigned int *status);
+};
+
+struct da903x_chip {
+        struct i2c_client       *client;
+        struct device           *dev;
+        struct da903x_chip_ops  *ops;
+
+        int                     type;
+        uint32_t                events_mask;
+
+        struct mutex            lock;
+        struct work_struct      irq_work;
+
+        struct blocking_notifier_head notifier_list;
+};
+
+static inline int __da903x_read(struct i2c_client *client,
+                                int reg, uint8_t *val)
+{
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(client, reg);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
+                return ret;
+        }
+
+        *val = (uint8_t)ret;
+        return 0;
+}
+
+static inline int __da903x_reads(struct i2c_client *client, int reg,
+                                 int len, uint8_t *val)
+{
+        int ret;
+
+        ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed reading from 0x%02x\n", reg);
+                return ret;
+        }
+        return 0;
+}
+
+static inline int __da903x_write(struct i2c_client *client,
+                                 int reg, uint8_t val)
+{
+        int ret;
+
+        ret = i2c_smbus_write_byte_data(client, reg, val);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
+                                val, reg);
+                return ret;
+        }
+        return 0;
+}
+
+static inline int __da903x_writes(struct i2c_client *client, int reg,
+                                  int len, uint8_t *val)
+{
+        int ret;
+
+        ret = i2c_smbus_write_i2c_block_data(client, reg, len, val);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed writings to 0x%02x\n", reg);
+                return ret;
+        }
+        return 0;
+}
+
+int da903x_register_notifier(struct device *dev, struct notifier_block *nb,
+                                unsigned int events)
+{
+        struct da903x_chip *chip = dev_get_drvdata(dev);
+
+        chip->ops->unmask_events(chip, events);
+        return blocking_notifier_chain_register(&chip->notifier_list, nb);
+}
+EXPORT_SYMBOL_GPL(da903x_register_notifier);
+
+int da903x_unregister_notifier(struct device *dev, struct notifier_block *nb,
+                                unsigned int events)
+{
+        struct da903x_chip *chip = dev_get_drvdata(dev);
+
+        chip->ops->mask_events(chip, events);
+        return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
+}
+EXPORT_SYMBOL_GPL(da903x_unregister_notifier);
+
+int da903x_write(struct device *dev, int reg, uint8_t val)
+{
+        return __da903x_write(to_i2c_client(dev), reg, val);
+}
+EXPORT_SYMBOL_GPL(da903x_write);
+
+int da903x_read(struct device *dev, int reg, uint8_t *val)
+{
+        return __da903x_read(to_i2c_client(dev), reg, val);
+}
+EXPORT_SYMBOL_GPL(da903x_read);
+
+int da903x_set_bits(struct device *dev, int reg, uint8_t bit_mask)
+{
+        struct da903x_chip *chip = dev_get_drvdata(dev);
+        uint8_t reg_val;
+        int ret = 0;
+
+        mutex_lock(&chip->lock);
+
+        ret = __da903x_read(chip->client, reg, &reg_val);
+        if (ret)
+                goto out;
+
+        if ((reg_val & bit_mask) == 0) {
+                reg_val |= bit_mask;
+                ret = __da903x_write(chip->client, reg, reg_val);
+        }
+out:
+        mutex_unlock(&chip->lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(da903x_set_bits);
+
+int da903x_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
+{
+        struct da903x_chip *chip = dev_get_drvdata(dev);
+        uint8_t reg_val;
+        int ret = 0;
+
+        mutex_lock(&chip->lock);
+
+        ret = __da903x_read(chip->client, reg, &reg_val);
+        if (ret)
+                goto out;
+
+        if (reg_val & bit_mask) {
+                reg_val &= ~bit_mask;
+                ret = __da903x_write(chip->client, reg, reg_val);
+        }
+out:
+        mutex_unlock(&chip->lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(da903x_clr_bits);
+
+int da903x_update(struct device *dev, int reg, uint8_t val, uint8_t mask)
+{
+        struct da903x_chip *chip = dev_get_drvdata(dev);
+        uint8_t reg_val;
+        int ret = 0;
+
+        mutex_lock(&chip->lock);
+
+        ret = __da903x_read(chip->client, reg, &reg_val);
+        if (ret)
+                goto out;
+
+        if ((reg_val & mask) != val) {
+                reg_val = (reg_val & ~mask) | val;
+                ret = __da903x_write(chip->client, reg, reg_val);
+        }
+out:
+        mutex_unlock(&chip->lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(da903x_update);
+
+int da903x_query_status(struct device *dev, unsigned int sbits)
+{
+        struct da903x_chip *chip = dev_get_drvdata(dev);
+        unsigned int status = 0;
+
+        chip->ops->read_status(chip, &status);
+        return ((status & sbits) == sbits);
+}
+EXPORT_SYMBOL(da903x_query_status);
+
+static int __devinit da9030_init_chip(struct da903x_chip *chip)
+{
+        uint8_t chip_id;
+        int err;
+
+        err = __da903x_read(chip->client, DA9030_CHIP_ID, &chip_id);
+        if (err)
+                return err;
+
+        err = __da903x_write(chip->client, DA9030_SYS_CTRL_A, 0xE8);
+        if (err)
+                return err;
+
+        dev_info(chip->dev, "DA9030 (CHIP ID: 0x%02x) detected\n", chip_id);
+        return 0;
+}
+
+static int da9030_unmask_events(struct da903x_chip *chip, unsigned int events)
+{
+        uint8_t v[3];
+
+        chip->events_mask &= ~events;
+
+        v[0] = (chip->events_mask & 0xff);
+        v[1] = (chip->events_mask >> 8) & 0xff;
+        v[2] = (chip->events_mask >> 16) & 0xff;
+
+        return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
+}
+
+static int da9030_mask_events(struct da903x_chip *chip, unsigned int events)
+{
+        uint8_t v[3];
+
+        chip->events_mask &= ~events;
+
+        v[0] = (chip->events_mask & 0xff);
+        v[1] = (chip->events_mask >> 8) & 0xff;
+        v[2] = (chip->events_mask >> 16) & 0xff;
+
+        return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
+}
+
+static int da9030_read_events(struct da903x_chip *chip, unsigned int *events)
+{
+        uint8_t v[3] = {0, 0, 0};
+        int ret;
+
+        ret = __da903x_reads(chip->client, DA9030_EVENT_A, 3, v);
+        if (ret < 0)
+                return ret;
+
+        *events = (v[2] << 16) | (v[1] << 8) | v[0];
+        return 0;
+}
+
+static int da9030_read_status(struct da903x_chip *chip, unsigned int *status)
+{
+        return __da903x_read(chip->client, DA9030_STATUS, (uint8_t *)status);
+}
+
+static int da9034_init_chip(struct da903x_chip *chip)
+{
+        uint8_t chip_id;
+        int err;
+
+        err = __da903x_read(chip->client, DA9034_CHIP_ID, &chip_id);
+        if (err)
+                return err;
+
+        err = __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0xE8);
+        if (err)
+                return err;
+
+        /* avoid SRAM power off during sleep*/
+        __da903x_write(chip->client, 0x10, 0x07);
+        __da903x_write(chip->client, 0x11, 0xff);
+        __da903x_write(chip->client, 0x12, 0xff);
+
+        /* Enable the ONKEY power down functionality */
+        __da903x_write(chip->client, DA9034_SYS_CTRL_B, 0x20);
+        __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0x60);
+
+        /* workaround to make LEDs work */
+        __da903x_write(chip->client, 0x90, 0x01);
+        __da903x_write(chip->client, 0xB0, 0x08);
+
+        /* make ADTV1 and SDTV1 effective */
+        __da903x_write(chip->client, 0x20, 0x00);
+
+        dev_info(chip->dev, "DA9034 (CHIP ID: 0x%02x) detected\n", chip_id);
+        return 0;
+}
+
+static int da9034_unmask_events(struct da903x_chip *chip, unsigned int events)
+{
+        uint8_t v[4];
+
+        chip->events_mask &= ~events;
+
+        v[0] = (chip->events_mask & 0xff);
+        v[1] = (chip->events_mask >> 8) & 0xff;
+        v[2] = (chip->events_mask >> 16) & 0xff;
+        v[3] = (chip->events_mask >> 24) & 0xff;
+
+        return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
+}
+
+static int da9034_mask_events(struct da903x_chip *chip, unsigned int events)
+{
+        uint8_t v[4];
+
+        chip->events_mask |= events;
+
+        v[0] = (chip->events_mask & 0xff);
+        v[1] = (chip->events_mask >> 8) & 0xff;
+        v[2] = (chip->events_mask >> 16) & 0xff;
+        v[3] = (chip->events_mask >> 24) & 0xff;
+
+        return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
+}
+
+static int da9034_read_events(struct da903x_chip *chip, unsigned int *events)
+{
+        uint8_t v[4] = {0, 0, 0, 0};
+        int ret;
+
+        ret = __da903x_reads(chip->client, DA9034_EVENT_A, 4, v);
+        if (ret < 0)
+                return ret;
+
+        *events = (v[3] << 24) | (v[2] << 16) | (v[1] << 8) | v[0];
+        return 0;
+}
+
+static int da9034_read_status(struct da903x_chip *chip, unsigned int *status)
+{
+        uint8_t v[2] = {0, 0};
+        int ret = 0;
+
+        ret = __da903x_reads(chip->client, DA9034_STATUS_A, 2, v);
+        if (ret)
+                return ret;
+
+        *status = (v[1] << 8) | v[0];
+        return 0;
+}
+
+static void da903x_irq_work(struct work_struct *work)
+{
+        struct da903x_chip *chip =
+                container_of(work, struct da903x_chip, irq_work);
+        unsigned int events = 0;
+
+        while (1) {
+                if (chip->ops->read_events(chip, &events))
+                        break;
+
+                events &= ~chip->events_mask;
+                if (events == 0)
+                        break;
+
+                blocking_notifier_call_chain(
+                                &chip->notifier_list, events, NULL);
+        }
+        enable_irq(chip->client->irq);
+}
+
+static int da903x_irq_handler(int irq, void *data)
+{
+        struct da903x_chip *chip = data;
+
+        disable_irq_nosync(irq);
+        (void)schedule_work(&chip->irq_work);
+
+        return IRQ_HANDLED;
+}
+
+static struct da903x_chip_ops da903x_ops[] = {
+        [0] = {
+                .init_chip      = da9030_init_chip,
+                .unmask_events  = da9030_unmask_events,
+                .mask_events    = da9030_mask_events,
+                .read_events    = da9030_read_events,
+                .read_status    = da9030_read_status,
+        },
+        [1] = {
+                .init_chip      = da9034_init_chip,
+                .unmask_events  = da9034_unmask_events,
+                .mask_events    = da9034_mask_events,
+                .read_events    = da9034_read_events,
+                .read_status    = da9034_read_status,
+        }
+};
+
+static const struct i2c_device_id da903x_id_table[] = {
+        { "da9030", 0 },
+        { "da9034", 1 },
+        { },
+};
+MODULE_DEVICE_TABLE(i2c, da903x_id_table);
+
+static int __devexit __remove_subdev(struct device *dev, void *unused)
+{
+        platform_device_unregister(to_platform_device(dev));
+        return 0;
+}
+
+static int __devexit da903x_remove_subdevs(struct da903x_chip *chip)
+{
+        return device_for_each_child(chip->dev, NULL, __remove_subdev);
+}
+
+static int __devinit da903x_add_subdevs(struct da903x_chip *chip,
+                                        struct da903x_platform_data *pdata)
+{
+        struct da903x_subdev_info *subdev;
+        struct platform_device *pdev;
+        int i, ret = 0;
+
+        for (i = 0; i < pdata->num_subdevs; i++) {
+                subdev = &pdata->subdevs[i];
+
+                pdev = platform_device_alloc(subdev->name, subdev->id);
+
+                pdev->dev.parent = chip->dev;
+                pdev->dev.platform_data = subdev->platform_data;
+
+                ret = platform_device_add(pdev);
+                if (ret)
+                        goto failed;
+        }
+        return 0;
+
+failed:
+        da903x_remove_subdevs(chip);
+        return ret;
+}
+
+static int __devinit da903x_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
+{
+        struct da903x_platform_data *pdata = client->dev.platform_data;
+        struct da903x_chip *chip;
+        unsigned int tmp;
+        int ret;
+
+        chip = kzalloc(sizeof(struct da903x_chip), GFP_KERNEL);
+        if (chip == NULL)
+                return -ENOMEM;
+
+        chip->client = client;
+        chip->dev = &client->dev;
+        chip->ops = &da903x_ops[id->driver_data];
+
+        mutex_init(&chip->lock);
+        INIT_WORK(&chip->irq_work, da903x_irq_work);
+        BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list);
+
+        i2c_set_clientdata(client, chip);
+
+        ret = chip->ops->init_chip(chip);
+        if (ret)
+                goto out_free_chip;
+
+        /* mask and clear all IRQs */
+        chip->events_mask = 0xffffffff;
+        chip->ops->mask_events(chip, chip->events_mask);
+        chip->ops->read_events(chip, &tmp);
+
+        ret = request_irq(client->irq, da903x_irq_handler,
+                        IRQF_DISABLED | IRQF_TRIGGER_FALLING,
+                        "da903x", chip);
+        if (ret) {
+                dev_err(&client->dev, "failed to request irq %d\n",
+                                client->irq);
+                goto out_free_chip;
+        }
+
+        ret = da903x_add_subdevs(chip, pdata);
+        if (ret)
+                goto out_free_irq;
+
+        return 0;
+
+out_free_irq:
+        free_irq(client->irq, chip);
+out_free_chip:
+        i2c_set_clientdata(client, NULL);
+        kfree(chip);
+        return ret;
+}
+
+static int __devexit da903x_remove(struct i2c_client *client)
+{
+        struct da903x_chip *chip = i2c_get_clientdata(client);
+
+        da903x_remove_subdevs(chip);
+        kfree(chip);
+        return 0;
+}
+
+static struct i2c_driver da903x_driver = {
+        .driver = {
+                .name   = "da903x",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = da903x_probe,
+        .remove         = __devexit_p(da903x_remove),
+        .id_table       = da903x_id_table,
+};
+
+static int __init da903x_init(void)
+{
+        return i2c_add_driver(&da903x_driver);
+}
+module_init(da903x_init);
+
+static void __exit da903x_exit(void)
+{
+        i2c_del_driver(&da903x_driver);
+}
+module_exit(da903x_exit);
+
+MODULE_DESCRIPTION("PMIC Driver for Dialog Semiconductor DA9034");
+MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>"
+              "Mike Rapoport <mike@compulab.co.il>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/htc-egpio.c b/drivers/mfd/htc-egpio.c
index 6be43172dc65..1a4d04664d6d 100644
--- a/drivers/mfd/htc-egpio.c
+++ b/drivers/mfd/htc-egpio.c
@@ -112,7 +112,7 @@ static void egpio_handler(unsigned int irq, struct irq_desc *desc)
                 /* Run irq handler */
                 pr_debug("got IRQ %d\n", irqpin);
                 irq = ei->irq_start + irqpin;
-                desc = &irq_desc[irq];
+                desc = irq_to_desc(irq);
                 desc->handle_irq(irq, desc);
         }
 }
@@ -289,7 +289,7 @@ static int __init egpio_probe(struct platform_device *pdev)
         ei->base_addr = ioremap_nocache(res->start, res->end - res->start);
         if (!ei->base_addr)
                 goto fail;
-        pr_debug("EGPIO phys=%08x virt=%p\n", res->start, ei->base_addr);
+        pr_debug("EGPIO phys=%08x virt=%p\n", (u32)res->start, ei->base_addr);
 
         if ((pdata->bus_width != 16) && (pdata->bus_width != 32))
                 goto fail;
diff --git a/drivers/mfd/mfd-core.c b/drivers/mfd/mfd-core.c
index 9c9c126ed334..6c0d1bec4b76 100644
--- a/drivers/mfd/mfd-core.c
+++ b/drivers/mfd/mfd-core.c
@@ -20,7 +20,7 @@ static int mfd_add_device(struct device *parent, int id,
                           struct resource *mem_base,
                           int irq_base)
 {
-        struct resource res[cell->num_resources];
+        struct resource *res;
         struct platform_device *pdev;
         int ret = -ENOMEM;
         int r;
@@ -29,14 +29,17 @@ static int mfd_add_device(struct device *parent, int id,
         if (!pdev)
                 goto fail_alloc;
 
+        res = kzalloc(sizeof(*res) * cell->num_resources, GFP_KERNEL);
+        if (!res)
+                goto fail_device;
+
         pdev->dev.parent = parent;
 
         ret = platform_device_add_data(pdev,
                         cell->platform_data, cell->data_size);
         if (ret)
-                goto fail_device;
+                goto fail_res;
 
-        memset(res, 0, sizeof(res));
         for (r = 0; r < cell->num_resources; r++) {
                 res[r].name = cell->resources[r].name;
                 res[r].flags = cell->resources[r].flags;
@@ -64,11 +67,15 @@ static int mfd_add_device(struct device *parent, int id,
 
         ret = platform_device_add(pdev);
         if (ret)
-                goto fail_device;
+                goto fail_res;
+
+        kfree(res);
 
         return 0;
 
 /*      platform_device_del(pdev); */
+fail_res:
+        kfree(res);
 fail_device:
         platform_device_put(pdev);
 fail_alloc:
diff --git a/drivers/mfd/sm501.c b/drivers/mfd/sm501.c
index 7aebad4c06ff..220e4371266b 100644
--- a/drivers/mfd/sm501.c
+++ b/drivers/mfd/sm501.c
@@ -623,8 +623,8 @@ unsigned long sm501_set_clock(struct device *dev,
 
         sm501_sync_regs(sm);
 
-        dev_info(sm->dev, "gate %08lx, clock %08lx, mode %08lx\n",
-                 gate, clock, mode);
+        dev_dbg(sm->dev, "gate %08lx, clock %08lx, mode %08lx\n",
+                gate, clock, mode);
 
         sm501_mdelay(sm, 16);
         mutex_unlock(&sm->clock_lock);
@@ -742,7 +742,7 @@ static int sm501_register_device(struct sm501_devdata *sm,
         int ret;
 
         for (ptr = 0; ptr < pdev->num_resources; ptr++) {
-                printk("%s[%d] flags %08lx: %08llx..%08llx\n",
+                printk(KERN_DEBUG "%s[%d] flags %08lx: %08llx..%08llx\n",
                        pdev->name, ptr,
                        pdev->resource[ptr].flags,
                        (unsigned long long)pdev->resource[ptr].start,
diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
index 49a0fffc02af..9f7024c0f8ec 100644
--- a/drivers/mfd/t7l66xb.c
+++ b/drivers/mfd/t7l66xb.c
@@ -24,8 +24,10 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/err.h>
 #include <linux/io.h>
 #include <linux/irq.h>
+#include <linux/clk.h>
 #include <linux/platform_device.h>
 #include <linux/mfd/core.h>
 #include <linux/mfd/tmio.h>
@@ -56,6 +58,8 @@ struct t7l66xb {
         spinlock_t              lock;
 
         struct resource         rscr;
+        struct clk              *clk48m;
+        struct clk              *clk32k;
         int                     irq;
         int                     irq_base;
 };
@@ -65,13 +69,11 @@ struct t7l66xb {
 static int t7l66xb_mmc_enable(struct platform_device *mmc)
 {
         struct platform_device *dev = to_platform_device(mmc->dev.parent);
-        struct t7l66xb_platform_data   *pdata = dev->dev.platform_data;
         struct t7l66xb *t7l66xb = platform_get_drvdata(dev);
         unsigned long flags;
         u8 dev_ctl;
 
-        if (pdata->enable_clk32k)
-                pdata->enable_clk32k(dev);
+        clk_enable(t7l66xb->clk32k);
 
         spin_lock_irqsave(&t7l66xb->lock, flags);
 
@@ -87,7 +89,6 @@ static int t7l66xb_mmc_enable(struct platform_device *mmc)
 static int t7l66xb_mmc_disable(struct platform_device *mmc)
 {
         struct platform_device *dev = to_platform_device(mmc->dev.parent);
-        struct t7l66xb_platform_data   *pdata = dev->dev.platform_data;
         struct t7l66xb *t7l66xb = platform_get_drvdata(dev);
         unsigned long flags;
         u8 dev_ctl;
@@ -100,8 +101,7 @@ static int t7l66xb_mmc_disable(struct platform_device *mmc)
 
         spin_unlock_irqrestore(&t7l66xb->lock, flags);
 
-        if (pdata->disable_clk32k)
-                pdata->disable_clk32k(dev);
+        clk_disable(t7l66xb->clk32k);
 
         return 0;
 }
@@ -258,18 +258,22 @@ static void t7l66xb_detach_irq(struct platform_device *dev)
 #ifdef CONFIG_PM
 static int t7l66xb_suspend(struct platform_device *dev, pm_message_t state)
 {
+        struct t7l66xb *t7l66xb = platform_get_drvdata(dev);
         struct t7l66xb_platform_data *pdata = dev->dev.platform_data;
 
         if (pdata && pdata->suspend)
                 pdata->suspend(dev);
+        clk_disable(t7l66xb->clk48m);
 
         return 0;
 }
 
 static int t7l66xb_resume(struct platform_device *dev)
 {
+        struct t7l66xb *t7l66xb = platform_get_drvdata(dev);
         struct t7l66xb_platform_data *pdata = dev->dev.platform_data;
 
+        clk_enable(t7l66xb->clk48m);
         if (pdata && pdata->resume)
                 pdata->resume(dev);
 
@@ -309,6 +313,19 @@ static int t7l66xb_probe(struct platform_device *dev)
 
         t7l66xb->irq_base = pdata->irq_base;
 
+        t7l66xb->clk32k = clk_get(&dev->dev, "CLK_CK32K");
+        if (IS_ERR(t7l66xb->clk32k)) {
+                ret = PTR_ERR(t7l66xb->clk32k);
+                goto err_clk32k_get;
+        }
+
+        t7l66xb->clk48m = clk_get(&dev->dev, "CLK_CK48M");
+        if (IS_ERR(t7l66xb->clk48m)) {
+                ret = PTR_ERR(t7l66xb->clk48m);
+                clk_put(t7l66xb->clk32k);
+                goto err_clk48m_get;
+        }
+
         rscr = &t7l66xb->rscr;
         rscr->name = "t7l66xb-core";
         rscr->start = iomem->start;
@@ -325,6 +342,8 @@ static int t7l66xb_probe(struct platform_device *dev)
                 goto err_ioremap;
         }
 
+        clk_enable(t7l66xb->clk48m);
+
         if (pdata && pdata->enable)
                 pdata->enable(dev);
 
@@ -359,9 +378,13 @@ static int t7l66xb_probe(struct platform_device *dev)
         iounmap(t7l66xb->scr);
 err_ioremap:
         release_resource(&t7l66xb->rscr);
-err_noirq:
 err_request_scr:
         kfree(t7l66xb);
+        clk_put(t7l66xb->clk48m);
+err_clk48m_get:
+        clk_put(t7l66xb->clk32k);
+err_clk32k_get:
+err_noirq:
         return ret;
 }
 
@@ -372,7 +395,8 @@ static int t7l66xb_remove(struct platform_device *dev)
         int ret;
 
         ret = pdata->disable(dev);
-
+        clk_disable(t7l66xb->clk48m);
+        clk_put(t7l66xb->clk48m);
         t7l66xb_detach_irq(dev);
         iounmap(t7l66xb->scr);
         release_resource(&t7l66xb->rscr);
diff --git a/drivers/mfd/tc6387xb.c b/drivers/mfd/tc6387xb.c
index a22b21ac6cf8..43222c12fec1 100644
--- a/drivers/mfd/tc6387xb.c
+++ b/drivers/mfd/tc6387xb.c
@@ -12,6 +12,7 @@
 
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/mfd/core.h>
 #include <linux/mfd/tmio.h>
@@ -24,18 +25,22 @@ enum {
 #ifdef CONFIG_PM
 static int tc6387xb_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct tc6387xb_platform_data *pdata = platform_get_drvdata(dev);
+        struct clk *clk32k = platform_get_drvdata(dev);
+        struct tc6387xb_platform_data *pdata = dev->dev.platform_data;
 
         if (pdata && pdata->suspend)
                 pdata->suspend(dev);
+        clk_disable(clk32k);
 
         return 0;
 }
 
 static int tc6387xb_resume(struct platform_device *dev)
 {
-        struct tc6387xb_platform_data *pdata = platform_get_drvdata(dev);
+        struct clk *clk32k = platform_get_drvdata(dev);
+        struct tc6387xb_platform_data *pdata = dev->dev.platform_data;
 
+        clk_enable(clk32k);
         if (pdata && pdata->resume)
                 pdata->resume(dev);
 
@@ -51,10 +56,9 @@ static int tc6387xb_resume(struct platform_device *dev)
 static int tc6387xb_mmc_enable(struct platform_device *mmc)
 {
         struct platform_device *dev      = to_platform_device(mmc->dev.parent);
-        struct tc6387xb_platform_data *tc6387xb = dev->dev.platform_data;
+        struct clk *clk32k = platform_get_drvdata(dev);
 
-        if (tc6387xb->enable_clk32k)
-                tc6387xb->enable_clk32k(dev);
+        clk_enable(clk32k);
 
         return 0;
 }
@@ -62,10 +66,9 @@ static int tc6387xb_mmc_enable(struct platform_device *mmc)
 static int tc6387xb_mmc_disable(struct platform_device *mmc)
 {
         struct platform_device *dev      = to_platform_device(mmc->dev.parent);
-        struct tc6387xb_platform_data *tc6387xb = dev->dev.platform_data;
+        struct clk *clk32k = platform_get_drvdata(dev);
 
-        if (tc6387xb->disable_clk32k)
-                tc6387xb->disable_clk32k(dev);
+        clk_disable(clk32k);
 
         return 0;
 }
@@ -102,14 +105,14 @@ static struct mfd_cell tc6387xb_cells[] = {
 
 static int tc6387xb_probe(struct platform_device *dev)
 {
-        struct tc6387xb_platform_data *data = platform_get_drvdata(dev);
+        struct tc6387xb_platform_data *pdata = dev->dev.platform_data;
         struct resource *iomem;
+        struct clk *clk32k;
         int irq, ret;
 
         iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
         if (!iomem) {
-                ret = -EINVAL;
-                goto err_resource;
+                return -EINVAL;
         }
 
         ret  = platform_get_irq(dev, 0);
@@ -118,8 +121,15 @@ static int tc6387xb_probe(struct platform_device *dev)
         else
                 goto err_resource;
 
-        if (data && data->enable)
-                data->enable(dev);
+        clk32k = clk_get(&dev->dev, "CLK_CK32K");
+        if (IS_ERR(clk32k)) {
+                ret = PTR_ERR(clk32k);
+                goto err_resource;
+        }
+        platform_set_drvdata(dev, clk32k);
+
+        if (pdata && pdata->enable)
+                pdata->enable(dev);
 
         printk(KERN_INFO "Toshiba tc6387xb initialised\n");
 
@@ -134,18 +144,19 @@ static int tc6387xb_probe(struct platform_device *dev)
         if (!ret)
                 return 0;
 
+        clk_put(clk32k);
 err_resource:
         return ret;
 }
 
 static int tc6387xb_remove(struct platform_device *dev)
 {
-        struct tc6387xb_platform_data *data = platform_get_drvdata(dev);
-
-        if (data && data->disable)
-                data->disable(dev);
+        struct clk *clk32k = platform_get_drvdata(dev);
 
-        /* FIXME - free the resources! */
+        mfd_remove_devices(&dev->dev);
+        clk_disable(clk32k);
+        clk_put(clk32k);
+        platform_set_drvdata(dev, NULL);
 
         return 0;
 }
diff --git a/drivers/mfd/tc6393xb.c b/drivers/mfd/tc6393xb.c
index e4c1c788b5f8..f856e9463a9f 100644
--- a/drivers/mfd/tc6393xb.c
+++ b/drivers/mfd/tc6393xb.c
@@ -113,6 +113,8 @@ struct tc6393xb {
 enum {
         TC6393XB_CELL_NAND,
         TC6393XB_CELL_MMC,
+        TC6393XB_CELL_OHCI,
+        TC6393XB_CELL_FB,
 };
 
 /*--------------------------------------------------------------------------*/
@@ -170,6 +172,176 @@ static struct resource __devinitdata tc6393xb_mmc_resources[] = {
         },
 };
 
+const static struct resource tc6393xb_ohci_resources[] = {
+        {
+                .start  = 0x3000,
+                .end    = 0x31ff,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = 0x0300,
+                .end    = 0x03ff,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = 0x010000,
+                .end    = 0x017fff,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = 0x018000,
+                .end    = 0x01ffff,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = IRQ_TC6393_OHCI,
+                .end    = IRQ_TC6393_OHCI,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource __devinitdata tc6393xb_fb_resources[] = {
+        {
+                .start  = 0x5000,
+                .end    = 0x51ff,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = 0x0500,
+                .end    = 0x05ff,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = 0x100000,
+                .end    = 0x1fffff,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = IRQ_TC6393_FB,
+                .end    = IRQ_TC6393_FB,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static int tc6393xb_ohci_enable(struct platform_device *dev)
+{
+        struct tc6393xb *tc6393xb = dev_get_drvdata(dev->dev.parent);
+        unsigned long flags;
+        u16 ccr;
+        u8 fer;
+
+        spin_lock_irqsave(&tc6393xb->lock, flags);
+
+        ccr = tmio_ioread16(tc6393xb->scr + SCR_CCR);
+        ccr |= SCR_CCR_USBCK;
+        tmio_iowrite16(ccr, tc6393xb->scr + SCR_CCR);
+
+        fer = tmio_ioread8(tc6393xb->scr + SCR_FER);
+        fer |= SCR_FER_USBEN;
+        tmio_iowrite8(fer, tc6393xb->scr + SCR_FER);
+
+        spin_unlock_irqrestore(&tc6393xb->lock, flags);
+
+        return 0;
+}
+
+static int tc6393xb_ohci_disable(struct platform_device *dev)
+{
+        struct tc6393xb *tc6393xb = dev_get_drvdata(dev->dev.parent);
+        unsigned long flags;
+        u16 ccr;
+        u8 fer;
+
+        spin_lock_irqsave(&tc6393xb->lock, flags);
+
+        fer = tmio_ioread8(tc6393xb->scr + SCR_FER);
+        fer &= ~SCR_FER_USBEN;
+        tmio_iowrite8(fer, tc6393xb->scr + SCR_FER);
+
+        ccr = tmio_ioread16(tc6393xb->scr + SCR_CCR);
+        ccr &= ~SCR_CCR_USBCK;
+        tmio_iowrite16(ccr, tc6393xb->scr + SCR_CCR);
+
+        spin_unlock_irqrestore(&tc6393xb->lock, flags);
+
+        return 0;
+}
+
+static int tc6393xb_fb_enable(struct platform_device *dev)
+{
+        struct tc6393xb *tc6393xb = dev_get_drvdata(dev->dev.parent);
+        unsigned long flags;
+        u16 ccr;
+
+        spin_lock_irqsave(&tc6393xb->lock, flags);
+
+        ccr = tmio_ioread16(tc6393xb->scr + SCR_CCR);
+        ccr &= ~SCR_CCR_MCLK_MASK;
+        ccr |= SCR_CCR_MCLK_48;
+        tmio_iowrite16(ccr, tc6393xb->scr + SCR_CCR);
+
+        spin_unlock_irqrestore(&tc6393xb->lock, flags);
+
+        return 0;
+}
+
+static int tc6393xb_fb_disable(struct platform_device *dev)
+{
+        struct tc6393xb *tc6393xb = dev_get_drvdata(dev->dev.parent);
+        unsigned long flags;
+        u16 ccr;
+
+        spin_lock_irqsave(&tc6393xb->lock, flags);
+
+        ccr = tmio_ioread16(tc6393xb->scr + SCR_CCR);
+        ccr &= ~SCR_CCR_MCLK_MASK;
+        ccr |= SCR_CCR_MCLK_OFF;
+        tmio_iowrite16(ccr, tc6393xb->scr + SCR_CCR);
+
+        spin_unlock_irqrestore(&tc6393xb->lock, flags);
+
+        return 0;
+}
+
+int tc6393xb_lcd_set_power(struct platform_device *fb, bool on)
+{
+        struct platform_device *dev = to_platform_device(fb->dev.parent);
+        struct tc6393xb *tc6393xb = platform_get_drvdata(dev);
+        u8 fer;
+        unsigned long flags;
+
+        spin_lock_irqsave(&tc6393xb->lock, flags);
+
+        fer = ioread8(tc6393xb->scr + SCR_FER);
+        if (on)
+                fer |= SCR_FER_SLCDEN;
+        else
+                fer &= ~SCR_FER_SLCDEN;
+        iowrite8(fer, tc6393xb->scr + SCR_FER);
+
+        spin_unlock_irqrestore(&tc6393xb->lock, flags);
+
+        return 0;
+}
+EXPORT_SYMBOL(tc6393xb_lcd_set_power);
+
+int tc6393xb_lcd_mode(struct platform_device *fb,
+                                        const struct fb_videomode *mode) {
+        struct platform_device *dev = to_platform_device(fb->dev.parent);
+        struct tc6393xb *tc6393xb = platform_get_drvdata(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&tc6393xb->lock, flags);
+
+        iowrite16(mode->pixclock, tc6393xb->scr + SCR_PLL1CR + 0);
+        iowrite16(mode->pixclock >> 16, tc6393xb->scr + SCR_PLL1CR + 2);
+
+        spin_unlock_irqrestore(&tc6393xb->lock, flags);
+
+        return 0;
+}
+EXPORT_SYMBOL(tc6393xb_lcd_mode);
+
 static struct mfd_cell __devinitdata tc6393xb_cells[] = {
         [TC6393XB_CELL_NAND] = {
                 .name = "tmio-nand",
@@ -182,6 +354,24 @@ static struct mfd_cell __devinitdata tc6393xb_cells[] = {
                 .num_resources = ARRAY_SIZE(tc6393xb_mmc_resources),
                 .resources = tc6393xb_mmc_resources,
         },
+        [TC6393XB_CELL_OHCI] = {
+                .name = "tmio-ohci",
+                .num_resources = ARRAY_SIZE(tc6393xb_ohci_resources),
+                .resources = tc6393xb_ohci_resources,
+                .enable = tc6393xb_ohci_enable,
+                .suspend = tc6393xb_ohci_disable,
+                .resume = tc6393xb_ohci_enable,
+                .disable = tc6393xb_ohci_disable,
+        },
+        [TC6393XB_CELL_FB] = {
+                .name = "tmio-fb",
+                .num_resources = ARRAY_SIZE(tc6393xb_fb_resources),
+                .resources = tc6393xb_fb_resources,
+                .enable = tc6393xb_fb_enable,
+                .suspend = tc6393xb_fb_disable,
+                .resume = tc6393xb_fb_enable,
+                .disable = tc6393xb_fb_disable,
+        },
 };
 
 /*--------------------------------------------------------------------------*/
@@ -369,41 +559,12 @@ static void tc6393xb_detach_irq(struct platform_device *dev)
 
 /*--------------------------------------------------------------------------*/
 
-static int tc6393xb_hw_init(struct platform_device *dev)
-{
-        struct tc6393xb_platform_data *tcpd = dev->dev.platform_data;
-        struct tc6393xb *tc6393xb = platform_get_drvdata(dev);
-        int i;
-
-        iowrite8(tc6393xb->suspend_state.fer,   tc6393xb->scr + SCR_FER);
-        iowrite16(tcpd->scr_pll2cr,             tc6393xb->scr + SCR_PLL2CR);
-        iowrite16(tc6393xb->suspend_state.ccr,  tc6393xb->scr + SCR_CCR);
-        iowrite16(SCR_MCR_RDY_OPENDRAIN | SCR_MCR_RDY_UNK | SCR_MCR_RDY_EN |
-                  SCR_MCR_INT_OPENDRAIN | SCR_MCR_INT_UNK | SCR_MCR_INT_EN |
-                  BIT(15),                      tc6393xb->scr + SCR_MCR);
-        iowrite16(tcpd->scr_gper,               tc6393xb->scr + SCR_GPER);
-        iowrite8(0,                             tc6393xb->scr + SCR_IRR);
-        iowrite8(0xbf,                          tc6393xb->scr + SCR_IMR);
-
-        for (i = 0; i < 3; i++) {
-                iowrite8(tc6393xb->suspend_state.gpo_dsr[i],
-                                        tc6393xb->scr + SCR_GPO_DSR(i));
-                iowrite8(tc6393xb->suspend_state.gpo_doecr[i],
-                                        tc6393xb->scr + SCR_GPO_DOECR(i));
-                iowrite8(tc6393xb->suspend_state.gpi_bcr[i],
-                                        tc6393xb->scr + SCR_GPI_BCR(i));
-        }
-
-        return 0;
-}
-
 static int __devinit tc6393xb_probe(struct platform_device *dev)
 {
         struct tc6393xb_platform_data *tcpd = dev->dev.platform_data;
         struct tc6393xb *tc6393xb;
         struct resource *iomem, *rscr;
         int ret, temp;
-        int i;
 
         iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
         if (!iomem)
@@ -458,21 +619,16 @@ static int __devinit tc6393xb_probe(struct platform_device *dev)
         if (ret)
                 goto err_enable;
 
-        tc6393xb->suspend_state.fer = 0;
-
-        for (i = 0; i < 3; i++) {
-                tc6393xb->suspend_state.gpo_dsr[i] =
-                        (tcpd->scr_gpo_dsr >> (8 * i)) & 0xff;
-                tc6393xb->suspend_state.gpo_doecr[i] =
-                        (tcpd->scr_gpo_doecr >> (8 * i)) & 0xff;
-        }
-
-        tc6393xb->suspend_state.ccr = SCR_CCR_UNK1 |
-                                        SCR_CCR_HCLK_48;
-
-        ret = tc6393xb_hw_init(dev);
-        if (ret)
-                goto err_hw_init;
+        iowrite8(0,                             tc6393xb->scr + SCR_FER);
+        iowrite16(tcpd->scr_pll2cr,             tc6393xb->scr + SCR_PLL2CR);
+        iowrite16(SCR_CCR_UNK1 | SCR_CCR_HCLK_48,
+                                                tc6393xb->scr + SCR_CCR);
+        iowrite16(SCR_MCR_RDY_OPENDRAIN | SCR_MCR_RDY_UNK | SCR_MCR_RDY_EN |
+                  SCR_MCR_INT_OPENDRAIN | SCR_MCR_INT_UNK | SCR_MCR_INT_EN |
+                  BIT(15),                      tc6393xb->scr + SCR_MCR);
+        iowrite16(tcpd->scr_gper,               tc6393xb->scr + SCR_GPER);
+        iowrite8(0,                             tc6393xb->scr + SCR_IRR);
+        iowrite8(0xbf,                          tc6393xb->scr + SCR_IMR);
 
         printk(KERN_INFO "Toshiba tc6393xb revision %d at 0x%08lx, irq %d\n",
                         tmio_ioread8(tc6393xb->scr + SCR_REVID),
@@ -488,16 +644,33 @@ static int __devinit tc6393xb_probe(struct platform_device *dev)
 
         tc6393xb_attach_irq(dev);
 
+        if (tcpd->setup) {
+                ret = tcpd->setup(dev);
+                if (ret)
+                        goto err_setup;
+        }
+
         tc6393xb_cells[TC6393XB_CELL_NAND].driver_data = tcpd->nand_data;
         tc6393xb_cells[TC6393XB_CELL_NAND].platform_data =
                 &tc6393xb_cells[TC6393XB_CELL_NAND];
         tc6393xb_cells[TC6393XB_CELL_NAND].data_size =
                 sizeof(tc6393xb_cells[TC6393XB_CELL_NAND]);
+
         tc6393xb_cells[TC6393XB_CELL_MMC].platform_data =
                 &tc6393xb_cells[TC6393XB_CELL_MMC];
         tc6393xb_cells[TC6393XB_CELL_MMC].data_size =
                 sizeof(tc6393xb_cells[TC6393XB_CELL_MMC]);
 
+        tc6393xb_cells[TC6393XB_CELL_OHCI].platform_data =
+                &tc6393xb_cells[TC6393XB_CELL_OHCI];
+        tc6393xb_cells[TC6393XB_CELL_OHCI].data_size =
+                sizeof(tc6393xb_cells[TC6393XB_CELL_OHCI]);
+
+        tc6393xb_cells[TC6393XB_CELL_FB].driver_data = tcpd->fb_data;
+        tc6393xb_cells[TC6393XB_CELL_FB].platform_data =
+                &tc6393xb_cells[TC6393XB_CELL_FB];
+        tc6393xb_cells[TC6393XB_CELL_FB].data_size =
+                sizeof(tc6393xb_cells[TC6393XB_CELL_FB]);
 
         ret = mfd_add_devices(&dev->dev, dev->id,
                         tc6393xb_cells, ARRAY_SIZE(tc6393xb_cells),
@@ -506,12 +679,15 @@ static int __devinit tc6393xb_probe(struct platform_device *dev)
         if (!ret)
                 return 0;
 
+        if (tcpd->teardown)
+                tcpd->teardown(dev);
+
+err_setup:
         tc6393xb_detach_irq(dev);
 
 err_gpio_add:
         if (tc6393xb->gpio.base != -1)
                 temp = gpiochip_remove(&tc6393xb->gpio);
-err_hw_init:
         tcpd->disable(dev);
 err_clk_enable:
         clk_disable(tc6393xb->clk);
@@ -535,6 +711,10 @@ static int __devexit tc6393xb_remove(struct platform_device *dev)
         int ret;
 
         mfd_remove_devices(&dev->dev);
+
+        if (tcpd->teardown)
+                tcpd->teardown(dev);
+
         tc6393xb_detach_irq(dev);
 
         if (tc6393xb->gpio.base != -1) {
@@ -585,15 +765,37 @@ static int tc6393xb_resume(struct platform_device *dev)
         struct tc6393xb_platform_data *tcpd = dev->dev.platform_data;
         struct tc6393xb *tc6393xb = platform_get_drvdata(dev);
         int ret;
+        int i;
 
         clk_enable(tc6393xb->clk);
 
         ret = tcpd->resume(dev);
-
         if (ret)
                 return ret;
 
-        return tc6393xb_hw_init(dev);
+        if (!tcpd->resume_restore)
+                return 0;
+
+        iowrite8(tc6393xb->suspend_state.fer,   tc6393xb->scr + SCR_FER);
+        iowrite16(tcpd->scr_pll2cr,             tc6393xb->scr + SCR_PLL2CR);
+        iowrite16(tc6393xb->suspend_state.ccr,  tc6393xb->scr + SCR_CCR);
+        iowrite16(SCR_MCR_RDY_OPENDRAIN | SCR_MCR_RDY_UNK | SCR_MCR_RDY_EN |
+                  SCR_MCR_INT_OPENDRAIN | SCR_MCR_INT_UNK | SCR_MCR_INT_EN |
+                  BIT(15),                      tc6393xb->scr + SCR_MCR);
+        iowrite16(tcpd->scr_gper,               tc6393xb->scr + SCR_GPER);
+        iowrite8(0,                             tc6393xb->scr + SCR_IRR);
+        iowrite8(0xbf,                          tc6393xb->scr + SCR_IMR);
+
+        for (i = 0; i < 3; i++) {
+                iowrite8(tc6393xb->suspend_state.gpo_dsr[i],
+                                        tc6393xb->scr + SCR_GPO_DSR(i));
+                iowrite8(tc6393xb->suspend_state.gpo_doecr[i],
+                                        tc6393xb->scr + SCR_GPO_DOECR(i));
+                iowrite8(tc6393xb->suspend_state.gpi_bcr[i],
+                                        tc6393xb->scr + SCR_GPI_BCR(i));
+        }
+
+        return 0;
 }
 #else
 #define tc6393xb_suspend NULL
diff --git a/drivers/mfd/twl4030-core.c b/drivers/mfd/twl4030-core.c
new file mode 100644
index 000000000000..fd9a0160202c
--- /dev/null
+++ b/drivers/mfd/twl4030-core.c
@@ -0,0 +1,1193 @@
+/*
+ * twl4030_core.c - driver for TWL4030/TPS659x0 PM and audio CODEC devices
+ *
+ * Copyright (C) 2005-2006 Texas Instruments, Inc.
+ *
+ * Modifications to defer interrupt handling to a kernel thread:
+ * Copyright (C) 2006 MontaVista Software, Inc.
+ *
+ * Based on tlv320aic23.c:
+ * Copyright (c) by Kai Svahn <kai.svahn@nokia.com>
+ *
+ * Code cleanup and modifications to IRQ handler.
+ * by syed khasim <x0khasim@ti.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/kernel_stat.h>
+#include <linux/init.h>
+#include <linux/mutex.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/random.h>
+#include <linux/kthread.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+#include <linux/i2c.h>
+#include <linux/i2c/twl4030.h>
+
+
+/*
+ * The TWL4030 "Triton 2" is one of a family of a multi-function "Power
+ * Management and System Companion Device" chips originally designed for
+ * use in OMAP2 and OMAP 3 based systems.  Its control interfaces use I2C,
+ * often at around 3 Mbit/sec, including for interrupt handling.
+ *
+ * This driver core provides genirq support for the interrupts emitted,
+ * by the various modules, and exports register access primitives.
+ *
+ * FIXME this driver currently requires use of the first interrupt line
+ * (and associated registers).
+ */
+
+#define DRIVER_NAME                     "twl4030"
+
+#if defined(CONFIG_TWL4030_BCI_BATTERY) || \
+        defined(CONFIG_TWL4030_BCI_BATTERY_MODULE)
+#define twl_has_bci()           true
+#else
+#define twl_has_bci()           false
+#endif
+
+#if defined(CONFIG_KEYBOARD_TWL4030) || defined(CONFIG_KEYBOARD_TWL4030_MODULE)
+#define twl_has_keypad()        true
+#else
+#define twl_has_keypad()        false
+#endif
+
+#if defined(CONFIG_GPIO_TWL4030) || defined(CONFIG_GPIO_TWL4030_MODULE)
+#define twl_has_gpio()  true
+#else
+#define twl_has_gpio()  false
+#endif
+
+#if defined(CONFIG_TWL4030_MADC) || defined(CONFIG_TWL4030_MADC_MODULE)
+#define twl_has_madc()  true
+#else
+#define twl_has_madc()  false
+#endif
+
+#if defined(CONFIG_RTC_DRV_TWL4030) || defined(CONFIG_RTC_DRV_TWL4030_MODULE)
+#define twl_has_rtc()   true
+#else
+#define twl_has_rtc()   false
+#endif
+
+#if defined(CONFIG_TWL4030_USB) || defined(CONFIG_TWL4030_USB_MODULE)
+#define twl_has_usb()   true
+#else
+#define twl_has_usb()   false
+#endif
+
+static inline void activate_irq(int irq)
+{
+#ifdef CONFIG_ARM
+        /* ARM requires an extra step to clear IRQ_NOREQUEST, which it
+         * sets on behalf of every irq_chip.  Also sets IRQ_NOPROBE.
+         */
+        set_irq_flags(irq, IRQF_VALID);
+#else
+        /* same effect on other architectures */
+        set_irq_noprobe(irq);
+#endif
+}
+
+/* Primary Interrupt Handler on TWL4030 Registers */
+
+/* Register Definitions */
+
+#define REG_PIH_ISR_P1                  (0x1)
+#define REG_PIH_ISR_P2                  (0x2)
+#define REG_PIH_SIR                     (0x3)
+
+/* Triton Core internal information (BEGIN) */
+
+/* Last - for index max*/
+#define TWL4030_MODULE_LAST             TWL4030_MODULE_SECURED_REG
+
+#define TWL4030_NUM_SLAVES              4
+
+
+/* Base Address defns for twl4030_map[] */
+
+/* subchip/slave 0 - USB ID */
+#define TWL4030_BASEADD_USB             0x0000
+
+/* subchip/slave 1 - AUD ID */
+#define TWL4030_BASEADD_AUDIO_VOICE     0x0000
+#define TWL4030_BASEADD_GPIO            0x0098
+#define TWL4030_BASEADD_INTBR           0x0085
+#define TWL4030_BASEADD_PIH             0x0080
+#define TWL4030_BASEADD_TEST            0x004C
+
+/* subchip/slave 2 - AUX ID */
+#define TWL4030_BASEADD_INTERRUPTS      0x00B9
+#define TWL4030_BASEADD_LED             0x00EE
+#define TWL4030_BASEADD_MADC            0x0000
+#define TWL4030_BASEADD_MAIN_CHARGE     0x0074
+#define TWL4030_BASEADD_PRECHARGE       0x00AA
+#define TWL4030_BASEADD_PWM0            0x00F8
+#define TWL4030_BASEADD_PWM1            0x00FB
+#define TWL4030_BASEADD_PWMA            0x00EF
+#define TWL4030_BASEADD_PWMB            0x00F1
+#define TWL4030_BASEADD_KEYPAD          0x00D2
+
+/* subchip/slave 3 - POWER ID */
+#define TWL4030_BASEADD_BACKUP          0x0014
+#define TWL4030_BASEADD_INT             0x002E
+#define TWL4030_BASEADD_PM_MASTER       0x0036
+#define TWL4030_BASEADD_PM_RECEIVER     0x005B
+#define TWL4030_BASEADD_RTC             0x001C
+#define TWL4030_BASEADD_SECURED_REG     0x0000
+
+/* Triton Core internal information (END) */
+
+
+/* Few power values */
+#define R_CFG_BOOT                      0x05
+#define R_PROTECT_KEY                   0x0E
+
+/* access control values for R_PROTECT_KEY */
+#define KEY_UNLOCK1                     0xce
+#define KEY_UNLOCK2                     0xec
+#define KEY_LOCK                        0x00
+
+/* some fields in R_CFG_BOOT */
+#define HFCLK_FREQ_19p2_MHZ             (1 << 0)
+#define HFCLK_FREQ_26_MHZ               (2 << 0)
+#define HFCLK_FREQ_38p4_MHZ             (3 << 0)
+#define HIGH_PERF_SQ                    (1 << 3)
+
+
+/*----------------------------------------------------------------------*/
+
+/**
+ * struct twl4030_mod_iregs - TWL module IMR/ISR regs to mask/clear at init
+ * @mod_no: TWL4030 module number (e.g., TWL4030_MODULE_GPIO)
+ * @sih_ctrl: address of module SIH_CTRL register
+ * @reg_cnt: number of IMR/ISR regs
+ * @imrs: pointer to array of TWL module interrupt mask register indices
+ * @isrs: pointer to array of TWL module interrupt status register indices
+ *
+ * Ties together TWL4030 modules and lists of IMR/ISR registers to mask/clear
+ * during twl_init_irq().
+ */
+struct twl4030_mod_iregs {
+        const u8 mod_no;
+        const u8 sih_ctrl;
+        const u8 reg_cnt;
+        const u8 *imrs;
+        const u8 *isrs;
+};
+
+/* TWL4030 INT module interrupt mask registers */
+static const u8 __initconst twl4030_int_imr_regs[] = {
+        TWL4030_INT_PWR_IMR1,
+        TWL4030_INT_PWR_IMR2,
+};
+
+/* TWL4030 INT module interrupt status registers */
+static const u8 __initconst twl4030_int_isr_regs[] = {
+        TWL4030_INT_PWR_ISR1,
+        TWL4030_INT_PWR_ISR2,
+};
+
+/* TWL4030 INTERRUPTS module interrupt mask registers */
+static const u8 __initconst twl4030_interrupts_imr_regs[] = {
+        TWL4030_INTERRUPTS_BCIIMR1A,
+        TWL4030_INTERRUPTS_BCIIMR1B,
+        TWL4030_INTERRUPTS_BCIIMR2A,
+        TWL4030_INTERRUPTS_BCIIMR2B,
+};
+
+/* TWL4030 INTERRUPTS module interrupt status registers */
+static const u8 __initconst twl4030_interrupts_isr_regs[] = {
+        TWL4030_INTERRUPTS_BCIISR1A,
+        TWL4030_INTERRUPTS_BCIISR1B,
+        TWL4030_INTERRUPTS_BCIISR2A,
+        TWL4030_INTERRUPTS_BCIISR2B,
+};
+
+/* TWL4030 MADC module interrupt mask registers */
+static const u8 __initconst twl4030_madc_imr_regs[] = {
+        TWL4030_MADC_IMR1,
+        TWL4030_MADC_IMR2,
+};
+
+/* TWL4030 MADC module interrupt status registers */
+static const u8 __initconst twl4030_madc_isr_regs[] = {
+        TWL4030_MADC_ISR1,
+        TWL4030_MADC_ISR2,
+};
+
+/* TWL4030 keypad module interrupt mask registers */
+static const u8 __initconst twl4030_keypad_imr_regs[] = {
+        TWL4030_KEYPAD_KEYP_IMR1,
+        TWL4030_KEYPAD_KEYP_IMR2,
+};
+
+/* TWL4030 keypad module interrupt status registers */
+static const u8 __initconst twl4030_keypad_isr_regs[] = {
+        TWL4030_KEYPAD_KEYP_ISR1,
+        TWL4030_KEYPAD_KEYP_ISR2,
+};
+
+/* TWL4030 GPIO module interrupt mask registers */
+static const u8 __initconst twl4030_gpio_imr_regs[] = {
+        REG_GPIO_IMR1A,
+        REG_GPIO_IMR1B,
+        REG_GPIO_IMR2A,
+        REG_GPIO_IMR2B,
+        REG_GPIO_IMR3A,
+        REG_GPIO_IMR3B,
+};
+
+/* TWL4030 GPIO module interrupt status registers */
+static const u8 __initconst twl4030_gpio_isr_regs[] = {
+        REG_GPIO_ISR1A,
+        REG_GPIO_ISR1B,
+        REG_GPIO_ISR2A,
+        REG_GPIO_ISR2B,
+        REG_GPIO_ISR3A,
+        REG_GPIO_ISR3B,
+};
+
+/* TWL4030 modules that have IMR/ISR registers that must be masked/cleared */
+static const struct twl4030_mod_iregs __initconst twl4030_mod_regs[] = {
+        {
+                .mod_no   = TWL4030_MODULE_INT,
+                .sih_ctrl = TWL4030_INT_PWR_SIH_CTRL,
+                .reg_cnt  = ARRAY_SIZE(twl4030_int_imr_regs),
+                .imrs     = twl4030_int_imr_regs,
+                .isrs     = twl4030_int_isr_regs,
+        },
+        {
+                .mod_no   = TWL4030_MODULE_INTERRUPTS,
+                .sih_ctrl = TWL4030_INTERRUPTS_BCISIHCTRL,
+                .reg_cnt  = ARRAY_SIZE(twl4030_interrupts_imr_regs),
+                .imrs     = twl4030_interrupts_imr_regs,
+                .isrs     = twl4030_interrupts_isr_regs,
+        },
+        {
+                .mod_no   = TWL4030_MODULE_MADC,
+                .sih_ctrl = TWL4030_MADC_SIH_CTRL,
+                .reg_cnt  = ARRAY_SIZE(twl4030_madc_imr_regs),
+                .imrs     = twl4030_madc_imr_regs,
+                .isrs     = twl4030_madc_isr_regs,
+        },
+        {
+                .mod_no   = TWL4030_MODULE_KEYPAD,
+                .sih_ctrl = TWL4030_KEYPAD_KEYP_SIH_CTRL,
+                .reg_cnt  = ARRAY_SIZE(twl4030_keypad_imr_regs),
+                .imrs     = twl4030_keypad_imr_regs,
+                .isrs     = twl4030_keypad_isr_regs,
+        },
+        {
+                .mod_no   = TWL4030_MODULE_GPIO,
+                .sih_ctrl = REG_GPIO_SIH_CTRL,
+                .reg_cnt  = ARRAY_SIZE(twl4030_gpio_imr_regs),
+                .imrs     = twl4030_gpio_imr_regs,
+                .isrs     = twl4030_gpio_isr_regs,
+        },
+};
+
+/*----------------------------------------------------------------*/
+
+/* is driver active, bound to a chip? */
+static bool inuse;
+
+/* Structure for each TWL4030 Slave */
+struct twl4030_client {
+        struct i2c_client *client;
+        u8 address;
+
+        /* max numb of i2c_msg required is for read =2 */
+        struct i2c_msg xfer_msg[2];
+
+        /* To lock access to xfer_msg */
+        struct mutex xfer_lock;
+};
+
+static struct twl4030_client twl4030_modules[TWL4030_NUM_SLAVES];
+
+
+/* mapping the module id to slave id and base address */
+struct twl4030mapping {
+        unsigned char sid;      /* Slave ID */
+        unsigned char base;     /* base address */
+};
+
+static struct twl4030mapping twl4030_map[TWL4030_MODULE_LAST + 1] = {
+        /*
+         * NOTE:  don't change this table without updating the
+         * <linux/i2c/twl4030.h> defines for TWL4030_MODULE_*
+         * so they continue to match the order in this table.
+         */
+
+        { 0, TWL4030_BASEADD_USB },
+
+        { 1, TWL4030_BASEADD_AUDIO_VOICE },
+        { 1, TWL4030_BASEADD_GPIO },
+        { 1, TWL4030_BASEADD_INTBR },
+        { 1, TWL4030_BASEADD_PIH },
+        { 1, TWL4030_BASEADD_TEST },
+
+        { 2, TWL4030_BASEADD_KEYPAD },
+        { 2, TWL4030_BASEADD_MADC },
+        { 2, TWL4030_BASEADD_INTERRUPTS },
+        { 2, TWL4030_BASEADD_LED },
+        { 2, TWL4030_BASEADD_MAIN_CHARGE },
+        { 2, TWL4030_BASEADD_PRECHARGE },
+        { 2, TWL4030_BASEADD_PWM0 },
+        { 2, TWL4030_BASEADD_PWM1 },
+        { 2, TWL4030_BASEADD_PWMA },
+        { 2, TWL4030_BASEADD_PWMB },
+
+        { 3, TWL4030_BASEADD_BACKUP },
+        { 3, TWL4030_BASEADD_INT },
+        { 3, TWL4030_BASEADD_PM_MASTER },
+        { 3, TWL4030_BASEADD_PM_RECEIVER },
+        { 3, TWL4030_BASEADD_RTC },
+        { 3, TWL4030_BASEADD_SECURED_REG },
+};
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * TWL4030 doesn't have PIH mask, hence dummy function for mask
+ * and unmask of the (eight) interrupts reported at that level ...
+ * masking is only available from SIH (secondary) modules.
+ */
+
+static void twl4030_i2c_ackirq(unsigned int irq)
+{
+}
+
+static void twl4030_i2c_disableint(unsigned int irq)
+{
+}
+
+static void twl4030_i2c_enableint(unsigned int irq)
+{
+}
+
+static struct irq_chip twl4030_irq_chip = {
+        .name   = "twl4030",
+        .ack    = twl4030_i2c_ackirq,
+        .mask   = twl4030_i2c_disableint,
+        .unmask = twl4030_i2c_enableint,
+};
+
+/*----------------------------------------------------------------------*/
+
+/* Exported Functions */
+
+/**
+ * twl4030_i2c_write - Writes a n bit register in TWL4030
+ * @mod_no: module number
+ * @value: an array of num_bytes+1 containing data to write
+ * @reg: register address (just offset will do)
+ * @num_bytes: number of bytes to transfer
+ *
+ * IMPORTANT: for 'value' parameter: Allocate value num_bytes+1 and
+ * valid data starts at Offset 1.
+ *
+ * Returns the result of operation - 0 is success
+ */
+int twl4030_i2c_write(u8 mod_no, u8 *value, u8 reg, u8 num_bytes)
+{
+        int ret;
+        int sid;
+        struct twl4030_client *twl;
+        struct i2c_msg *msg;
+
+        if (unlikely(mod_no > TWL4030_MODULE_LAST)) {
+                pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
+                return -EPERM;
+        }
+        sid = twl4030_map[mod_no].sid;
+        twl = &twl4030_modules[sid];
+
+        if (unlikely(!inuse)) {
+                pr_err("%s: client %d is not initialized\n", DRIVER_NAME, sid);
+                return -EPERM;
+        }
+        mutex_lock(&twl->xfer_lock);
+        /*
+         * [MSG1]: fill the register address data
+         * fill the data Tx buffer
+         */
+        msg = &twl->xfer_msg[0];
+        msg->addr = twl->address;
+        msg->len = num_bytes + 1;
+        msg->flags = 0;
+        msg->buf = value;
+        /* over write the first byte of buffer with the register address */
+        *value = twl4030_map[mod_no].base + reg;
+        ret = i2c_transfer(twl->client->adapter, twl->xfer_msg, 1);
+        mutex_unlock(&twl->xfer_lock);
+
+        /* i2cTransfer returns num messages.translate it pls.. */
+        if (ret >= 0)
+                ret = 0;
+        return ret;
+}
+EXPORT_SYMBOL(twl4030_i2c_write);
+
+/**
+ * twl4030_i2c_read - Reads a n bit register in TWL4030
+ * @mod_no: module number
+ * @value: an array of num_bytes containing data to be read
+ * @reg: register address (just offset will do)
+ * @num_bytes: number of bytes to transfer
+ *
+ * Returns result of operation - num_bytes is success else failure.
+ */
+int twl4030_i2c_read(u8 mod_no, u8 *value, u8 reg, u8 num_bytes)
+{
+        int ret;
+        u8 val;
+        int sid;
+        struct twl4030_client *twl;
+        struct i2c_msg *msg;
+
+        if (unlikely(mod_no > TWL4030_MODULE_LAST)) {
+                pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
+                return -EPERM;
+        }
+        sid = twl4030_map[mod_no].sid;
+        twl = &twl4030_modules[sid];
+
+        if (unlikely(!inuse)) {
+                pr_err("%s: client %d is not initialized\n", DRIVER_NAME, sid);
+                return -EPERM;
+        }
+        mutex_lock(&twl->xfer_lock);
+        /* [MSG1] fill the register address data */
+        msg = &twl->xfer_msg[0];
+        msg->addr = twl->address;
+        msg->len = 1;
+        msg->flags = 0; /* Read the register value */
+        val = twl4030_map[mod_no].base + reg;
+        msg->buf = &val;
+        /* [MSG2] fill the data rx buffer */
+        msg = &twl->xfer_msg[1];
+        msg->addr = twl->address;
+        msg->flags = I2C_M_RD;  /* Read the register value */
+        msg->len = num_bytes;   /* only n bytes */
+        msg->buf = value;
+        ret = i2c_transfer(twl->client->adapter, twl->xfer_msg, 2);
+        mutex_unlock(&twl->xfer_lock);
+
+        /* i2cTransfer returns num messages.translate it pls.. */
+        if (ret >= 0)
+                ret = 0;
+        return ret;
+}
+EXPORT_SYMBOL(twl4030_i2c_read);
+
+/**
+ * twl4030_i2c_write_u8 - Writes a 8 bit register in TWL4030
+ * @mod_no: module number
+ * @value: the value to be written 8 bit
+ * @reg: register address (just offset will do)
+ *
+ * Returns result of operation - 0 is success
+ */
+int twl4030_i2c_write_u8(u8 mod_no, u8 value, u8 reg)
+{
+
+        /* 2 bytes offset 1 contains the data offset 0 is used by i2c_write */
+        u8 temp_buffer[2] = { 0 };
+        /* offset 1 contains the data */
+        temp_buffer[1] = value;
+        return twl4030_i2c_write(mod_no, temp_buffer, reg, 1);
+}
+EXPORT_SYMBOL(twl4030_i2c_write_u8);
+
+/**
+ * twl4030_i2c_read_u8 - Reads a 8 bit register from TWL4030
+ * @mod_no: module number
+ * @value: the value read 8 bit
+ * @reg: register address (just offset will do)
+ *
+ * Returns result of operation - 0 is success
+ */
+int twl4030_i2c_read_u8(u8 mod_no, u8 *value, u8 reg)
+{
+        return twl4030_i2c_read(mod_no, value, reg, 1);
+}
+EXPORT_SYMBOL(twl4030_i2c_read_u8);
+
+/*----------------------------------------------------------------------*/
+
+static unsigned twl4030_irq_base;
+
+static struct completion irq_event;
+
+/*
+ * This thread processes interrupts reported by the Primary Interrupt Handler.
+ */
+static int twl4030_irq_thread(void *data)
+{
+        long irq = (long)data;
+        irq_desc_t *desc = irq_desc + irq;
+        static unsigned i2c_errors;
+        const static unsigned max_i2c_errors = 100;
+
+        current->flags |= PF_NOFREEZE;
+
+        while (!kthread_should_stop()) {
+                int ret;
+                int module_irq;
+                u8 pih_isr;
+
+                /* Wait for IRQ, then read PIH irq status (also blocking) */
+                wait_for_completion_interruptible(&irq_event);
+
+                ret = twl4030_i2c_read_u8(TWL4030_MODULE_PIH, &pih_isr,
+                                          REG_PIH_ISR_P1);
+                if (ret) {
+                        pr_warning("%s: I2C error %d reading PIH ISR\n",
+                                        DRIVER_NAME, ret);
+                        if (++i2c_errors >= max_i2c_errors) {
+                                printk(KERN_ERR "Maximum I2C error count"
+                                                " exceeded.  Terminating %s.\n",
+                                                __func__);
+                                break;
+                        }
+                        complete(&irq_event);
+                        continue;
+                }
+
+                /* these handlers deal with the relevant SIH irq status */
+                local_irq_disable();
+                for (module_irq = twl4030_irq_base;
+                                pih_isr;
+                                pih_isr >>= 1, module_irq++) {
+                        if (pih_isr & 0x1) {
+                                irq_desc_t *d = irq_desc + module_irq;
+
+                                d->handle_irq(module_irq, d);
+                        }
+                }
+                local_irq_enable();
+
+                desc->chip->unmask(irq);
+        }
+
+        return 0;
+}
+
+/*
+ * do_twl4030_irq() is the desc->handle method for the twl4030 interrupt.
+ * This is a chained interrupt, so there is no desc->action method for it.
+ * Now we need to query the interrupt controller in the twl4030 to determine
+ * which module is generating the interrupt request.  However, we can't do i2c
+ * transactions in interrupt context, so we must defer that work to a kernel
+ * thread.  All we do here is acknowledge and mask the interrupt and wakeup
+ * the kernel thread.
+ */
+static void do_twl4030_irq(unsigned int irq, irq_desc_t *desc)
+{
+        const unsigned int cpu = smp_processor_id();
+
+        /*
+         * Earlier this was desc->triggered = 1;
+         */
+        desc->status |= IRQ_LEVEL;
+
+        /*
+         * Acknowledge, clear _AND_ disable the interrupt.
+         */
+        desc->chip->ack(irq);
+
+        if (!desc->depth) {
+                kstat_cpu(cpu).irqs[irq]++;
+
+                complete(&irq_event);
+        }
+}
+
+static struct task_struct * __init start_twl4030_irq_thread(long irq)
+{
+        struct task_struct *thread;
+
+        init_completion(&irq_event);
+        thread = kthread_run(twl4030_irq_thread, (void *)irq, "twl4030-irq");
+        if (!thread)
+                pr_err("%s: could not create twl4030 irq %ld thread!\n",
+                       DRIVER_NAME, irq);
+
+        return thread;
+}
+
+/*----------------------------------------------------------------------*/
+
+static int add_children(struct twl4030_platform_data *pdata)
+{
+        struct platform_device  *pdev = NULL;
+        struct twl4030_client   *twl = NULL;
+        int                     status = 0;
+
+        if (twl_has_bci() && pdata->bci) {
+                twl = &twl4030_modules[3];
+
+                pdev = platform_device_alloc("twl4030_bci", -1);
+                if (!pdev) {
+                        pr_debug("%s: can't alloc bci dev\n", DRIVER_NAME);
+                        status = -ENOMEM;
+                        goto err;
+                }
+
+                if (status == 0) {
+                        pdev->dev.parent = &twl->client->dev;
+                        status = platform_device_add_data(pdev, pdata->bci,
+                                        sizeof(*pdata->bci));
+                        if (status < 0) {
+                                dev_dbg(&twl->client->dev,
+                                        "can't add bci data, %d\n",
+                                        status);
+                                goto err;
+                        }
+                }
+
+                if (status == 0) {
+                        struct resource r = {
+                                .start = TWL4030_PWRIRQ_CHG_PRES,
+                                .flags = IORESOURCE_IRQ,
+                        };
+
+                        status = platform_device_add_resources(pdev, &r, 1);
+                }
+
+                if (status == 0)
+                        status = platform_device_add(pdev);
+
+                if (status < 0) {
+                        platform_device_put(pdev);
+                        dev_dbg(&twl->client->dev,
+                                        "can't create bci dev, %d\n",
+                                        status);
+                        goto err;
+                }
+        }
+
+        if (twl_has_gpio() && pdata->gpio) {
+                twl = &twl4030_modules[1];
+
+                pdev = platform_device_alloc("twl4030_gpio", -1);
+                if (!pdev) {
+                        pr_debug("%s: can't alloc gpio dev\n", DRIVER_NAME);
+                        status = -ENOMEM;
+                        goto err;
+                }
+
+                /* more driver model init */
+                if (status == 0) {
+                        pdev->dev.parent = &twl->client->dev;
+                        /* device_init_wakeup(&pdev->dev, 1); */
+
+                        status = platform_device_add_data(pdev, pdata->gpio,
+                                        sizeof(*pdata->gpio));
+                        if (status < 0) {
+                                dev_dbg(&twl->client->dev,
+                                        "can't add gpio data, %d\n",
+                                        status);
+                                goto err;
+                        }
+                }
+
+                /* GPIO module IRQ */
+                if (status == 0) {
+                        struct resource r = {
+                                .start = pdata->irq_base + 0,
+                                .flags = IORESOURCE_IRQ,
+                        };
+
+                        status = platform_device_add_resources(pdev, &r, 1);
+                }
+
+                if (status == 0)
+                        status = platform_device_add(pdev);
+
+                if (status < 0) {
+                        platform_device_put(pdev);
+                        dev_dbg(&twl->client->dev,
+                                        "can't create gpio dev, %d\n",
+                                        status);
+                        goto err;
+                }
+        }
+
+        if (twl_has_keypad() && pdata->keypad) {
+                pdev = platform_device_alloc("twl4030_keypad", -1);
+                if (pdev) {
+                        twl = &twl4030_modules[2];
+                        pdev->dev.parent = &twl->client->dev;
+                        device_init_wakeup(&pdev->dev, 1);
+                        status = platform_device_add_data(pdev, pdata->keypad,
+                                        sizeof(*pdata->keypad));
+                        if (status < 0) {
+                                dev_dbg(&twl->client->dev,
+                                        "can't add keypad data, %d\n",
+                                        status);
+                                platform_device_put(pdev);
+                                goto err;
+                        }
+                        status = platform_device_add(pdev);
+                        if (status < 0) {
+                                platform_device_put(pdev);
+                                dev_dbg(&twl->client->dev,
+                                                "can't create keypad dev, %d\n",
+                                                status);
+                                goto err;
+                        }
+                } else {
+                        pr_debug("%s: can't alloc keypad dev\n", DRIVER_NAME);
+                        status = -ENOMEM;
+                        goto err;
+                }
+        }
+
+        if (twl_has_madc() && pdata->madc) {
+                pdev = platform_device_alloc("twl4030_madc", -1);
+                if (pdev) {
+                        twl = &twl4030_modules[2];
+                        pdev->dev.parent = &twl->client->dev;
+                        device_init_wakeup(&pdev->dev, 1);
+                        status = platform_device_add_data(pdev, pdata->madc,
+                                        sizeof(*pdata->madc));
+                        if (status < 0) {
+                                platform_device_put(pdev);
+                                dev_dbg(&twl->client->dev,
+                                        "can't add madc data, %d\n",
+                                        status);
+                                goto err;
+                        }
+                        status = platform_device_add(pdev);
+                        if (status < 0) {
+                                platform_device_put(pdev);
+                                dev_dbg(&twl->client->dev,
+                                                "can't create madc dev, %d\n",
+                                                status);
+                                goto err;
+                        }
+                } else {
+                        pr_debug("%s: can't alloc madc dev\n", DRIVER_NAME);
+                        status = -ENOMEM;
+                        goto err;
+                }
+        }
+
+        if (twl_has_rtc()) {
+                twl = &twl4030_modules[3];
+
+                pdev = platform_device_alloc("twl4030_rtc", -1);
+                if (!pdev) {
+                        pr_debug("%s: can't alloc rtc dev\n", DRIVER_NAME);
+                        status = -ENOMEM;
+                } else {
+                        pdev->dev.parent = &twl->client->dev;
+                        device_init_wakeup(&pdev->dev, 1);
+                }
+
+                /*
+                 * REVISIT platform_data here currently might use of
+                 * "msecure" line ... but for now we just expect board
+                 * setup to tell the chip "we are secure" at all times.
+                 * Eventually, Linux might become more aware of such
+                 * HW security concerns, and "least privilege".
+                 */
+
+                /* RTC module IRQ */
+                if (status == 0) {
+                        struct resource r = {
+                                /* REVISIT don't hard-wire this stuff */
+                                .start = TWL4030_PWRIRQ_RTC,
+                                .flags = IORESOURCE_IRQ,
+                        };
+
+                        status = platform_device_add_resources(pdev, &r, 1);
+                }
+
+                if (status == 0)
+                        status = platform_device_add(pdev);
+
+                if (status < 0) {
+                        platform_device_put(pdev);
+                        dev_dbg(&twl->client->dev,
+                                        "can't create rtc dev, %d\n",
+                                        status);
+                        goto err;
+                }
+        }
+
+        if (twl_has_usb() && pdata->usb) {
+                twl = &twl4030_modules[0];
+
+                pdev = platform_device_alloc("twl4030_usb", -1);
+                if (!pdev) {
+                        pr_debug("%s: can't alloc usb dev\n", DRIVER_NAME);
+                        status = -ENOMEM;
+                        goto err;
+                }
+
+                if (status == 0) {
+                        pdev->dev.parent = &twl->client->dev;
+                        device_init_wakeup(&pdev->dev, 1);
+                        status = platform_device_add_data(pdev, pdata->usb,
+                                        sizeof(*pdata->usb));
+                        if (status < 0) {
+                                platform_device_put(pdev);
+                                dev_dbg(&twl->client->dev,
+                                        "can't add usb data, %d\n",
+                                        status);
+                                goto err;
+                        }
+                }
+
+                if (status == 0) {
+                        struct resource r = {
+                                .start = TWL4030_PWRIRQ_USB_PRES,
+                                .flags = IORESOURCE_IRQ,
+                        };
+
+                        status = platform_device_add_resources(pdev, &r, 1);
+                }
+
+                if (status == 0)
+                        status = platform_device_add(pdev);
+
+                if (status < 0) {
+                        platform_device_put(pdev);
+                        dev_dbg(&twl->client->dev,
+                                        "can't create usb dev, %d\n",
+                                        status);
+                }
+        }
+
+err:
+        if (status)
+                pr_err("failed to add twl4030's children (status %d)\n", status);
+        return status;
+}
+
+/*----------------------------------------------------------------------*/
+
+/*
+ * These three functions initialize the on-chip clock framework,
+ * letting it generate the right frequencies for USB, MADC, and
+ * other purposes.
+ */
+static inline int __init protect_pm_master(void)
+{
+        int e = 0;
+
+        e = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_LOCK,
+                        R_PROTECT_KEY);
+        return e;
+}
+
+static inline int __init unprotect_pm_master(void)
+{
+        int e = 0;
+
+        e |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_UNLOCK1,
+                        R_PROTECT_KEY);
+        e |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_UNLOCK2,
+                        R_PROTECT_KEY);
+        return e;
+}
+
+static void __init clocks_init(void)
+{
+        int e = 0;
+        struct clk *osc;
+        u32 rate;
+        u8 ctrl = HFCLK_FREQ_26_MHZ;
+
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        if (cpu_is_omap2430())
+                osc = clk_get(NULL, "osc_ck");
+        else
+                osc = clk_get(NULL, "osc_sys_ck");
+#else
+        /* REVISIT for non-OMAP systems, pass the clock rate from
+         * board init code, using platform_data.
+         */
+        osc = ERR_PTR(-EIO);
+#endif
+        if (IS_ERR(osc)) {
+                printk(KERN_WARNING "Skipping twl4030 internal clock init and "
+                                "using bootloader value (unknown osc rate)\n");
+                return;
+        }
+
+        rate = clk_get_rate(osc);
+        clk_put(osc);
+
+        switch (rate) {
+        case 19200000:
+                ctrl = HFCLK_FREQ_19p2_MHZ;
+                break;
+        case 26000000:
+                ctrl = HFCLK_FREQ_26_MHZ;
+                break;
+        case 38400000:
+                ctrl = HFCLK_FREQ_38p4_MHZ;
+                break;
+        }
+
+        ctrl |= HIGH_PERF_SQ;
+        e |= unprotect_pm_master();
+        /* effect->MADC+USB ck en */
+        e |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, ctrl, R_CFG_BOOT);
+        e |= protect_pm_master();
+
+        if (e < 0)
+                pr_err("%s: clock init err [%d]\n", DRIVER_NAME, e);
+}
+
+/*----------------------------------------------------------------------*/
+
+/**
+ * twl4030_i2c_clear_isr - clear TWL4030 SIH ISR regs via read + write
+ * @mod_no: TWL4030 module number
+ * @reg: register index to clear
+ * @cor: value of the <module>_SIH_CTRL.COR bit (1 or 0)
+ *
+ * Either reads (cor == 1) or writes (cor == 0) to a TWL4030 interrupt
+ * status register to ensure that any prior interrupts are cleared.
+ * Returns the status from the I2C read operation.
+ */
+static int __init twl4030_i2c_clear_isr(u8 mod_no, u8 reg, u8 cor)
+{
+        u8 tmp;
+
+        return (cor) ? twl4030_i2c_read_u8(mod_no, &tmp, reg) :
+                twl4030_i2c_write_u8(mod_no, 0xff, reg);
+}
+
+/**
+ * twl4030_read_cor_bit - are TWL module ISRs cleared by reads or writes?
+ * @mod_no: TWL4030 module number
+ * @reg: register index to clear
+ *
+ * Returns 1 if the TWL4030 SIH interrupt status registers (ISRs) for
+ * the specified TWL module are cleared by reads, or 0 if cleared by
+ * writes.
+ */
+static int twl4030_read_cor_bit(u8 mod_no, u8 reg)
+{
+        u8 tmp = 0;
+
+        WARN_ON(twl4030_i2c_read_u8(mod_no, &tmp, reg) < 0);
+
+        tmp &= TWL4030_SIH_CTRL_COR_MASK;
+        tmp >>= __ffs(TWL4030_SIH_CTRL_COR_MASK);
+
+        return tmp;
+}
+
+/**
+ * twl4030_mask_clear_intrs - mask and clear all TWL4030 interrupts
+ * @t: pointer to twl4030_mod_iregs array
+ * @t_sz: ARRAY_SIZE(t) (starting at 1)
+ *
+ * Mask all TWL4030 interrupt mask registers (IMRs) and clear all
+ * interrupt status registers (ISRs).  No return value, but will WARN if
+ * any I2C operations fail.
+ */
+static void __init twl4030_mask_clear_intrs(const struct twl4030_mod_iregs *t,
+                                            const u8 t_sz)
+{
+        int i, j;
+
+        /*
+         * N.B. - further efficiency is possible here.  Eight I2C
+         * operations on BCI and GPIO modules are avoidable if I2C
+         * burst read/write transactions were implemented.  Would
+         * probably save about 1ms of boot time and a small amount of
+         * power.
+         */
+        for (i = 0; i < t_sz; i++) {
+                const struct twl4030_mod_iregs tmr = t[i];
+                int cor;
+
+                /* Are ISRs cleared by reads or writes? */
+                cor = twl4030_read_cor_bit(tmr.mod_no, tmr.sih_ctrl);
+
+                for (j = 0; j < tmr.reg_cnt; j++) {
+
+                        /* Mask interrupts at the TWL4030 */
+                        WARN_ON(twl4030_i2c_write_u8(tmr.mod_no, 0xff,
+                                                     tmr.imrs[j]) < 0);
+
+                        /* Clear TWL4030 ISRs */
+                        WARN_ON(twl4030_i2c_clear_isr(tmr.mod_no,
+                                                      tmr.isrs[j], cor) < 0);
+                }
+        }
+}
+
+
+static void twl_init_irq(int irq_num, unsigned irq_base, unsigned irq_end)
+{
+        int     i;
+
+        /*
+         * Mask and clear all TWL4030 interrupts since initially we do
+         * not have any TWL4030 module interrupt handlers present
+         */
+        twl4030_mask_clear_intrs(twl4030_mod_regs,
+                                 ARRAY_SIZE(twl4030_mod_regs));
+
+        twl4030_irq_base = irq_base;
+
+        /* install an irq handler for each of the PIH modules */
+        for (i = irq_base; i < irq_end; i++) {
+                set_irq_chip_and_handler(i, &twl4030_irq_chip,
+                                handle_simple_irq);
+                activate_irq(i);
+        }
+
+        /* install an irq handler to demultiplex the TWL4030 interrupt */
+        set_irq_data(irq_num, start_twl4030_irq_thread(irq_num));
+        set_irq_chained_handler(irq_num, do_twl4030_irq);
+}
+
+/*----------------------------------------------------------------------*/
+
+static int twl4030_remove(struct i2c_client *client)
+{
+        unsigned i;
+
+        /* FIXME undo twl_init_irq() */
+        if (twl4030_irq_base) {
+                dev_err(&client->dev, "can't yet clean up IRQs?\n");
+                return -ENOSYS;
+        }
+
+        for (i = 0; i < TWL4030_NUM_SLAVES; i++) {
+                struct twl4030_client   *twl = &twl4030_modules[i];
+
+                if (twl->client && twl->client != client)
+                        i2c_unregister_device(twl->client);
+                twl4030_modules[i].client = NULL;
+        }
+        inuse = false;
+        return 0;
+}
+
+/* NOTE:  this driver only handles a single twl4030/tps659x0 chip */
+static int
+twl4030_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+        int                             status;
+        unsigned                        i;
+        struct twl4030_platform_data    *pdata = client->dev.platform_data;
+
+        if (!pdata) {
+                dev_dbg(&client->dev, "no platform data?\n");
+                return -EINVAL;
+        }
+
+        if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {
+                dev_dbg(&client->dev, "can't talk I2C?\n");
+                return -EIO;
+        }
+
+        if (inuse || twl4030_irq_base) {
+                dev_dbg(&client->dev, "driver is already in use\n");
+                return -EBUSY;
+        }
+
+        for (i = 0; i < TWL4030_NUM_SLAVES; i++) {
+                struct twl4030_client   *twl = &twl4030_modules[i];
+
+                twl->address = client->addr + i;
+                if (i == 0)
+                        twl->client = client;
+                else {
+                        twl->client = i2c_new_dummy(client->adapter,
+                                        twl->address);
+                        if (!twl->client) {
+                                dev_err(&twl->client->dev,
+                                        "can't attach client %d\n", i);
+                                status = -ENOMEM;
+                                goto fail;
+                        }
+                        strlcpy(twl->client->name, id->name,
+                                        sizeof(twl->client->name));
+                }
+                mutex_init(&twl->xfer_lock);
+        }
+        inuse = true;
+
+        /* setup clock framework */
+        clocks_init();
+
+        /* Maybe init the T2 Interrupt subsystem */
+        if (client->irq
+                        && pdata->irq_base
+                        && pdata->irq_end > pdata->irq_base) {
+                twl_init_irq(client->irq, pdata->irq_base, pdata->irq_end);
+                dev_info(&client->dev, "IRQ %d chains IRQs %d..%d\n",
+                                client->irq, pdata->irq_base, pdata->irq_end - 1);
+        }
+
+        status = add_children(pdata);
+fail:
+        if (status < 0)
+                twl4030_remove(client);
+        return status;
+}
+
+static const struct i2c_device_id twl4030_ids[] = {
+        { "twl4030", 0 },       /* "Triton 2" */
+        { "tps65950", 0 },      /* catalog version of twl4030 */
+        { "tps65930", 0 },      /* fewer LDOs and DACs; no charger */
+        { "tps65920", 0 },      /* fewer LDOs; no codec or charger */
+        { "twl5030", 0 },       /* T2 updated */
+        { /* end of list */ },
+};
+MODULE_DEVICE_TABLE(i2c, twl4030_ids);
+
+/* One Client Driver , 4 Clients */
+static struct i2c_driver twl4030_driver = {
+        .driver.name    = DRIVER_NAME,
+        .id_table       = twl4030_ids,
+        .probe          = twl4030_probe,
+        .remove         = twl4030_remove,
+};
+
+static int __init twl4030_init(void)
+{
+        return i2c_add_driver(&twl4030_driver);
+}
+subsys_initcall(twl4030_init);
+
+static void __exit twl4030_exit(void)
+{
+        i2c_del_driver(&twl4030_driver);
+}
+module_exit(twl4030_exit);
+
+MODULE_AUTHOR("Texas Instruments, Inc.");
+MODULE_DESCRIPTION("I2C Core interface for TWL4030");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/wm8350-core.c b/drivers/mfd/wm8350-core.c
index 25a7a5d08bce..bf87f675e7fa 100644
--- a/drivers/mfd/wm8350-core.c
+++ b/drivers/mfd/wm8350-core.c
@@ -1217,7 +1217,7 @@ int wm8350_device_init(struct wm8350 *wm8350, int irq,
 
         mutex_init(&wm8350->irq_mutex);
         INIT_WORK(&wm8350->irq_work, wm8350_irq_worker);
-        if (irq != NO_IRQ) {
+        if (irq) {
                 ret = request_irq(irq, wm8350_irq, 0,
                                   "wm8350", wm8350);
                 if (ret != 0) {
diff --git a/drivers/misc/hp-wmi.c b/drivers/misc/hp-wmi.c
index 5dabfb69ee53..4b7c24c519c3 100644
--- a/drivers/misc/hp-wmi.c
+++ b/drivers/misc/hp-wmi.c
@@ -82,6 +82,7 @@ static struct key_entry hp_wmi_keymap[] = {
         {KE_KEY, 0x03, KEY_BRIGHTNESSDOWN},
         {KE_KEY, 0x20e6, KEY_PROG1},
         {KE_KEY, 0x2142, KEY_MEDIA},
+        {KE_KEY, 0x213b, KEY_INFO},
         {KE_KEY, 0x231b, KEY_HELP},
         {KE_END, 0}
 };
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 406989e992ba..7a72e75d5c67 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -132,6 +132,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
 
         blk_queue_prep_rq(mq->queue, mmc_prep_request);
         blk_queue_ordered(mq->queue, QUEUE_ORDERED_DRAIN, NULL);
+        queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mq->queue);
 
 #ifdef CONFIG_MMC_BLOCK_BOUNCE
         if (host->max_hw_segs == 1) {
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index ae16d845d746..3b2085b57769 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -3,6 +3,9 @@
  *
  *  Copyright (C) 2004-2006 maintech GmbH, Thomas Kleffel <tk@maintech.de>
  *
+ * Current driver maintained by Ben Dooks and Simtec Electronics
+ *  Copyright (C) 2008 Simtec Electronics <ben-linux@fluff.org>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
@@ -13,6 +16,7 @@
 #include <linux/clk.h>
 #include <linux/mmc/host.h>
 #include <linux/platform_device.h>
+#include <linux/cpufreq.h>
 #include <linux/irq.h>
 #include <linux/io.h>
 
@@ -39,9 +43,9 @@ enum dbg_channels {
         dbg_conf  = (1 << 8),
 };
 
-static const int dbgmap_err   = dbg_err | dbg_fail;
+static const int dbgmap_err   = dbg_fail;
 static const int dbgmap_info  = dbg_info | dbg_conf;
-static const int dbgmap_debug = dbg_debug;
+static const int dbgmap_debug = dbg_err | dbg_debug;
 
 #define dbg(host, channels, args...)              \
         do {                                      \
@@ -189,7 +193,7 @@ static inline void clear_imask(struct s3cmci_host *host)
 }
 
 static inline int get_data_buffer(struct s3cmci_host *host,
-                                  u32 *words, u32 **pointer)
+                                  u32 *bytes, u32 **pointer)
 {
         struct scatterlist *sg;
 
@@ -206,7 +210,7 @@ static inline int get_data_buffer(struct s3cmci_host *host,
         }
         sg = &host->mrq->data->sg[host->pio_sgptr];
 
-        *words = sg->length >> 2;
+        *bytes = sg->length;
         *pointer = sg_virt(sg);
 
         host->pio_sgptr++;
@@ -222,7 +226,7 @@ static inline u32 fifo_count(struct s3cmci_host *host)
         u32 fifostat = readl(host->base + S3C2410_SDIFSTA);
 
         fifostat &= S3C2410_SDIFSTA_COUNTMASK;
-        return fifostat >> 2;
+        return fifostat;
 }
 
 static inline u32 fifo_free(struct s3cmci_host *host)
@@ -230,13 +234,15 @@ static inline u32 fifo_free(struct s3cmci_host *host)
         u32 fifostat = readl(host->base + S3C2410_SDIFSTA);
 
         fifostat &= S3C2410_SDIFSTA_COUNTMASK;
-        return (63 - fifostat) >> 2;
+        return 63 - fifostat;
 }
 
 static void do_pio_read(struct s3cmci_host *host)
 {
         int res;
         u32 fifo;
+        u32 *ptr;
+        u32 fifo_words;
         void __iomem *from_ptr;
 
         /* write real prescaler to host, it might be set slow to fix */
@@ -245,8 +251,8 @@ static void do_pio_read(struct s3cmci_host *host)
         from_ptr = host->base + host->sdidata;
 
         while ((fifo = fifo_count(host))) {
-                if (!host->pio_words) {
-                        res = get_data_buffer(host, &host->pio_words,
+                if (!host->pio_bytes) {
+                        res = get_data_buffer(host, &host->pio_bytes,
                                               &host->pio_ptr);
                         if (res) {
                                 host->pio_active = XFER_NONE;
@@ -259,26 +265,47 @@ static void do_pio_read(struct s3cmci_host *host)
 
                         dbg(host, dbg_pio,
                             "pio_read(): new target: [%i]@[%p]\n",
-                            host->pio_words, host->pio_ptr);
+                            host->pio_bytes, host->pio_ptr);
                 }
 
                 dbg(host, dbg_pio,
                     "pio_read(): fifo:[%02i] buffer:[%03i] dcnt:[%08X]\n",
-                    fifo, host->pio_words,
+                    fifo, host->pio_bytes,
                     readl(host->base + S3C2410_SDIDCNT));
 
-                if (fifo > host->pio_words)
-                        fifo = host->pio_words;
+                /* If we have reached the end of the block, we can
+                 * read a word and get 1 to 3 bytes.  If we in the
+                 * middle of the block, we have to read full words,
+                 * otherwise we will write garbage, so round down to
+                 * an even multiple of 4. */
+                if (fifo >= host->pio_bytes)
+                        fifo = host->pio_bytes;
+                else
+                        fifo -= fifo & 3;
 
-                host->pio_words -= fifo;
+                host->pio_bytes -= fifo;
                 host->pio_count += fifo;
 
-                while (fifo--)
-                        *(host->pio_ptr++) = readl(from_ptr);
+                fifo_words = fifo >> 2;
+                ptr = host->pio_ptr;
+                while (fifo_words--)
+                        *ptr++ = readl(from_ptr);
+                host->pio_ptr = ptr;
+
+                if (fifo & 3) {
+                        u32 n = fifo & 3;
+                        u32 data = readl(from_ptr);
+                        u8 *p = (u8 *)host->pio_ptr;
+
+                        while (n--) {
+                                *p++ = data;
+                                data >>= 8;
+                        }
+                }
         }
 
-        if (!host->pio_words) {
-                res = get_data_buffer(host, &host->pio_words, &host->pio_ptr);
+        if (!host->pio_bytes) {
+                res = get_data_buffer(host, &host->pio_bytes, &host->pio_ptr);
                 if (res) {
                         dbg(host, dbg_pio,
                             "pio_read(): complete (no more buffers).\n");
@@ -298,12 +325,13 @@ static void do_pio_write(struct s3cmci_host *host)
         void __iomem *to_ptr;
         int res;
         u32 fifo;
+        u32 *ptr;
 
         to_ptr = host->base + host->sdidata;
 
         while ((fifo = fifo_free(host))) {
-                if (!host->pio_words) {
-                        res = get_data_buffer(host, &host->pio_words,
+                if (!host->pio_bytes) {
+                        res = get_data_buffer(host, &host->pio_bytes,
                                                         &host->pio_ptr);
                         if (res) {
                                 dbg(host, dbg_pio,
@@ -315,18 +343,27 @@ static void do_pio_write(struct s3cmci_host *host)
 
                         dbg(host, dbg_pio,
                             "pio_write(): new source: [%i]@[%p]\n",
-                            host->pio_words, host->pio_ptr);
+                            host->pio_bytes, host->pio_ptr);
 
                 }
 
-                if (fifo > host->pio_words)
-                        fifo = host->pio_words;
+                /* If we have reached the end of the block, we have to
+                 * write exactly the remaining number of bytes.  If we
+                 * in the middle of the block, we have to write full
+                 * words, so round down to an even multiple of 4. */
+                if (fifo >= host->pio_bytes)
+                        fifo = host->pio_bytes;
+                else
+                        fifo -= fifo & 3;
 
-                host->pio_words -= fifo;
+                host->pio_bytes -= fifo;
                 host->pio_count += fifo;
 
+                fifo = (fifo + 3) >> 2;
+                ptr = host->pio_ptr;
                 while (fifo--)
-                        writel(*(host->pio_ptr++), to_ptr);
+                        writel(*ptr++, to_ptr);
+                host->pio_ptr = ptr;
         }
 
         enable_imask(host, S3C2410_SDIIMSK_TXFIFOHALF);
@@ -349,9 +386,9 @@ static void pio_tasklet(unsigned long data)
                 clear_imask(host);
                 if (host->pio_active != XFER_NONE) {
                         dbg(host, dbg_err, "unfinished %s "
-                            "- pio_count:[%u] pio_words:[%u]\n",
+                            "- pio_count:[%u] pio_bytes:[%u]\n",
                             (host->pio_active == XFER_READ) ? "read" : "write",
-                            host->pio_count, host->pio_words);
+                            host->pio_count, host->pio_bytes);
 
                         if (host->mrq->data)
                                 host->mrq->data->error = -EINVAL;
@@ -812,11 +849,10 @@ static int s3cmci_setup_data(struct s3cmci_host *host, struct mmc_data *data)
                 /* We cannot deal with unaligned blocks with more than
                  * one block being transfered. */
 
-                if (data->blocks > 1)
+                if (data->blocks > 1) {
+                        pr_warning("%s: can't do non-word sized block transfers (blksz %d)\n", __func__, data->blksz);
                         return -EINVAL;
-
-                /* No support yet for non-word block transfers. */
-                return -EINVAL;
+                }
         }
 
         while (readl(host->base + S3C2410_SDIDSTA) &
@@ -896,7 +932,7 @@ static int s3cmci_prepare_pio(struct s3cmci_host *host, struct mmc_data *data)
         BUG_ON((data->flags & BOTH_DIR) == BOTH_DIR);
 
         host->pio_sgptr = 0;
-        host->pio_words = 0;
+        host->pio_bytes = 0;
         host->pio_count = 0;
         host->pio_active = rw ? XFER_WRITE : XFER_READ;
 
@@ -1033,10 +1069,33 @@ static void s3cmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
                 s3cmci_send_request(mmc);
 }
 
+static void s3cmci_set_clk(struct s3cmci_host *host, struct mmc_ios *ios)
+{
+        u32 mci_psc;
+
+        /* Set clock */
+        for (mci_psc = 0; mci_psc < 255; mci_psc++) {
+                host->real_rate = host->clk_rate / (host->clk_div*(mci_psc+1));
+
+                if (host->real_rate <= ios->clock)
+                        break;
+        }
+
+        if (mci_psc > 255)
+                mci_psc = 255;
+
+        host->prescaler = mci_psc;
+        writel(host->prescaler, host->base + S3C2410_SDIPRE);
+
+        /* If requested clock is 0, real_rate will be 0, too */
+        if (ios->clock == 0)
+                host->real_rate = 0;
+}
+
 static void s3cmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
         struct s3cmci_host *host = mmc_priv(mmc);
-        u32 mci_psc, mci_con;
+        u32 mci_con;
 
         /* Set the power state */
 
@@ -1074,23 +1133,7 @@ static void s3cmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 break;
         }
 
-        /* Set clock */
-        for (mci_psc = 0; mci_psc < 255; mci_psc++) {
-                host->real_rate = host->clk_rate / (host->clk_div*(mci_psc+1));
-
-                if (host->real_rate <= ios->clock)
-                        break;
-        }
-
-        if (mci_psc > 255)
-                mci_psc = 255;
-
-        host->prescaler = mci_psc;
-        writel(host->prescaler, host->base + S3C2410_SDIPRE);
-
-        /* If requested clock is 0, real_rate will be 0, too */
-        if (ios->clock == 0)
-                host->real_rate = 0;
+        s3cmci_set_clk(host, ios);
 
         /* Set CLOCK_ENABLE */
         if (ios->clock)
@@ -1148,6 +1191,61 @@ static struct s3c24xx_mci_pdata s3cmci_def_pdata = {
          * checks. Any zero fields to ensure reaonable defaults are picked. */
 };
 
+#ifdef CONFIG_CPU_FREQ
+
+static int s3cmci_cpufreq_transition(struct notifier_block *nb,
+                                     unsigned long val, void *data)
+{
+        struct s3cmci_host *host;
+        struct mmc_host *mmc;
+        unsigned long newclk;
+        unsigned long flags;
+
+        host = container_of(nb, struct s3cmci_host, freq_transition);
+        newclk = clk_get_rate(host->clk);
+        mmc = host->mmc;
+
+        if ((val == CPUFREQ_PRECHANGE && newclk > host->clk_rate) ||
+            (val == CPUFREQ_POSTCHANGE && newclk < host->clk_rate)) {
+                spin_lock_irqsave(&mmc->lock, flags);
+
+                host->clk_rate = newclk;
+
+                if (mmc->ios.power_mode != MMC_POWER_OFF &&
+                    mmc->ios.clock != 0)
+                        s3cmci_set_clk(host, &mmc->ios);
+
+                spin_unlock_irqrestore(&mmc->lock, flags);
+        }
+
+        return 0;
+}
+
+static inline int s3cmci_cpufreq_register(struct s3cmci_host *host)
+{
+        host->freq_transition.notifier_call = s3cmci_cpufreq_transition;
+
+        return cpufreq_register_notifier(&host->freq_transition,
+                                         CPUFREQ_TRANSITION_NOTIFIER);
+}
+
+static inline void s3cmci_cpufreq_deregister(struct s3cmci_host *host)
+{
+        cpufreq_unregister_notifier(&host->freq_transition,
+                                    CPUFREQ_TRANSITION_NOTIFIER);
+}
+
+#else
+static inline int s3cmci_cpufreq_register(struct s3cmci_host *host)
+{
+        return 0;
+}
+
+static inline void s3cmci_cpufreq_deregister(struct s3cmci_host *host)
+{
+}
+#endif
+
 static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440)
 {
         struct s3cmci_host *host;
@@ -1298,10 +1396,16 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440)
             (host->is2440?"2440":""),
             host->base, host->irq, host->irq_cd, host->dma);
 
+        ret = s3cmci_cpufreq_register(host);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to register cpufreq\n");
+                goto free_dmabuf;
+        }
+
         ret = mmc_add_host(mmc);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add mmc host.\n");
-                goto free_dmabuf;
+                goto free_cpufreq;
         }
 
         platform_set_drvdata(pdev, mmc);
@@ -1309,6 +1413,9 @@ static int __devinit s3cmci_probe(struct platform_device *pdev, int is2440)
 
         return 0;
 
+ free_cpufreq:
+        s3cmci_cpufreq_deregister(host);
+
  free_dmabuf:
         clk_disable(host->clk);
 
@@ -1342,6 +1449,7 @@ static void s3cmci_shutdown(struct platform_device *pdev)
         if (host->irq_cd >= 0)
                 free_irq(host->irq_cd, host);
 
+        s3cmci_cpufreq_deregister(host);
         mmc_remove_host(mmc);
         clk_disable(host->clk);
 }
@@ -1455,7 +1563,7 @@ module_exit(s3cmci_exit);
 
 MODULE_DESCRIPTION("Samsung S3C MMC/SD Card Interface driver");
 MODULE_LICENSE("GPL v2");
-MODULE_AUTHOR("Thomas Kleffel <tk@maintech.de>");
+MODULE_AUTHOR("Thomas Kleffel <tk@maintech.de>, Ben Dooks <ben-linux@fluff.org>");
 MODULE_ALIAS("platform:s3c2410-sdi");
 MODULE_ALIAS("platform:s3c2412-sdi");
 MODULE_ALIAS("platform:s3c2440-sdi");
diff --git a/drivers/mmc/host/s3cmci.h b/drivers/mmc/host/s3cmci.h
index 37d9c60010c9..ca1ba3d58cfd 100644
--- a/drivers/mmc/host/s3cmci.h
+++ b/drivers/mmc/host/s3cmci.h
@@ -51,7 +51,7 @@ struct s3cmci_host {
         int                     dma_complete;
 
         u32                     pio_sgptr;
-        u32                     pio_words;
+        u32                     pio_bytes;
         u32                     pio_count;
         u32                     *pio_ptr;
 #define XFER_NONE 0
@@ -67,4 +67,8 @@ struct s3cmci_host {
 
         unsigned int            ccnt, dcnt;
         struct tasklet_struct   pio_tasklet;
+
+#ifdef CONFIG_CPU_FREQ
+        struct notifier_block   freq_transition;
+#endif
 };
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index 14f11f8b9e5f..a90d50c2c3e5 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -172,6 +172,11 @@ config MTD_CHAR
           memory chips, and also use ioctl() to obtain information about
           the device, or to erase parts of it.
 
+config HAVE_MTD_OTP
+        bool
+        help
+          Enable access to OTP regions using MTD_CHAR.
+
 config MTD_BLKDEVS
         tristate "Common interface to block layer for MTD 'translation layers'"
         depends on BLOCK
diff --git a/drivers/mtd/chips/Kconfig b/drivers/mtd/chips/Kconfig
index 479d32b57a1e..9408099eec48 100644
--- a/drivers/mtd/chips/Kconfig
+++ b/drivers/mtd/chips/Kconfig
@@ -6,6 +6,7 @@ menu "RAM/ROM/Flash chip drivers"
 config MTD_CFI
         tristate "Detect flash chips by Common Flash Interface (CFI) probe"
         select MTD_GEN_PROBE
+        select MTD_CFI_UTIL
         help
           The Common Flash Interface specification was developed by Intel,
           AMD and other flash manufactures that provides a universal method
@@ -154,6 +155,7 @@ config MTD_CFI_I8
 config MTD_OTP
         bool "Protection Registers aka one-time programmable (OTP) bits"
         depends on MTD_CFI_ADV_OPTIONS
+        select HAVE_MTD_OTP
         default n
         help
           This enables support for reading, writing and locking so called
@@ -187,7 +189,7 @@ config MTD_CFI_INTELEXT
           StrataFlash and other parts.
 
 config MTD_CFI_AMDSTD
-        tristate "Support for AMD/Fujitsu flash chips"
+        tristate "Support for AMD/Fujitsu/Spansion flash chips"
         depends on MTD_GEN_PROBE
         select MTD_CFI_UTIL
         help
diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c
index 5f1b472137a0..c93a8be5d5f1 100644
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
@@ -478,6 +478,28 @@ struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
                 else
                         cfi->chips[i].erase_time = 2000000;
 
+                if (cfi->cfiq->WordWriteTimeoutTyp &&
+                    cfi->cfiq->WordWriteTimeoutMax)
+                        cfi->chips[i].word_write_time_max =
+                                1<<(cfi->cfiq->WordWriteTimeoutTyp +
+                                    cfi->cfiq->WordWriteTimeoutMax);
+                else
+                        cfi->chips[i].word_write_time_max = 50000 * 8;
+
+                if (cfi->cfiq->BufWriteTimeoutTyp &&
+                    cfi->cfiq->BufWriteTimeoutMax)
+                        cfi->chips[i].buffer_write_time_max =
+                                1<<(cfi->cfiq->BufWriteTimeoutTyp +
+                                    cfi->cfiq->BufWriteTimeoutMax);
+
+                if (cfi->cfiq->BlockEraseTimeoutTyp &&
+                    cfi->cfiq->BlockEraseTimeoutMax)
+                        cfi->chips[i].erase_time_max =
+                                1000<<(cfi->cfiq->BlockEraseTimeoutTyp +
+                                       cfi->cfiq->BlockEraseTimeoutMax);
+                else
+                        cfi->chips[i].erase_time_max = 2000000 * 8;
+
                 cfi->chips[i].ref_point_counter = 0;
                 init_waitqueue_head(&(cfi->chips[i].wq));
         }
@@ -703,6 +725,10 @@ static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long
         struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
         unsigned long timeo = jiffies + HZ;
 
+        /* Prevent setting state FL_SYNCING for chip in suspended state. */
+        if (mode == FL_SYNCING && chip->oldstate != FL_READY)
+                goto sleep;
+
         switch (chip->state) {
 
         case FL_STATUS:
@@ -808,8 +834,9 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
         DECLARE_WAITQUEUE(wait, current);
 
  retry:
-        if (chip->priv && (mode == FL_WRITING || mode == FL_ERASING
-                           || mode == FL_OTP_WRITE || mode == FL_SHUTDOWN)) {
+        if (chip->priv &&
+            (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE
+            || mode == FL_SHUTDOWN) && chip->state != FL_SYNCING) {
                 /*
                  * OK. We have possibility for contention on the write/erase
                  * operations which are global to the real chip and not per
@@ -859,6 +886,14 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                                 return ret;
                         }
                         spin_lock(&shared->lock);
+
+                        /* We should not own chip if it is already
+                         * in FL_SYNCING state. Put contender and retry. */
+                        if (chip->state == FL_SYNCING) {
+                                put_chip(map, contender, contender->start);
+                                spin_unlock(contender->mutex);
+                                goto retry;
+                        }
                         spin_unlock(contender->mutex);
                 }
 
@@ -1012,7 +1047,7 @@ static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
 
 static int __xipram xip_wait_for_operation(
                 struct map_info *map, struct flchip *chip,
-                unsigned long adr, unsigned int chip_op_time )
+                unsigned long adr, unsigned int chip_op_time_max)
 {
         struct cfi_private *cfi = map->fldrv_priv;
         struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
@@ -1021,7 +1056,7 @@ static int __xipram xip_wait_for_operation(
         flstate_t oldstate, newstate;
 
         start = xip_currtime();
-        usec = chip_op_time * 8;
+        usec = chip_op_time_max;
         if (usec == 0)
                 usec = 500000;
         done = 0;
@@ -1131,8 +1166,8 @@ static int __xipram xip_wait_for_operation(
 #define XIP_INVAL_CACHED_RANGE(map, from, size)  \
         INVALIDATE_CACHED_RANGE(map, from, size)
 
-#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec) \
-        xip_wait_for_operation(map, chip, cmd_adr, usec)
+#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec, usec_max) \
+        xip_wait_for_operation(map, chip, cmd_adr, usec_max)
 
 #else
 
@@ -1144,7 +1179,7 @@ static int __xipram xip_wait_for_operation(
 static int inval_cache_and_wait_for_operation(
                 struct map_info *map, struct flchip *chip,
                 unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
-                unsigned int chip_op_time)
+                unsigned int chip_op_time, unsigned int chip_op_time_max)
 {
         struct cfi_private *cfi = map->fldrv_priv;
         map_word status, status_OK = CMD(0x80);
@@ -1156,8 +1191,7 @@ static int inval_cache_and_wait_for_operation(
                 INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
         spin_lock(chip->mutex);
 
-        /* set our timeout to 8 times the expected delay */
-        timeo = chip_op_time * 8;
+        timeo = chip_op_time_max;
         if (!timeo)
                 timeo = 500000;
         reset_timeo = timeo;
@@ -1217,8 +1251,8 @@ static int inval_cache_and_wait_for_operation(
 
 #endif
 
-#define WAIT_TIMEOUT(map, chip, adr, udelay) \
-        INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay);
+#define WAIT_TIMEOUT(map, chip, adr, udelay, udelay_max) \
+        INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay, udelay_max);
 
 
 static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
@@ -1452,7 +1486,8 @@ static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
 
         ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
                                    adr, map_bankwidth(map),
-                                   chip->word_write_time);
+                                   chip->word_write_time,
+                                   chip->word_write_time_max);
         if (ret) {
                 xip_enable(map, chip, adr);
                 printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
@@ -1623,7 +1658,7 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
 
         chip->state = FL_WRITING_TO_BUFFER;
         map_write(map, write_cmd, cmd_adr);
-        ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0);
+        ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0, 0);
         if (ret) {
                 /* Argh. Not ready for write to buffer */
                 map_word Xstatus = map_read(map, cmd_adr);
@@ -1640,7 +1675,7 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
 
         /* Figure out the number of words to write */
         word_gap = (-adr & (map_bankwidth(map)-1));
-        words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
+        words = DIV_ROUND_UP(len - word_gap, map_bankwidth(map));
         if (!word_gap) {
                 words--;
         } else {
@@ -1692,7 +1727,8 @@ static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
 
         ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
                                    initial_adr, initial_len,
-                                   chip->buffer_write_time);
+                                   chip->buffer_write_time,
+                                   chip->buffer_write_time_max);
         if (ret) {
                 map_write(map, CMD(0x70), cmd_adr);
                 chip->state = FL_STATUS;
@@ -1827,7 +1863,8 @@ static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
 
         ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
                                    adr, len,
-                                   chip->erase_time);
+                                   chip->erase_time,
+                                   chip->erase_time_max);
         if (ret) {
                 map_write(map, CMD(0x70), adr);
                 chip->state = FL_STATUS;
@@ -2006,7 +2043,7 @@ static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip
          */
         udelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1000000/HZ : 0;
 
-        ret = WAIT_TIMEOUT(map, chip, adr, udelay);
+        ret = WAIT_TIMEOUT(map, chip, adr, udelay, udelay * 100);
         if (ret) {
                 map_write(map, CMD(0x70), adr);
                 chip->state = FL_STATUS;
diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
index a972cc6be436..3e6f5d8609e8 100644
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -13,6 +13,8 @@
  * XIP support hooks by Vitaly Wool (based on code for Intel flash
  * by Nicolas Pitre)
  *
+ * 25/09/2008 Christopher Moore: TopBottom fixup for many Macronix with CFI V1.0
+ *
  * Occasionally maintained by Thayne Harbaugh tharbaugh at lnxi dot com
  *
  * This code is GPL
@@ -43,6 +45,7 @@
 
 #define MANUFACTURER_AMD        0x0001
 #define MANUFACTURER_ATMEL      0x001F
+#define MANUFACTURER_MACRONIX   0x00C2
 #define MANUFACTURER_SST        0x00BF
 #define SST49LF004B             0x0060
 #define SST49LF040B             0x0050
@@ -144,12 +147,44 @@ static void fixup_amd_bootblock(struct mtd_info *mtd, void* param)
 
         if (((major << 8) | minor) < 0x3131) {
                 /* CFI version 1.0 => don't trust bootloc */
+
+                DEBUG(MTD_DEBUG_LEVEL1,
+                        "%s: JEDEC Vendor ID is 0x%02X Device ID is 0x%02X\n",
+                        map->name, cfi->mfr, cfi->id);
+
+                /* AFAICS all 29LV400 with a bottom boot block have a device ID
+                 * of 0x22BA in 16-bit mode and 0xBA in 8-bit mode.
+                 * These were badly detected as they have the 0x80 bit set
+                 * so treat them as a special case.
+                 */
+                if (((cfi->id == 0xBA) || (cfi->id == 0x22BA)) &&
+
+                        /* Macronix added CFI to their 2nd generation
+                         * MX29LV400C B/T but AFAICS no other 29LV400 (AMD,
+                         * Fujitsu, Spansion, EON, ESI and older Macronix)
+                         * has CFI.
+                         *
+                         * Therefore also check the manufacturer.
+                         * This reduces the risk of false detection due to
+                         * the 8-bit device ID.
+                         */
+                        (cfi->mfr == MANUFACTURER_MACRONIX)) {
+                        DEBUG(MTD_DEBUG_LEVEL1,
+                                "%s: Macronix MX29LV400C with bottom boot block"
+                                " detected\n", map->name);
+                        extp->TopBottom = 2;    /* bottom boot */
+                } else
                 if (cfi->id & 0x80) {
                         printk(KERN_WARNING "%s: JEDEC Device ID is 0x%02X. Assuming broken CFI table.\n", map->name, cfi->id);
                         extp->TopBottom = 3;    /* top boot */
                 } else {
                         extp->TopBottom = 2;    /* bottom boot */
                 }
+
+                DEBUG(MTD_DEBUG_LEVEL1,
+                        "%s: AMD CFI PRI V%c.%c has no boot block field;"
+                        " deduced %s from Device ID\n", map->name, major, minor,
+                        extp->TopBottom == 2 ? "bottom" : "top");
         }
 }
 #endif
@@ -178,10 +213,18 @@ static void fixup_convert_atmel_pri(struct mtd_info *mtd, void *param)
         if (atmel_pri.Features & 0x02)
                 extp->EraseSuspend = 2;
 
-        if (atmel_pri.BottomBoot)
-                extp->TopBottom = 2;
-        else
-                extp->TopBottom = 3;
+        /* Some chips got it backwards... */
+        if (cfi->id == AT49BV6416) {
+                if (atmel_pri.BottomBoot)
+                        extp->TopBottom = 3;
+                else
+                        extp->TopBottom = 2;
+        } else {
+                if (atmel_pri.BottomBoot)
+                        extp->TopBottom = 2;
+                else
+                        extp->TopBottom = 3;
+        }
 
         /* burst write mode not supported */
         cfi->cfiq->BufWriteTimeoutTyp = 0;
@@ -243,6 +286,7 @@ static struct cfi_fixup cfi_fixup_table[] = {
         { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri, NULL },
 #ifdef AMD_BOOTLOC_BUG
         { CFI_MFR_AMD, CFI_ID_ANY, fixup_amd_bootblock, NULL },
+        { MANUFACTURER_MACRONIX, CFI_ID_ANY, fixup_amd_bootblock, NULL },
 #endif
         { CFI_MFR_AMD, 0x0050, fixup_use_secsi, NULL, },
         { CFI_MFR_AMD, 0x0053, fixup_use_secsi, NULL, },
diff --git a/drivers/mtd/chips/cfi_probe.c b/drivers/mtd/chips/cfi_probe.c
index c418e92e1d92..e63e6749429a 100644
--- a/drivers/mtd/chips/cfi_probe.c
+++ b/drivers/mtd/chips/cfi_probe.c
@@ -44,17 +44,14 @@ do { \
 
 #define xip_enable(base, map, cfi) \
 do { \
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL); \
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL); \
+        cfi_qry_mode_off(base, map, cfi);               \
         xip_allowed(base, map); \
 } while (0)
 
 #define xip_disable_qry(base, map, cfi) \
 do { \
         xip_disable(); \
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL); \
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL); \
-        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL); \
+        cfi_qry_mode_on(base, map, cfi); \
 } while (0)
 
 #else
@@ -70,32 +67,6 @@ do { \
    in: interleave,type,mode
    ret: table index, <0 for error
  */
-static int __xipram qry_present(struct map_info *map, __u32 base,
-                                struct cfi_private *cfi)
-{
-        int osf = cfi->interleave * cfi->device_type;   // scale factor
-        map_word val[3];
-        map_word qry[3];
-
-        qry[0] = cfi_build_cmd('Q', map, cfi);
-        qry[1] = cfi_build_cmd('R', map, cfi);
-        qry[2] = cfi_build_cmd('Y', map, cfi);
-
-        val[0] = map_read(map, base + osf*0x10);
-        val[1] = map_read(map, base + osf*0x11);
-        val[2] = map_read(map, base + osf*0x12);
-
-        if (!map_word_equal(map, qry[0], val[0]))
-                return 0;
-
-        if (!map_word_equal(map, qry[1], val[1]))
-                return 0;
-
-        if (!map_word_equal(map, qry[2], val[2]))
-                return 0;
-
-        return 1;       // "QRY" found
-}
 
 static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
                                    unsigned long *chip_map, struct cfi_private *cfi)
@@ -116,11 +87,7 @@ static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
         }
 
         xip_disable();
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
-        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
-
-        if (!qry_present(map,base,cfi)) {
+        if (!cfi_qry_mode_on(base, map, cfi)) {
                 xip_enable(base, map, cfi);
                 return 0;
         }
@@ -141,14 +108,13 @@ static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
                 start = i << cfi->chipshift;
                 /* This chip should be in read mode if it's one
                    we've already touched. */
-                if (qry_present(map, start, cfi)) {
+                if (cfi_qry_present(map, start, cfi)) {
                         /* Eep. This chip also had the QRY marker.
                          * Is it an alias for the new one? */
-                        cfi_send_gen_cmd(0xF0, 0, start, map, cfi, cfi->device_type, NULL);
-                        cfi_send_gen_cmd(0xFF, 0, start, map, cfi, cfi->device_type, NULL);
+                        cfi_qry_mode_off(start, map, cfi);
 
                         /* If the QRY marker goes away, it's an alias */
-                        if (!qry_present(map, start, cfi)) {
+                        if (!cfi_qry_present(map, start, cfi)) {
                                 xip_allowed(base, map);
                                 printk(KERN_DEBUG "%s: Found an alias at 0x%x for the chip at 0x%lx\n",
                                        map->name, base, start);
@@ -158,10 +124,9 @@ static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
                          * unfortunate. Stick the new chip in read mode
                          * too and if it's the same, assume it's an alias. */
                         /* FIXME: Use other modes to do a proper check */
-                        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
-                        cfi_send_gen_cmd(0xFF, 0, start, map, cfi, cfi->device_type, NULL);
+                        cfi_qry_mode_off(base, map, cfi);
 
-                        if (qry_present(map, base, cfi)) {
+                        if (cfi_qry_present(map, base, cfi)) {
                                 xip_allowed(base, map);
                                 printk(KERN_DEBUG "%s: Found an alias at 0x%x for the chip at 0x%lx\n",
                                        map->name, base, start);
@@ -176,8 +141,7 @@ static int __xipram cfi_probe_chip(struct map_info *map, __u32 base,
         cfi->numchips++;
 
         /* Put it back into Read Mode */
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_qry_mode_off(base, map, cfi);
         xip_allowed(base, map);
 
         printk(KERN_INFO "%s: Found %d x%d devices at 0x%x in %d-bit bank\n",
@@ -237,9 +201,7 @@ static int __xipram cfi_chip_setup(struct map_info *map,
                           cfi_read_query(map, base + 0xf * ofs_factor);
 
         /* Put it back into Read Mode */
-        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
-        /* ... even if it's an Intel chip */
-        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_qry_mode_off(base, map, cfi);
         xip_allowed(base, map);
 
         /* Do any necessary byteswapping */
diff --git a/drivers/mtd/chips/cfi_util.c b/drivers/mtd/chips/cfi_util.c
index 0ee457018016..34d40e25d312 100644
--- a/drivers/mtd/chips/cfi_util.c
+++ b/drivers/mtd/chips/cfi_util.c
@@ -24,6 +24,66 @@
 #include <linux/mtd/cfi.h>
 #include <linux/mtd/compatmac.h>
 
+int __xipram cfi_qry_present(struct map_info *map, __u32 base,
+                             struct cfi_private *cfi)
+{
+        int osf = cfi->interleave * cfi->device_type;   /* scale factor */
+        map_word val[3];
+        map_word qry[3];
+
+        qry[0] = cfi_build_cmd('Q', map, cfi);
+        qry[1] = cfi_build_cmd('R', map, cfi);
+        qry[2] = cfi_build_cmd('Y', map, cfi);
+
+        val[0] = map_read(map, base + osf*0x10);
+        val[1] = map_read(map, base + osf*0x11);
+        val[2] = map_read(map, base + osf*0x12);
+
+        if (!map_word_equal(map, qry[0], val[0]))
+                return 0;
+
+        if (!map_word_equal(map, qry[1], val[1]))
+                return 0;
+
+        if (!map_word_equal(map, qry[2], val[2]))
+                return 0;
+
+        return 1;       /* "QRY" found */
+}
+EXPORT_SYMBOL_GPL(cfi_qry_present);
+
+int __xipram cfi_qry_mode_on(uint32_t base, struct map_info *map,
+                             struct cfi_private *cfi)
+{
+        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
+        if (cfi_qry_present(map, base, cfi))
+                return 1;
+        /* QRY not found probably we deal with some odd CFI chips */
+        /* Some revisions of some old Intel chips? */
+        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
+        if (cfi_qry_present(map, base, cfi))
+                return 1;
+        /* ST M29DW chips */
+        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0x98, 0x555, base, map, cfi, cfi->device_type, NULL);
+        if (cfi_qry_present(map, base, cfi))
+                return 1;
+        /* QRY not found */
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cfi_qry_mode_on);
+
+void __xipram cfi_qry_mode_off(uint32_t base, struct map_info *map,
+                               struct cfi_private *cfi)
+{
+        cfi_send_gen_cmd(0xF0, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_send_gen_cmd(0xFF, 0, base, map, cfi, cfi->device_type, NULL);
+}
+EXPORT_SYMBOL_GPL(cfi_qry_mode_off);
+
 struct cfi_extquery *
 __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* name)
 {
@@ -48,8 +108,7 @@ __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* n
 #endif
 
         /* Switch it into Query Mode */
-        cfi_send_gen_cmd(0x98, 0x55, base, map, cfi, cfi->device_type, NULL);
-
+        cfi_qry_mode_on(base, map, cfi);
         /* Read in the Extended Query Table */
         for (i=0; i<size; i++) {
                 ((unsigned char *)extp)[i] =
@@ -57,8 +116,7 @@ __xipram cfi_read_pri(struct map_info *map, __u16 adr, __u16 size, const char* n
         }
 
         /* Make sure it returns to read mode */
-        cfi_send_gen_cmd(0xf0, 0, base, map, cfi, cfi->device_type, NULL);
-        cfi_send_gen_cmd(0xff, 0, base, map, cfi, cfi->device_type, NULL);
+        cfi_qry_mode_off(base, map, cfi);
 
 #ifdef CONFIG_MTD_XIP
         (void) map_read(map, base);
diff --git a/drivers/mtd/chips/gen_probe.c b/drivers/mtd/chips/gen_probe.c
index f061885b2812..e2dc96441e05 100644
--- a/drivers/mtd/chips/gen_probe.c
+++ b/drivers/mtd/chips/gen_probe.c
@@ -111,7 +111,7 @@ static struct cfi_private *genprobe_ident_chips(struct map_info *map, struct chi
                 max_chips = 1;
         }
 
-        mapsize = sizeof(long) * ( (max_chips + BITS_PER_LONG-1) / BITS_PER_LONG );
+        mapsize = sizeof(long) * DIV_ROUND_UP(max_chips, BITS_PER_LONG);
         chip_map = kzalloc(mapsize, GFP_KERNEL);
         if (!chip_map) {
                 printk(KERN_WARNING "%s: kmalloc failed for CFI chip map\n", map->name);
diff --git a/drivers/mtd/cmdlinepart.c b/drivers/mtd/cmdlinepart.c
index 71bc07f149b7..50a340388e74 100644
--- a/drivers/mtd/cmdlinepart.c
+++ b/drivers/mtd/cmdlinepart.c
@@ -7,6 +7,7 @@
  *
  * mtdparts=<mtddef>[;<mtddef]
  * <mtddef>  := <mtd-id>:<partdef>[,<partdef>]
+ *              where <mtd-id> is the name from the "cat /proc/mtd" command
  * <partdef> := <size>[@offset][<name>][ro][lk]
  * <mtd-id>  := unique name used in mapping driver/device (mtd->name)
  * <size>    := standard linux memsize OR "-" to denote all remaining space
diff --git a/drivers/mtd/devices/Kconfig b/drivers/mtd/devices/Kconfig
index 9c613f06623c..6fde0a2e3567 100644
--- a/drivers/mtd/devices/Kconfig
+++ b/drivers/mtd/devices/Kconfig
@@ -59,6 +59,27 @@ config MTD_DATAFLASH
           Sometimes DataFlash chips are packaged inside MMC-format
           cards; at this writing, the MMC stack won't handle those.
 
+config MTD_DATAFLASH_WRITE_VERIFY
+        bool "Verify DataFlash page writes"
+        depends on MTD_DATAFLASH
+        help
+          This adds an extra check when data is written to the flash.
+          It may help if you are verifying chip setup (timings etc) on
+          your board.  There is a rare possibility that even though the
+          device thinks the write was successful, a bit could have been
+          flipped accidentally due to device wear or something else.
+
+config MTD_DATAFLASH_OTP
+        bool "DataFlash OTP support (Security Register)"
+        depends on MTD_DATAFLASH
+        select HAVE_MTD_OTP
+        help
+          Newer DataFlash chips (revisions C and D) support 128 bytes of
+          one-time-programmable (OTP) data.  The first half may be written
+          (once) with up to 64 bytes of data, such as a serial number or
+          other key product data.  The second half is programmed with a
+          unique-to-each-chip bit pattern at the factory.
+
 config MTD_M25P80
         tristate "Support most SPI Flash chips (AT26DF, M25P, W25X, ...)"
         depends on SPI_MASTER && EXPERIMENTAL
diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
index b35c3333e210..76a76751da36 100644
--- a/drivers/mtd/devices/m25p80.c
+++ b/drivers/mtd/devices/m25p80.c
@@ -39,6 +39,7 @@
 #define OPCODE_PP               0x02    /* Page program (up to 256 bytes) */
 #define OPCODE_BE_4K            0x20    /* Erase 4KiB block */
 #define OPCODE_BE_32K           0x52    /* Erase 32KiB block */
+#define OPCODE_BE               0xc7    /* Erase whole flash block */
 #define OPCODE_SE               0xd8    /* Sector erase (usually 64KiB) */
 #define OPCODE_RDID             0x9f    /* Read JEDEC ID */
 
@@ -161,6 +162,31 @@ static int wait_till_ready(struct m25p *flash)
         return 1;
 }
 
+/*
+ * Erase the whole flash memory
+ *
+ * Returns 0 if successful, non-zero otherwise.
+ */
+static int erase_block(struct m25p *flash)
+{
+        DEBUG(MTD_DEBUG_LEVEL3, "%s: %s %dKiB\n",
+                        flash->spi->dev.bus_id, __func__,
+                        flash->mtd.size / 1024);
+
+        /* Wait until finished previous write command. */
+        if (wait_till_ready(flash))
+                return 1;
+
+        /* Send write enable, then erase commands. */
+        write_enable(flash);
+
+        /* Set up command buffer. */
+        flash->command[0] = OPCODE_BE;
+
+        spi_write(flash->spi, flash->command, 1);
+
+        return 0;
+}
 
 /*
  * Erase one sector of flash memory at offset ``offset'' which is any
@@ -229,15 +255,21 @@ static int m25p80_erase(struct mtd_info *mtd, struct erase_info *instr)
          */
 
         /* now erase those sectors */
-        while (len) {
-                if (erase_sector(flash, addr)) {
-                        instr->state = MTD_ERASE_FAILED;
-                        mutex_unlock(&flash->lock);
-                        return -EIO;
-                }
+        if (len == flash->mtd.size && erase_block(flash)) {
+                instr->state = MTD_ERASE_FAILED;
+                mutex_unlock(&flash->lock);
+                return -EIO;
+        } else {
+                while (len) {
+                        if (erase_sector(flash, addr)) {
+                                instr->state = MTD_ERASE_FAILED;
+                                mutex_unlock(&flash->lock);
+                                return -EIO;
+                        }
 
-                addr += mtd->erasesize;
-                len -= mtd->erasesize;
+                        addr += mtd->erasesize;
+                        len -= mtd->erasesize;
+                }
         }
 
         mutex_unlock(&flash->lock);
@@ -437,6 +469,7 @@ struct flash_info {
          * then a two byte device id.
          */
         u32             jedec_id;
+        u16             ext_id;
 
         /* The size listed here is what works with OPCODE_SE, which isn't
          * necessarily called a "sector" by the vendor.
@@ -456,72 +489,75 @@ struct flash_info {
 static struct flash_info __devinitdata m25p_data [] = {
 
         /* Atmel -- some are (confusingly) marketed as "DataFlash" */
-        { "at25fs010",  0x1f6601, 32 * 1024, 4, SECT_4K, },
-        { "at25fs040",  0x1f6604, 64 * 1024, 8, SECT_4K, },
+        { "at25fs010",  0x1f6601, 0, 32 * 1024, 4, SECT_4K, },
+        { "at25fs040",  0x1f6604, 0, 64 * 1024, 8, SECT_4K, },
 
-        { "at25df041a", 0x1f4401, 64 * 1024, 8, SECT_4K, },
-        { "at25df641",  0x1f4800, 64 * 1024, 128, SECT_4K, },
+        { "at25df041a", 0x1f4401, 0, 64 * 1024, 8, SECT_4K, },
+        { "at25df641",  0x1f4800, 0, 64 * 1024, 128, SECT_4K, },
 
-        { "at26f004",   0x1f0400, 64 * 1024, 8, SECT_4K, },
-        { "at26df081a", 0x1f4501, 64 * 1024, 16, SECT_4K, },
-        { "at26df161a", 0x1f4601, 64 * 1024, 32, SECT_4K, },
-        { "at26df321",  0x1f4701, 64 * 1024, 64, SECT_4K, },
+        { "at26f004",   0x1f0400, 0, 64 * 1024, 8, SECT_4K, },
+        { "at26df081a", 0x1f4501, 0, 64 * 1024, 16, SECT_4K, },
+        { "at26df161a", 0x1f4601, 0, 64 * 1024, 32, SECT_4K, },
+        { "at26df321",  0x1f4701, 0, 64 * 1024, 64, SECT_4K, },
 
         /* Spansion -- single (large) sector size only, at least
          * for the chips listed here (without boot sectors).
          */
-        { "s25sl004a", 0x010212, 64 * 1024, 8, },
-        { "s25sl008a", 0x010213, 64 * 1024, 16, },
-        { "s25sl016a", 0x010214, 64 * 1024, 32, },
-        { "s25sl032a", 0x010215, 64 * 1024, 64, },
-        { "s25sl064a", 0x010216, 64 * 1024, 128, },
+        { "s25sl004a", 0x010212, 0, 64 * 1024, 8, },
+        { "s25sl008a", 0x010213, 0, 64 * 1024, 16, },
+        { "s25sl016a", 0x010214, 0, 64 * 1024, 32, },
+        { "s25sl032a", 0x010215, 0, 64 * 1024, 64, },
+        { "s25sl064a", 0x010216, 0, 64 * 1024, 128, },
+        { "s25sl12800", 0x012018, 0x0300, 256 * 1024, 64, },
+        { "s25sl12801", 0x012018, 0x0301, 64 * 1024, 256, },
 
         /* SST -- large erase sizes are "overlays", "sectors" are 4K */
-        { "sst25vf040b", 0xbf258d, 64 * 1024, 8, SECT_4K, },
-        { "sst25vf080b", 0xbf258e, 64 * 1024, 16, SECT_4K, },
-        { "sst25vf016b", 0xbf2541, 64 * 1024, 32, SECT_4K, },
-        { "sst25vf032b", 0xbf254a, 64 * 1024, 64, SECT_4K, },
+        { "sst25vf040b", 0xbf258d, 0, 64 * 1024, 8, SECT_4K, },
+        { "sst25vf080b", 0xbf258e, 0, 64 * 1024, 16, SECT_4K, },
+        { "sst25vf016b", 0xbf2541, 0, 64 * 1024, 32, SECT_4K, },
+        { "sst25vf032b", 0xbf254a, 0, 64 * 1024, 64, SECT_4K, },
 
         /* ST Microelectronics -- newer production may have feature updates */
-        { "m25p05",  0x202010,  32 * 1024, 2, },
-        { "m25p10",  0x202011,  32 * 1024, 4, },
-        { "m25p20",  0x202012,  64 * 1024, 4, },
-        { "m25p40",  0x202013,  64 * 1024, 8, },
-        { "m25p80",         0,  64 * 1024, 16, },
-        { "m25p16",  0x202015,  64 * 1024, 32, },
-        { "m25p32",  0x202016,  64 * 1024, 64, },
-        { "m25p64",  0x202017,  64 * 1024, 128, },
-        { "m25p128", 0x202018, 256 * 1024, 64, },
-
-        { "m45pe80", 0x204014,  64 * 1024, 16, },
-        { "m45pe16", 0x204015,  64 * 1024, 32, },
-
-        { "m25pe80", 0x208014,  64 * 1024, 16, },
-        { "m25pe16", 0x208015,  64 * 1024, 32, SECT_4K, },
+        { "m25p05",  0x202010,  0, 32 * 1024, 2, },
+        { "m25p10",  0x202011,  0, 32 * 1024, 4, },
+        { "m25p20",  0x202012,  0, 64 * 1024, 4, },
+        { "m25p40",  0x202013,  0, 64 * 1024, 8, },
+        { "m25p80",         0,  0, 64 * 1024, 16, },
+        { "m25p16",  0x202015,  0, 64 * 1024, 32, },
+        { "m25p32",  0x202016,  0, 64 * 1024, 64, },
+        { "m25p64",  0x202017,  0, 64 * 1024, 128, },
+        { "m25p128", 0x202018, 0, 256 * 1024, 64, },
+
+        { "m45pe80", 0x204014,  0, 64 * 1024, 16, },
+        { "m45pe16", 0x204015,  0, 64 * 1024, 32, },
+
+        { "m25pe80", 0x208014,  0, 64 * 1024, 16, },
+        { "m25pe16", 0x208015,  0, 64 * 1024, 32, SECT_4K, },
 
         /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
-        { "w25x10", 0xef3011, 64 * 1024, 2, SECT_4K, },
-        { "w25x20", 0xef3012, 64 * 1024, 4, SECT_4K, },
-        { "w25x40", 0xef3013, 64 * 1024, 8, SECT_4K, },
-        { "w25x80", 0xef3014, 64 * 1024, 16, SECT_4K, },
-        { "w25x16", 0xef3015, 64 * 1024, 32, SECT_4K, },
-        { "w25x32", 0xef3016, 64 * 1024, 64, SECT_4K, },
-        { "w25x64", 0xef3017, 64 * 1024, 128, SECT_4K, },
+        { "w25x10", 0xef3011, 0, 64 * 1024, 2, SECT_4K, },
+        { "w25x20", 0xef3012, 0, 64 * 1024, 4, SECT_4K, },
+        { "w25x40", 0xef3013, 0, 64 * 1024, 8, SECT_4K, },
+        { "w25x80", 0xef3014, 0, 64 * 1024, 16, SECT_4K, },
+        { "w25x16", 0xef3015, 0, 64 * 1024, 32, SECT_4K, },
+        { "w25x32", 0xef3016, 0, 64 * 1024, 64, SECT_4K, },
+        { "w25x64", 0xef3017, 0, 64 * 1024, 128, SECT_4K, },
 };
 
 static struct flash_info *__devinit jedec_probe(struct spi_device *spi)
 {
         int                     tmp;
         u8                      code = OPCODE_RDID;
-        u8                      id[3];
+        u8                      id[5];
         u32                     jedec;
+        u16                     ext_jedec;
         struct flash_info       *info;
 
         /* JEDEC also defines an optional "extended device information"
          * string for after vendor-specific data, after the three bytes
          * we use here.  Supporting some chips might require using it.
          */
-        tmp = spi_write_then_read(spi, &code, 1, id, 3);
+        tmp = spi_write_then_read(spi, &code, 1, id, 5);
         if (tmp < 0) {
                 DEBUG(MTD_DEBUG_LEVEL0, "%s: error %d reading JEDEC ID\n",
                         spi->dev.bus_id, tmp);
@@ -533,10 +569,14 @@ static struct flash_info *__devinit jedec_probe(struct spi_device *spi)
         jedec = jedec << 8;
         jedec |= id[2];
 
+        ext_jedec = id[3] << 8 | id[4];
+
         for (tmp = 0, info = m25p_data;
                         tmp < ARRAY_SIZE(m25p_data);
                         tmp++, info++) {
                 if (info->jedec_id == jedec)
+                        if (ext_jedec != 0 && info->ext_id != ext_jedec)
+                                continue;
                         return info;
         }
         dev_err(&spi->dev, "unrecognized JEDEC id %06x\n", jedec);
diff --git a/drivers/mtd/devices/mtd_dataflash.c b/drivers/mtd/devices/mtd_dataflash.c
index 8bd0dea6885f..6dd9aff8bb2d 100644
--- a/drivers/mtd/devices/mtd_dataflash.c
+++ b/drivers/mtd/devices/mtd_dataflash.c
@@ -30,12 +30,10 @@
  * doesn't (yet) use these for any kind of i/o overlap or prefetching.
  *
  * Sometimes DataFlash is packaged in MMC-format cards, although the
- * MMC stack can't use SPI (yet), or distinguish between MMC and DataFlash
+ * MMC stack can't (yet?) distinguish between MMC and DataFlash
  * protocols during enumeration.
  */
 
-#define CONFIG_DATAFLASH_WRITE_VERIFY
-
 /* reads can bypass the buffers */
 #define OP_READ_CONTINUOUS      0xE8
 #define OP_READ_PAGE            0xD2
@@ -80,7 +78,8 @@
  */
 #define OP_READ_ID              0x9F
 #define OP_READ_SECURITY        0x77
-#define OP_WRITE_SECURITY       0x9A    /* OTP bits */
+#define OP_WRITE_SECURITY_REVC  0x9A
+#define OP_WRITE_SECURITY       0x9B    /* revision D */
 
 
 struct dataflash {
@@ -402,7 +401,7 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
                 (void) dataflash_waitready(priv->spi);
 
 
-#ifdef  CONFIG_DATAFLASH_WRITE_VERIFY
+#ifdef CONFIG_MTD_DATAFLASH_VERIFY_WRITE
 
                 /* (3) Compare to Buffer1 */
                 addr = pageaddr << priv->page_offset;
@@ -431,7 +430,7 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
                 } else
                         status = 0;
 
-#endif  /* CONFIG_DATAFLASH_WRITE_VERIFY */
+#endif  /* CONFIG_MTD_DATAFLASH_VERIFY_WRITE */
 
                 remaining = remaining - writelen;
                 pageaddr++;
@@ -451,16 +450,192 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
 
 /* ......................................................................... */
 
+#ifdef CONFIG_MTD_DATAFLASH_OTP
+
+static int dataflash_get_otp_info(struct mtd_info *mtd,
+                struct otp_info *info, size_t len)
+{
+        /* Report both blocks as identical:  bytes 0..64, locked.
+         * Unless the user block changed from all-ones, we can't
+         * tell whether it's still writable; so we assume it isn't.
+         */
+        info->start = 0;
+        info->length = 64;
+        info->locked = 1;
+        return sizeof(*info);
+}
+
+static ssize_t otp_read(struct spi_device *spi, unsigned base,
+                uint8_t *buf, loff_t off, size_t len)
+{
+        struct spi_message      m;
+        size_t                  l;
+        uint8_t                 *scratch;
+        struct spi_transfer     t;
+        int                     status;
+
+        if (off > 64)
+                return -EINVAL;
+
+        if ((off + len) > 64)
+                len = 64 - off;
+        if (len == 0)
+                return len;
+
+        spi_message_init(&m);
+
+        l = 4 + base + off + len;
+        scratch = kzalloc(l, GFP_KERNEL);
+        if (!scratch)
+                return -ENOMEM;
+
+        /* OUT: OP_READ_SECURITY, 3 don't-care bytes, zeroes
+         * IN:  ignore 4 bytes, data bytes 0..N (max 127)
+         */
+        scratch[0] = OP_READ_SECURITY;
+
+        memset(&t, 0, sizeof t);
+        t.tx_buf = scratch;
+        t.rx_buf = scratch;
+        t.len = l;
+        spi_message_add_tail(&t, &m);
+
+        dataflash_waitready(spi);
+
+        status = spi_sync(spi, &m);
+        if (status >= 0) {
+                memcpy(buf, scratch + 4 + base + off, len);
+                status = len;
+        }
+
+        kfree(scratch);
+        return status;
+}
+
+static int dataflash_read_fact_otp(struct mtd_info *mtd,
+                loff_t from, size_t len, size_t *retlen, u_char *buf)
+{
+        struct dataflash        *priv = (struct dataflash *)mtd->priv;
+        int                     status;
+
+        /* 64 bytes, from 0..63 ... start at 64 on-chip */
+        mutex_lock(&priv->lock);
+        status = otp_read(priv->spi, 64, buf, from, len);
+        mutex_unlock(&priv->lock);
+
+        if (status < 0)
+                return status;
+        *retlen = status;
+        return 0;
+}
+
+static int dataflash_read_user_otp(struct mtd_info *mtd,
+                loff_t from, size_t len, size_t *retlen, u_char *buf)
+{
+        struct dataflash        *priv = (struct dataflash *)mtd->priv;
+        int                     status;
+
+        /* 64 bytes, from 0..63 ... start at 0 on-chip */
+        mutex_lock(&priv->lock);
+        status = otp_read(priv->spi, 0, buf, from, len);
+        mutex_unlock(&priv->lock);
+
+        if (status < 0)
+                return status;
+        *retlen = status;
+        return 0;
+}
+
+static int dataflash_write_user_otp(struct mtd_info *mtd,
+                loff_t from, size_t len, size_t *retlen, u_char *buf)
+{
+        struct spi_message      m;
+        const size_t            l = 4 + 64;
+        uint8_t                 *scratch;
+        struct spi_transfer     t;
+        struct dataflash        *priv = (struct dataflash *)mtd->priv;
+        int                     status;
+
+        if (len > 64)
+                return -EINVAL;
+
+        /* Strictly speaking, we *could* truncate the write ... but
+         * let's not do that for the only write that's ever possible.
+         */
+        if ((from + len) > 64)
+                return -EINVAL;
+
+        /* OUT: OP_WRITE_SECURITY, 3 zeroes, 64 data-or-zero bytes
+         * IN:  ignore all
+         */
+        scratch = kzalloc(l, GFP_KERNEL);
+        if (!scratch)
+                return -ENOMEM;
+        scratch[0] = OP_WRITE_SECURITY;
+        memcpy(scratch + 4 + from, buf, len);
+
+        spi_message_init(&m);
+
+        memset(&t, 0, sizeof t);
+        t.tx_buf = scratch;
+        t.len = l;
+        spi_message_add_tail(&t, &m);
+
+        /* Write the OTP bits, if they've not yet been written.
+         * This modifies SRAM buffer1.
+         */
+        mutex_lock(&priv->lock);
+        dataflash_waitready(priv->spi);
+        status = spi_sync(priv->spi, &m);
+        mutex_unlock(&priv->lock);
+
+        kfree(scratch);
+
+        if (status >= 0) {
+                status = 0;
+                *retlen = len;
+        }
+        return status;
+}
+
+static char *otp_setup(struct mtd_info *device, char revision)
+{
+        device->get_fact_prot_info = dataflash_get_otp_info;
+        device->read_fact_prot_reg = dataflash_read_fact_otp;
+        device->get_user_prot_info = dataflash_get_otp_info;
+        device->read_user_prot_reg = dataflash_read_user_otp;
+
+        /* rev c parts (at45db321c and at45db1281 only!) use a
+         * different write procedure; not (yet?) implemented.
+         */
+        if (revision > 'c')
+                device->write_user_prot_reg = dataflash_write_user_otp;
+
+        return ", OTP";
+}
+
+#else
+
+static char *otp_setup(struct mtd_info *device, char revision)
+{
+        return " (OTP)";
+}
+
+#endif
+
+/* ......................................................................... */
+
 /*
  * Register DataFlash device with MTD subsystem.
  */
 static int __devinit
-add_dataflash(struct spi_device *spi, char *name,
-                int nr_pages, int pagesize, int pageoffset)
+add_dataflash_otp(struct spi_device *spi, char *name,
+                int nr_pages, int pagesize, int pageoffset, char revision)
 {
         struct dataflash                *priv;
         struct mtd_info                 *device;
         struct flash_platform_data      *pdata = spi->dev.platform_data;
+        char                            *otp_tag = "";
 
         priv = kzalloc(sizeof *priv, GFP_KERNEL);
         if (!priv)
@@ -489,8 +664,12 @@ add_dataflash(struct spi_device *spi, char *name,
         device->write = dataflash_write;
         device->priv = priv;
 
-        dev_info(&spi->dev, "%s (%d KBytes) pagesize %d bytes\n",
-                        name, DIV_ROUND_UP(device->size, 1024), pagesize);
+        if (revision >= 'c')
+                otp_tag = otp_setup(device, revision);
+
+        dev_info(&spi->dev, "%s (%d KBytes) pagesize %d bytes%s\n",
+                        name, DIV_ROUND_UP(device->size, 1024),
+                        pagesize, otp_tag);
         dev_set_drvdata(&spi->dev, priv);
 
         if (mtd_has_partitions()) {
@@ -519,6 +698,14 @@ add_dataflash(struct spi_device *spi, char *name,
         return add_mtd_device(device) == 1 ? -ENODEV : 0;
 }
 
+static inline int __devinit
+add_dataflash(struct spi_device *spi, char *name,
+                int nr_pages, int pagesize, int pageoffset)
+{
+        return add_dataflash_otp(spi, name, nr_pages, pagesize,
+                        pageoffset, 0);
+}
+
 struct flash_info {
         char            *name;
 
@@ -664,13 +851,16 @@ static int __devinit dataflash_probe(struct spi_device *spi)
          * Try to detect dataflash by JEDEC ID.
          * If it succeeds we know we have either a C or D part.
          * D will support power of 2 pagesize option.
+         * Both support the security register, though with different
+         * write procedures.
          */
         info = jedec_probe(spi);
         if (IS_ERR(info))
                 return PTR_ERR(info);
         if (info != NULL)
-                return add_dataflash(spi, info->name, info->nr_pages,
-                                 info->pagesize, info->pageoffset);
+                return add_dataflash_otp(spi, info->name, info->nr_pages,
+                                info->pagesize, info->pageoffset,
+                                (info->flags & SUP_POW2PS) ? 'd' : 'c');
 
         /*
          * Older chips support only legacy commands, identifing
diff --git a/drivers/mtd/inftlcore.c b/drivers/mtd/inftlcore.c
index c4f9d3378b24..50ce13887f63 100644
--- a/drivers/mtd/inftlcore.c
+++ b/drivers/mtd/inftlcore.c
@@ -388,6 +388,10 @@ static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned
                 if (thisEUN == targetEUN)
                         break;
 
+                /* Unlink the last block from the chain. */
+                inftl->PUtable[prevEUN] = BLOCK_NIL;
+
+                /* Now try to erase it. */
                 if (INFTL_formatblock(inftl, thisEUN) < 0) {
                         /*
                          * Could not erase : mark block as reserved.
@@ -396,7 +400,6 @@ static u16 INFTL_foldchain(struct INFTLrecord *inftl, unsigned thisVUC, unsigned
                 } else {
                         /* Correctly erased : mark it as free */
                         inftl->PUtable[thisEUN] = BLOCK_FREE;
-                        inftl->PUtable[prevEUN] = BLOCK_NIL;
                         inftl->numfreeEUNs++;
                 }
         }
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index df8e00bba07b..5ea169362164 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -332,30 +332,6 @@ config MTD_CFI_FLAGADM
           Mapping for the Flaga digital module. If you don't have one, ignore
           this setting.
 
-config MTD_WALNUT
-        tristate "Flash device mapped on IBM 405GP Walnut"
-        depends on MTD_JEDECPROBE && WALNUT && !PPC_MERGE
-        help
-          This enables access routines for the flash chips on the IBM 405GP
-          Walnut board. If you have one of these boards and would like to
-          use the flash chips on it, say 'Y'.
-
-config MTD_EBONY
-        tristate "Flash devices mapped on IBM 440GP Ebony"
-        depends on MTD_JEDECPROBE && EBONY && !PPC_MERGE
-        help
-          This enables access routines for the flash chips on the IBM 440GP
-          Ebony board. If you have one of these boards and would like to
-          use the flash chips on it, say 'Y'.
-
-config MTD_OCOTEA
-        tristate "Flash devices mapped on IBM 440GX Ocotea"
-        depends on MTD_CFI && OCOTEA && !PPC_MERGE
-        help
-          This enables access routines for the flash chips on the IBM 440GX
-          Ocotea board. If you have one of these boards and would like to
-          use the flash chips on it, say 'Y'.
-
 config MTD_REDWOOD
         tristate "CFI Flash devices mapped on IBM Redwood"
         depends on MTD_CFI && ( REDWOOD_4 || REDWOOD_5 || REDWOOD_6 )
@@ -458,13 +434,6 @@ config MTD_CEIVA
           PhotoMax Digital Picture Frame.
           If you have such a device, say 'Y'.
 
-config MTD_NOR_TOTO
-        tristate "NOR Flash device on TOTO board"
-        depends on ARCH_OMAP && OMAP_TOTO
-        help
-          This enables access to the NOR flash on the Texas Instruments
-          TOTO board.
-
 config MTD_H720X
         tristate "Hynix evaluation board mappings"
         depends on MTD_CFI && ( ARCH_H7201 || ARCH_H7202 )
@@ -522,7 +491,7 @@ config MTD_BFIN_ASYNC
 
 config MTD_UCLINUX
         tristate "Generic uClinux RAM/ROM filesystem support"
-        depends on MTD_PARTITIONS && !MMU
+        depends on MTD_PARTITIONS && MTD_RAM && !MMU
         help
           Map driver to support image based filesystems for uClinux.
 
diff --git a/drivers/mtd/maps/Makefile b/drivers/mtd/maps/Makefile
index 6cda6df973e5..6d9ba35caf11 100644
--- a/drivers/mtd/maps/Makefile
+++ b/drivers/mtd/maps/Makefile
@@ -50,12 +50,8 @@ obj-$(CONFIG_MTD_REDWOOD)	+= redwood.o
 obj-$(CONFIG_MTD_UCLINUX)       += uclinux.o
 obj-$(CONFIG_MTD_NETtel)        += nettel.o
 obj-$(CONFIG_MTD_SCB2_FLASH)    += scb2_flash.o
-obj-$(CONFIG_MTD_EBONY)         += ebony.o
-obj-$(CONFIG_MTD_OCOTEA)        += ocotea.o
-obj-$(CONFIG_MTD_WALNUT)        += walnut.o
 obj-$(CONFIG_MTD_H720X)         += h720x-flash.o
 obj-$(CONFIG_MTD_SBC8240)       += sbc8240.o
-obj-$(CONFIG_MTD_NOR_TOTO)      += omap-toto-flash.o
 obj-$(CONFIG_MTD_IXP4XX)        += ixp4xx.o
 obj-$(CONFIG_MTD_IXP2000)       += ixp2000.o
 obj-$(CONFIG_MTD_WRSBC8260)     += wr_sbc82xx_flash.o
diff --git a/drivers/mtd/maps/ebony.c b/drivers/mtd/maps/ebony.c
deleted file mode 100644
index d92b7c70d3ed..000000000000
--- a/drivers/mtd/maps/ebony.c
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * Mapping for Ebony user flash
- *
- * Matt Porter <mporter@kernel.crashing.org>
- *
- * Copyright 2002-2004 MontaVista Software Inc.
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-#include <asm/io.h>
-#include <asm/ibm44x.h>
-#include <platforms/4xx/ebony.h>
-
-static struct mtd_info *flash;
-
-static struct map_info ebony_small_map = {
-        .name =         "Ebony small flash",
-        .size =         EBONY_SMALL_FLASH_SIZE,
-        .bankwidth =    1,
-};
-
-static struct map_info ebony_large_map = {
-        .name =         "Ebony large flash",
-        .size =         EBONY_LARGE_FLASH_SIZE,
-        .bankwidth =    1,
-};
-
-static struct mtd_partition ebony_small_partitions[] = {
-        {
-                .name =   "OpenBIOS",
-                .offset = 0x0,
-                .size =   0x80000,
-        }
-};
-
-static struct mtd_partition ebony_large_partitions[] = {
-        {
-                .name =   "fs",
-                .offset = 0,
-                .size =   0x380000,
-        },
-        {
-                .name =   "firmware",
-                .offset = 0x380000,
-                .size =   0x80000,
-        }
-};
-
-int __init init_ebony(void)
-{
-        u8 fpga0_reg;
-        u8 __iomem *fpga0_adr;
-        unsigned long long small_flash_base, large_flash_base;
-
-        fpga0_adr = ioremap64(EBONY_FPGA_ADDR, 16);
-        if (!fpga0_adr)
-                return -ENOMEM;
-
-        fpga0_reg = readb(fpga0_adr);
-        iounmap(fpga0_adr);
-
-        if (EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&
-                        !EBONY_FLASH_SEL(fpga0_reg))
-                small_flash_base = EBONY_SMALL_FLASH_HIGH2;
-        else if (EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&
-                        EBONY_FLASH_SEL(fpga0_reg))
-                small_flash_base = EBONY_SMALL_FLASH_HIGH1;
-        else if (!EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&
-                        !EBONY_FLASH_SEL(fpga0_reg))
-                small_flash_base = EBONY_SMALL_FLASH_LOW2;
-        else
-                small_flash_base = EBONY_SMALL_FLASH_LOW1;
-
-        if (EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&
-                        !EBONY_ONBRD_FLASH_EN(fpga0_reg))
-                large_flash_base = EBONY_LARGE_FLASH_LOW;
-        else
-                large_flash_base = EBONY_LARGE_FLASH_HIGH;
-
-        ebony_small_map.phys = small_flash_base;
-        ebony_small_map.virt = ioremap64(small_flash_base,
-                                         ebony_small_map.size);
-
-        if (!ebony_small_map.virt) {
-                printk("Failed to ioremap flash\n");
-                return -EIO;
-        }
-
-        simple_map_init(&ebony_small_map);
-
-        flash = do_map_probe("jedec_probe", &ebony_small_map);
-        if (flash) {
-                flash->owner = THIS_MODULE;
-                add_mtd_partitions(flash, ebony_small_partitions,
-                                        ARRAY_SIZE(ebony_small_partitions));
-        } else {
-                printk("map probe failed for flash\n");
-                iounmap(ebony_small_map.virt);
-                return -ENXIO;
-        }
-
-        ebony_large_map.phys = large_flash_base;
-        ebony_large_map.virt = ioremap64(large_flash_base,
-                                         ebony_large_map.size);
-
-        if (!ebony_large_map.virt) {
-                printk("Failed to ioremap flash\n");
-                iounmap(ebony_small_map.virt);
-                return -EIO;
-        }
-
-        simple_map_init(&ebony_large_map);
-
-        flash = do_map_probe("jedec_probe", &ebony_large_map);
-        if (flash) {
-                flash->owner = THIS_MODULE;
-                add_mtd_partitions(flash, ebony_large_partitions,
-                                        ARRAY_SIZE(ebony_large_partitions));
-        } else {
-                printk("map probe failed for flash\n");
-                iounmap(ebony_small_map.virt);
-                iounmap(ebony_large_map.virt);
-                return -ENXIO;
-        }
-
-        return 0;
-}
-
-static void __exit cleanup_ebony(void)
-{
-        if (flash) {
-                del_mtd_partitions(flash);
-                map_destroy(flash);
-        }
-
-        if (ebony_small_map.virt) {
-                iounmap(ebony_small_map.virt);
-                ebony_small_map.virt = NULL;
-        }
-
-        if (ebony_large_map.virt) {
-                iounmap(ebony_large_map.virt);
-                ebony_large_map.virt = NULL;
-        }
-}
-
-module_init(init_ebony);
-module_exit(cleanup_ebony);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Matt Porter <mporter@kernel.crashing.org>");
-MODULE_DESCRIPTION("MTD map and partitions for IBM 440GP Ebony boards");
diff --git a/drivers/mtd/maps/ocotea.c b/drivers/mtd/maps/ocotea.c
deleted file mode 100644
index 5522eac8c980..000000000000
--- a/drivers/mtd/maps/ocotea.c
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Mapping for Ocotea user flash
- *
- * Matt Porter <mporter@kernel.crashing.org>
- *
- * Copyright 2002-2004 MontaVista Software Inc.
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-#include <asm/io.h>
-#include <asm/ibm44x.h>
-#include <platforms/4xx/ocotea.h>
-
-static struct mtd_info *flash;
-
-static struct map_info ocotea_small_map = {
-        .name =         "Ocotea small flash",
-        .size =         OCOTEA_SMALL_FLASH_SIZE,
-        .buswidth =     1,
-};
-
-static struct map_info ocotea_large_map = {
-        .name =         "Ocotea large flash",
-        .size =         OCOTEA_LARGE_FLASH_SIZE,
-        .buswidth =     1,
-};
-
-static struct mtd_partition ocotea_small_partitions[] = {
-        {
-                .name =   "pibs",
-                .offset = 0x0,
-                .size =   0x100000,
-        }
-};
-
-static struct mtd_partition ocotea_large_partitions[] = {
-        {
-                .name =   "fs",
-                .offset = 0,
-                .size =   0x300000,
-        },
-        {
-                .name =   "firmware",
-                .offset = 0x300000,
-                .size =   0x100000,
-        }
-};
-
-int __init init_ocotea(void)
-{
-        u8 fpga0_reg;
-        u8 *fpga0_adr;
-        unsigned long long small_flash_base, large_flash_base;
-
-        fpga0_adr = ioremap64(OCOTEA_FPGA_ADDR, 16);
-        if (!fpga0_adr)
-                return -ENOMEM;
-
-        fpga0_reg = readb((unsigned long)fpga0_adr);
-        iounmap(fpga0_adr);
-
-        if (OCOTEA_BOOT_LARGE_FLASH(fpga0_reg)) {
-                small_flash_base = OCOTEA_SMALL_FLASH_HIGH;
-                large_flash_base = OCOTEA_LARGE_FLASH_LOW;
-        }
-        else {
-                small_flash_base = OCOTEA_SMALL_FLASH_LOW;
-                large_flash_base = OCOTEA_LARGE_FLASH_HIGH;
-        }
-
-        ocotea_small_map.phys = small_flash_base;
-        ocotea_small_map.virt = ioremap64(small_flash_base,
-                                         ocotea_small_map.size);
-
-        if (!ocotea_small_map.virt) {
-                printk("Failed to ioremap flash\n");
-                return -EIO;
-        }
-
-        simple_map_init(&ocotea_small_map);
-
-        flash = do_map_probe("map_rom", &ocotea_small_map);
-        if (flash) {
-                flash->owner = THIS_MODULE;
-                add_mtd_partitions(flash, ocotea_small_partitions,
-                                        ARRAY_SIZE(ocotea_small_partitions));
-        } else {
-                printk("map probe failed for flash\n");
-                iounmap(ocotea_small_map.virt);
-                return -ENXIO;
-        }
-
-        ocotea_large_map.phys = large_flash_base;
-        ocotea_large_map.virt = ioremap64(large_flash_base,
-                                         ocotea_large_map.size);
-
-        if (!ocotea_large_map.virt) {
-                printk("Failed to ioremap flash\n");
-                iounmap(ocotea_small_map.virt);
-                return -EIO;
-        }
-
-        simple_map_init(&ocotea_large_map);
-
-        flash = do_map_probe("cfi_probe", &ocotea_large_map);
-        if (flash) {
-                flash->owner = THIS_MODULE;
-                add_mtd_partitions(flash, ocotea_large_partitions,
-                                        ARRAY_SIZE(ocotea_large_partitions));
-        } else {
-                printk("map probe failed for flash\n");
-                iounmap(ocotea_small_map.virt);
-                iounmap(ocotea_large_map.virt);
-                return -ENXIO;
-        }
-
-        return 0;
-}
-
-static void __exit cleanup_ocotea(void)
-{
-        if (flash) {
-                del_mtd_partitions(flash);
-                map_destroy(flash);
-        }
-
-        if (ocotea_small_map.virt) {
-                iounmap((void *)ocotea_small_map.virt);
-                ocotea_small_map.virt = 0;
-        }
-
-        if (ocotea_large_map.virt) {
-                iounmap((void *)ocotea_large_map.virt);
-                ocotea_large_map.virt = 0;
-        }
-}
-
-module_init(init_ocotea);
-module_exit(cleanup_ocotea);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Matt Porter <mporter@kernel.crashing.org>");
-MODULE_DESCRIPTION("MTD map and partitions for IBM 440GX Ocotea boards");
diff --git a/drivers/mtd/maps/omap-toto-flash.c b/drivers/mtd/maps/omap-toto-flash.c
deleted file mode 100644
index 0a60ebbc2175..000000000000
--- a/drivers/mtd/maps/omap-toto-flash.c
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * NOR Flash memory access on TI Toto board
- *
- * jzhang@ti.com (C) 2003 Texas Instruments.
- *
- *  (C) 2002 MontVista Software, Inc.
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-
-#include <asm/hardware.h>
-#include <asm/io.h>
-
-
-#ifndef CONFIG_ARCH_OMAP
-#error This is for OMAP architecture only
-#endif
-
-//these lines need be moved to a hardware header file
-#define OMAP_TOTO_FLASH_BASE 0xd8000000
-#define OMAP_TOTO_FLASH_SIZE 0x80000
-
-static struct map_info omap_toto_map_flash = {
-        .name =         "OMAP Toto flash",
-        .bankwidth =    2,
-        .virt =         (void __iomem *)OMAP_TOTO_FLASH_BASE,
-};
-
-
-static struct mtd_partition toto_flash_partitions[] = {
-        {
-                .name =         "BootLoader",
-                .size =         0x00040000,     /* hopefully u-boot will stay 128k + 128*/
-                .offset =       0,
-                .mask_flags =   MTD_WRITEABLE,  /* force read-only */
-        }, {
-                .name =         "ReservedSpace",
-                .size =         0x00030000,
-                .offset =       MTDPART_OFS_APPEND,
-                //mask_flags:   MTD_WRITEABLE,  /* force read-only */
-        }, {
-                .name =         "EnvArea",      /* bottom 64KiB for env vars */
-                .size =         MTDPART_SIZ_FULL,
-                .offset =       MTDPART_OFS_APPEND,
-        }
-};
-
-static struct mtd_partition *parsed_parts;
-
-static struct mtd_info *flash_mtd;
-
-static int __init init_flash (void)
-{
-
-        struct mtd_partition *parts;
-        int nb_parts = 0;
-        int parsed_nr_parts = 0;
-        const char *part_type;
-
-        /*
-         * Static partition definition selection
-         */
-        part_type = "static";
-
-        parts = toto_flash_partitions;
-        nb_parts = ARRAY_SIZE(toto_flash_partitions);
-        omap_toto_map_flash.size = OMAP_TOTO_FLASH_SIZE;
-        omap_toto_map_flash.phys = virt_to_phys(OMAP_TOTO_FLASH_BASE);
-
-        simple_map_init(&omap_toto_map_flash);
-        /*
-         * Now let's probe for the actual flash.  Do it here since
-         * specific machine settings might have been set above.
-         */
-        printk(KERN_NOTICE "OMAP toto flash: probing %d-bit flash bus\n",
-                omap_toto_map_flash.bankwidth*8);
-        flash_mtd = do_map_probe("jedec_probe", &omap_toto_map_flash);
-        if (!flash_mtd)
-                return -ENXIO;
-
-        if (parsed_nr_parts > 0) {
-                parts = parsed_parts;
-                nb_parts = parsed_nr_parts;
-        }
-
-        if (nb_parts == 0) {
-                printk(KERN_NOTICE "OMAP toto flash: no partition info available,"
-                        "registering whole flash at once\n");
-                if (add_mtd_device(flash_mtd)){
-            return -ENXIO;
-        }
-        } else {
-                printk(KERN_NOTICE "Using %s partition definition\n",
-                        part_type);
-                return add_mtd_partitions(flash_mtd, parts, nb_parts);
-        }
-        return 0;
-}
-
-int __init omap_toto_mtd_init(void)
-{
-        int status;
-
-        if (status = init_flash()) {
-                printk(KERN_ERR "OMAP Toto Flash: unable to init map for toto flash\n");
-        }
-    return status;
-}
-
-static void  __exit omap_toto_mtd_cleanup(void)
-{
-        if (flash_mtd) {
-                del_mtd_partitions(flash_mtd);
-                map_destroy(flash_mtd);
-                kfree(parsed_parts);
-        }
-}
-
-module_init(omap_toto_mtd_init);
-module_exit(omap_toto_mtd_cleanup);
-
-MODULE_AUTHOR("Jian Zhang");
-MODULE_DESCRIPTION("OMAP Toto board map driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/maps/pci.c b/drivers/mtd/maps/pci.c
index 5c6a25c90380..48f4cf5cb9d1 100644
--- a/drivers/mtd/maps/pci.c
+++ b/drivers/mtd/maps/pci.c
@@ -203,15 +203,8 @@ intel_dc21285_init(struct pci_dev *dev, struct map_pci_info *map)
                  * not enabled, should we be allocating a new resource for it
                  * or simply enabling it?
                  */
-                if (!(pci_resource_flags(dev, PCI_ROM_RESOURCE) &
-                                    IORESOURCE_ROM_ENABLE)) {
-                        u32 val;
-                        pci_resource_flags(dev, PCI_ROM_RESOURCE) |= IORESOURCE_ROM_ENABLE;
-                        pci_read_config_dword(dev, PCI_ROM_ADDRESS, &val);
-                        val |= PCI_ROM_ADDRESS_ENABLE;
-                        pci_write_config_dword(dev, PCI_ROM_ADDRESS, val);
-                        printk("%s: enabling expansion ROM\n", pci_name(dev));
-                }
+                pci_enable_rom(dev);
+                printk("%s: enabling expansion ROM\n", pci_name(dev));
         }
 
         if (!len || !base)
@@ -232,18 +225,13 @@ intel_dc21285_init(struct pci_dev *dev, struct map_pci_info *map)
 static void
 intel_dc21285_exit(struct pci_dev *dev, struct map_pci_info *map)
 {
-        u32 val;
-
         if (map->base)
                 iounmap(map->base);
 
         /*
          * We need to undo the PCI BAR2/PCI ROM BAR address alteration.
          */
-        pci_resource_flags(dev, PCI_ROM_RESOURCE) &= ~IORESOURCE_ROM_ENABLE;
-        pci_read_config_dword(dev, PCI_ROM_ADDRESS, &val);
-        val &= ~PCI_ROM_ADDRESS_ENABLE;
-        pci_write_config_dword(dev, PCI_ROM_ADDRESS, val);
+        pci_disable_rom(dev);
 }
 
 static unsigned long
diff --git a/drivers/mtd/maps/physmap_of.c b/drivers/mtd/maps/physmap_of.c
index 49acd4171893..5fcfec034a94 100644
--- a/drivers/mtd/maps/physmap_of.c
+++ b/drivers/mtd/maps/physmap_of.c
@@ -230,8 +230,7 @@ static int __devinit of_flash_probe(struct of_device *dev,
 
 #ifdef CONFIG_MTD_OF_PARTS
         if (err == 0) {
-                err = of_mtd_parse_partitions(&dev->dev, info->mtd,
-                                              dp, &info->parts);
+                err = of_mtd_parse_partitions(&dev->dev, dp, &info->parts);
                 if (err < 0)
                         return err;
         }
diff --git a/drivers/mtd/maps/walnut.c b/drivers/mtd/maps/walnut.c
deleted file mode 100644
index e243476c8171..000000000000
--- a/drivers/mtd/maps/walnut.c
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Mapping for Walnut flash
- * (used ebony.c as a "framework")
- *
- * Heikki Lindholm <holindho@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.
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/map.h>
-#include <linux/mtd/partitions.h>
-#include <asm/io.h>
-#include <asm/ibm4xx.h>
-#include <platforms/4xx/walnut.h>
-
-/* these should be in platforms/4xx/walnut.h ? */
-#define WALNUT_FLASH_ONBD_N(x)          (x & 0x02)
-#define WALNUT_FLASH_SRAM_SEL(x)        (x & 0x01)
-#define WALNUT_FLASH_LOW                0xFFF00000
-#define WALNUT_FLASH_HIGH               0xFFF80000
-#define WALNUT_FLASH_SIZE               0x80000
-
-static struct mtd_info *flash;
-
-static struct map_info walnut_map = {
-        .name =         "Walnut flash",
-        .size =         WALNUT_FLASH_SIZE,
-        .bankwidth =    1,
-};
-
-/* Actually, OpenBIOS is the last 128 KiB of the flash - better
- * partitioning could be made */
-static struct mtd_partition walnut_partitions[] = {
-        {
-                .name =   "OpenBIOS",
-                .offset = 0x0,
-                .size =   WALNUT_FLASH_SIZE,
-                /*.mask_flags = MTD_WRITEABLE, */ /* force read-only */
-        }
-};
-
-int __init init_walnut(void)
-{
-        u8 fpga_brds1;
-        void *fpga_brds1_adr;
-        void *fpga_status_adr;
-        unsigned long flash_base;
-
-        /* this should already be mapped (platform/4xx/walnut.c) */
-        fpga_status_adr = ioremap(WALNUT_FPGA_BASE, 8);
-        if (!fpga_status_adr)
-                return -ENOMEM;
-
-        fpga_brds1_adr = fpga_status_adr+5;
-        fpga_brds1 = readb(fpga_brds1_adr);
-        /* iounmap(fpga_status_adr); */
-
-        if (WALNUT_FLASH_ONBD_N(fpga_brds1)) {
-                printk("The on-board flash is disabled (U79 sw 5)!");
-                iounmap(fpga_status_adr);
-                return -EIO;
-        }
-        if (WALNUT_FLASH_SRAM_SEL(fpga_brds1))
-                flash_base = WALNUT_FLASH_LOW;
-        else
-                flash_base = WALNUT_FLASH_HIGH;
-
-        walnut_map.phys = flash_base;
-        walnut_map.virt =
-                (void __iomem *)ioremap(flash_base, walnut_map.size);
-
-        if (!walnut_map.virt) {
-                printk("Failed to ioremap flash.\n");
-                iounmap(fpga_status_adr);
-                return -EIO;
-        }
-
-        simple_map_init(&walnut_map);
-
-        flash = do_map_probe("jedec_probe", &walnut_map);
-        if (flash) {
-                flash->owner = THIS_MODULE;
-                add_mtd_partitions(flash, walnut_partitions,
-                                        ARRAY_SIZE(walnut_partitions));
-        } else {
-                printk("map probe failed for flash\n");
-                iounmap(fpga_status_adr);
-                return -ENXIO;
-        }
-
-        iounmap(fpga_status_adr);
-        return 0;
-}
-
-static void __exit cleanup_walnut(void)
-{
-        if (flash) {
-                del_mtd_partitions(flash);
-                map_destroy(flash);
-        }
-
-        if (walnut_map.virt) {
-                iounmap((void *)walnut_map.virt);
-                walnut_map.virt = 0;
-        }
-}
-
-module_init(init_walnut);
-module_exit(cleanup_walnut);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Heikki Lindholm <holindho@infradead.org>");
-MODULE_DESCRIPTION("MTD map and partitions for IBM 405GP Walnut boards");
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index 1c74762dec89..963840e9b5bf 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -348,7 +348,7 @@ static void mtdchar_erase_callback (struct erase_info *instr)
         wake_up((wait_queue_head_t *)instr->priv);
 }
 
-#if defined(CONFIG_MTD_OTP) || defined(CONFIG_MTD_ONENAND_OTP)
+#ifdef CONFIG_HAVE_MTD_OTP
 static int otp_select_filemode(struct mtd_file_info *mfi, int mode)
 {
         struct mtd_info *mtd = mfi->mtd;
@@ -665,7 +665,7 @@ static int mtd_ioctl(struct inode *inode, struct file *file,
                 break;
         }
 
-#if defined(CONFIG_MTD_OTP) || defined(CONFIG_MTD_ONENAND_OTP)
+#ifdef CONFIG_HAVE_MTD_OTP
         case OTPSELECT:
         {
                 int mode;
diff --git a/drivers/mtd/mtdconcat.c b/drivers/mtd/mtdconcat.c
index 2972a5edb73d..789842d0e6f2 100644
--- a/drivers/mtd/mtdconcat.c
+++ b/drivers/mtd/mtdconcat.c
@@ -444,7 +444,7 @@ static int concat_erase(struct mtd_info *mtd, struct erase_info *instr)
                         return -EINVAL;
         }
 
-        instr->fail_addr = 0xffffffff;
+        instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
 
         /* make a local copy of instr to avoid modifying the caller's struct */
         erase = kmalloc(sizeof (struct erase_info), GFP_KERNEL);
@@ -493,7 +493,7 @@ static int concat_erase(struct mtd_info *mtd, struct erase_info *instr)
                         /* sanity check: should never happen since
                          * block alignment has been checked above */
                         BUG_ON(err == -EINVAL);
-                        if (erase->fail_addr != 0xffffffff)
+                        if (erase->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
                                 instr->fail_addr = erase->fail_addr + offset;
                         break;
                 }
diff --git a/drivers/mtd/mtdoops.c b/drivers/mtd/mtdoops.c
index 5a680e1e61f1..aebb3b27edbd 100644
--- a/drivers/mtd/mtdoops.c
+++ b/drivers/mtd/mtdoops.c
@@ -33,6 +33,7 @@
 #include <linux/interrupt.h>
 #include <linux/mtd/mtd.h>
 
+#define MTDOOPS_KERNMSG_MAGIC 0x5d005d00
 #define OOPS_PAGE_SIZE 4096
 
 static struct mtdoops_context {
@@ -99,7 +100,7 @@ static void mtdoops_inc_counter(struct mtdoops_context *cxt)
         int ret;
 
         cxt->nextpage++;
-        if (cxt->nextpage > cxt->oops_pages)
+        if (cxt->nextpage >= cxt->oops_pages)
                 cxt->nextpage = 0;
         cxt->nextcount++;
         if (cxt->nextcount == 0xffffffff)
@@ -141,7 +142,7 @@ static void mtdoops_workfunc_erase(struct work_struct *work)
         mod = (cxt->nextpage * OOPS_PAGE_SIZE) % mtd->erasesize;
         if (mod != 0) {
                 cxt->nextpage = cxt->nextpage + ((mtd->erasesize - mod) / OOPS_PAGE_SIZE);
-                if (cxt->nextpage > cxt->oops_pages)
+                if (cxt->nextpage >= cxt->oops_pages)
                         cxt->nextpage = 0;
         }
 
@@ -158,7 +159,7 @@ badblock:
                                 cxt->nextpage * OOPS_PAGE_SIZE);
                 i++;
                 cxt->nextpage = cxt->nextpage + (mtd->erasesize / OOPS_PAGE_SIZE);
-                if (cxt->nextpage > cxt->oops_pages)
+                if (cxt->nextpage >= cxt->oops_pages)
                         cxt->nextpage = 0;
                 if (i == (cxt->oops_pages / (mtd->erasesize / OOPS_PAGE_SIZE))) {
                         printk(KERN_ERR "mtdoops: All blocks bad!\n");
@@ -224,40 +225,40 @@ static void find_next_position(struct mtdoops_context *cxt)
 {
         struct mtd_info *mtd = cxt->mtd;
         int ret, page, maxpos = 0;
-        u32 count, maxcount = 0xffffffff;
+        u32 count[2], maxcount = 0xffffffff;
         size_t retlen;
 
         for (page = 0; page < cxt->oops_pages; page++) {
-                ret = mtd->read(mtd, page * OOPS_PAGE_SIZE, 4, &retlen, (u_char *) &count);
-                if ((retlen != 4) || ((ret < 0) && (ret != -EUCLEAN))) {
-                        printk(KERN_ERR "mtdoops: Read failure at %d (%td of 4 read)"
+                ret = mtd->read(mtd, page * OOPS_PAGE_SIZE, 8, &retlen, (u_char *) &count[0]);
+                if ((retlen != 8) || ((ret < 0) && (ret != -EUCLEAN))) {
+                        printk(KERN_ERR "mtdoops: Read failure at %d (%td of 8 read)"
                                 ", err %d.\n", page * OOPS_PAGE_SIZE, retlen, ret);
                         continue;
                 }
 
-                if (count == 0xffffffff)
+                if (count[1] != MTDOOPS_KERNMSG_MAGIC)
+                        continue;
+                if (count[0] == 0xffffffff)
                         continue;
                 if (maxcount == 0xffffffff) {
-                        maxcount = count;
+                        maxcount = count[0];
                         maxpos = page;
-                } else if ((count < 0x40000000) && (maxcount > 0xc0000000)) {
-                        maxcount = count;
+                } else if ((count[0] < 0x40000000) && (maxcount > 0xc0000000)) {
+                        maxcount = count[0];
                         maxpos = page;
-                } else if ((count > maxcount) && (count < 0xc0000000)) {
-                        maxcount = count;
+                } else if ((count[0] > maxcount) && (count[0] < 0xc0000000)) {
+                        maxcount = count[0];
                         maxpos = page;
-                } else if ((count > maxcount) && (count > 0xc0000000)
+                } else if ((count[0] > maxcount) && (count[0] > 0xc0000000)
                                         && (maxcount > 0x80000000)) {
-                        maxcount = count;
+                        maxcount = count[0];
                         maxpos = page;
                 }
         }
         if (maxcount == 0xffffffff) {
                 cxt->nextpage = 0;
                 cxt->nextcount = 1;
-                cxt->ready = 1;
-                printk(KERN_DEBUG "mtdoops: Ready %d, %d (first init)\n",
-                                cxt->nextpage, cxt->nextcount);
+                schedule_work(&cxt->work_erase);
                 return;
         }
 
@@ -358,8 +359,9 @@ mtdoops_console_write(struct console *co, const char *s, unsigned int count)
 
         if (cxt->writecount == 0) {
                 u32 *stamp = cxt->oops_buf;
-                *stamp = cxt->nextcount;
-                cxt->writecount = 4;
+                *stamp++ = cxt->nextcount;
+                *stamp = MTDOOPS_KERNMSG_MAGIC;
+                cxt->writecount = 8;
         }
 
         if ((count + cxt->writecount) > OOPS_PAGE_SIZE)
diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c
index 9a06dc93ee0d..3728913fa5fa 100644
--- a/drivers/mtd/mtdpart.c
+++ b/drivers/mtd/mtdpart.c
@@ -214,7 +214,7 @@ static int part_erase(struct mtd_info *mtd, struct erase_info *instr)
         instr->addr += part->offset;
         ret = part->master->erase(part->master, instr);
         if (ret) {
-                if (instr->fail_addr != 0xffffffff)
+                if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
                         instr->fail_addr -= part->offset;
                 instr->addr -= part->offset;
         }
@@ -226,7 +226,7 @@ void mtd_erase_callback(struct erase_info *instr)
         if (instr->mtd->erase == part_erase) {
                 struct mtd_part *part = PART(instr->mtd);
 
-                if (instr->fail_addr != 0xffffffff)
+                if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
                         instr->fail_addr -= part->offset;
                 instr->addr -= part->offset;
         }
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index 41f361c49b32..1c2e9450d663 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -56,6 +56,12 @@ config MTD_NAND_H1900
         help
           This enables the driver for the iPAQ h1900 flash.
 
+config MTD_NAND_GPIO
+        tristate "GPIO NAND Flash driver"
+        depends on GENERIC_GPIO && ARM
+        help
+          This enables a GPIO based NAND flash driver.
+
 config MTD_NAND_SPIA
         tristate "NAND Flash device on SPIA board"
         depends on ARCH_P720T
@@ -68,12 +74,6 @@ config MTD_NAND_AMS_DELTA
         help
           Support for NAND flash on Amstrad E3 (Delta).
 
-config MTD_NAND_TOTO
-        tristate "NAND Flash device on TOTO board"
-        depends on ARCH_OMAP && BROKEN
-        help
-          Support for NAND flash on Texas Instruments Toto platform.
-
 config MTD_NAND_TS7250
         tristate "NAND Flash device on TS-7250 board"
         depends on MACH_TS72XX
@@ -163,13 +163,6 @@ config MTD_NAND_S3C2410_HWECC
           incorrect ECC generation, and if using these, the default of
           software ECC is preferable.
 
-config MTD_NAND_NDFC
-        tristate "NDFC NanD Flash Controller"
-        depends on 4xx && !PPC_MERGE
-        select MTD_NAND_ECC_SMC
-        help
-         NDFC Nand Flash Controllers are integrated in IBM/AMCC's 4xx SoCs
-
 config MTD_NAND_S3C2410_CLKSTOP
         bool "S3C2410 NAND IDLE clock stop"
         depends on MTD_NAND_S3C2410
@@ -340,6 +333,13 @@ config MTD_NAND_PXA3xx
           This enables the driver for the NAND flash device found on
           PXA3xx processors
 
+config MTD_NAND_PXA3xx_BUILTIN
+        bool "Use builtin definitions for some NAND chips (deprecated)"
+        depends on MTD_NAND_PXA3xx
+        help
+          This enables builtin definitions for some NAND chips. This
+          is deprecated in favor of platform specific data.
+
 config MTD_NAND_CM_X270
         tristate "Support for NAND Flash on CM-X270 modules"
         depends on MTD_NAND && MACH_ARMCORE
@@ -400,10 +400,24 @@ config MTD_NAND_FSL_ELBC
 
 config MTD_NAND_FSL_UPM
         tristate "Support for NAND on Freescale UPM"
-        depends on MTD_NAND && OF_GPIO && (PPC_83xx || PPC_85xx)
+        depends on MTD_NAND && (PPC_83xx || PPC_85xx)
         select FSL_LBC
         help
           Enables support for NAND Flash chips wired onto Freescale PowerPC
           processor localbus with User-Programmable Machine support.
 
+config MTD_NAND_MXC
+        tristate "MXC NAND support"
+        depends on ARCH_MX2
+        help
+          This enables the driver for the NAND flash controller on the
+          MXC processors.
+
+config MTD_NAND_SH_FLCTL
+        tristate "Support for NAND on Renesas SuperH FLCTL"
+        depends on MTD_NAND && SUPERH && CPU_SUBTYPE_SH7723
+        help
+          Several Renesas SuperH CPU has FLCTL. This option enables support
+          for NAND Flash using FLCTL. This driver support SH7723.
+
 endif # MTD_NAND
diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile
index b786c5da82da..b661586afbfc 100644
--- a/drivers/mtd/nand/Makefile
+++ b/drivers/mtd/nand/Makefile
@@ -8,7 +8,6 @@ obj-$(CONFIG_MTD_NAND_IDS)		+= nand_ids.o
 obj-$(CONFIG_MTD_NAND_CAFE)             += cafe_nand.o
 obj-$(CONFIG_MTD_NAND_SPIA)             += spia.o
 obj-$(CONFIG_MTD_NAND_AMS_DELTA)        += ams-delta.o
-obj-$(CONFIG_MTD_NAND_TOTO)             += toto.o
 obj-$(CONFIG_MTD_NAND_AUTCPU12)         += autcpu12.o
 obj-$(CONFIG_MTD_NAND_EDB7312)          += edb7312.o
 obj-$(CONFIG_MTD_NAND_AU1550)           += au1550nd.o
@@ -24,6 +23,7 @@ obj-$(CONFIG_MTD_NAND_NANDSIM)		+= nandsim.o
 obj-$(CONFIG_MTD_NAND_CS553X)           += cs553x_nand.o
 obj-$(CONFIG_MTD_NAND_NDFC)             += ndfc.o
 obj-$(CONFIG_MTD_NAND_ATMEL)            += atmel_nand.o
+obj-$(CONFIG_MTD_NAND_GPIO)             += gpio.o
 obj-$(CONFIG_MTD_NAND_CM_X270)          += cmx270_nand.o
 obj-$(CONFIG_MTD_NAND_BASLER_EXCITE)    += excite_nandflash.o
 obj-$(CONFIG_MTD_NAND_PXA3xx)           += pxa3xx_nand.o
@@ -34,5 +34,7 @@ obj-$(CONFIG_MTD_NAND_PASEMI)		+= pasemi_nand.o
 obj-$(CONFIG_MTD_NAND_ORION)            += orion_nand.o
 obj-$(CONFIG_MTD_NAND_FSL_ELBC)         += fsl_elbc_nand.o
 obj-$(CONFIG_MTD_NAND_FSL_UPM)          += fsl_upm.o
+obj-$(CONFIG_MTD_NAND_SH_FLCTL)         += sh_flctl.o
+obj-$(CONFIG_MTD_NAND_MXC)              += mxc_nand.o
 
 nand-objs := nand_base.o nand_bbt.o
diff --git a/drivers/mtd/nand/atmel_nand.c b/drivers/mtd/nand/atmel_nand.c
index 3387e0d5076b..c98c1570a40b 100644
--- a/drivers/mtd/nand/atmel_nand.c
+++ b/drivers/mtd/nand/atmel_nand.c
@@ -174,48 +174,6 @@ static void atmel_write_buf16(struct mtd_info *mtd, const u8 *buf, int len)
 }
 
 /*
- * write oob for small pages
- */
-static int atmel_nand_write_oob_512(struct mtd_info *mtd,
-                struct nand_chip *chip, int page)
-{
-        int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
-        int eccsize = chip->ecc.size, length = mtd->oobsize;
-        int len, pos, status = 0;
-        const uint8_t *bufpoi = chip->oob_poi;
-
-        pos = eccsize + chunk;
-
-        chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page);
-        len = min_t(int, length, chunk);
-        chip->write_buf(mtd, bufpoi, len);
-        bufpoi += len;
-        length -= len;
-        if (length > 0)
-                chip->write_buf(mtd, bufpoi, length);
-
-        chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
-        status = chip->waitfunc(mtd, chip);
-
-        return status & NAND_STATUS_FAIL ? -EIO : 0;
-
-}
-
-/*
- * read oob for small pages
- */
-static int atmel_nand_read_oob_512(struct mtd_info *mtd,
-                struct nand_chip *chip, int page, int sndcmd)
-{
-        if (sndcmd) {
-                chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
-                sndcmd = 0;
-        }
-        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
-        return sndcmd;
-}
-
-/*
  * Calculate HW ECC
  *
  * function called after a write
@@ -235,14 +193,14 @@ static int atmel_nand_calculate(struct mtd_info *mtd,
         /* get the first 2 ECC bytes */
         ecc_value = ecc_readl(host->ecc, PR);
 
-        ecc_code[eccpos[0]] = ecc_value & 0xFF;
-        ecc_code[eccpos[1]] = (ecc_value >> 8) & 0xFF;
+        ecc_code[0] = ecc_value & 0xFF;
+        ecc_code[1] = (ecc_value >> 8) & 0xFF;
 
         /* get the last 2 ECC bytes */
         ecc_value = ecc_readl(host->ecc, NPR) & ATMEL_ECC_NPARITY;
 
-        ecc_code[eccpos[2]] = ecc_value & 0xFF;
-        ecc_code[eccpos[3]] = (ecc_value >> 8) & 0xFF;
+        ecc_code[2] = ecc_value & 0xFF;
+        ecc_code[3] = (ecc_value >> 8) & 0xFF;
 
         return 0;
 }
@@ -476,14 +434,12 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
                         res = -EIO;
                         goto err_ecc_ioremap;
                 }
-                nand_chip->ecc.mode = NAND_ECC_HW_SYNDROME;
+                nand_chip->ecc.mode = NAND_ECC_HW;
                 nand_chip->ecc.calculate = atmel_nand_calculate;
                 nand_chip->ecc.correct = atmel_nand_correct;
                 nand_chip->ecc.hwctl = atmel_nand_hwctl;
                 nand_chip->ecc.read_page = atmel_nand_read_page;
                 nand_chip->ecc.bytes = 4;
-                nand_chip->ecc.prepad = 0;
-                nand_chip->ecc.postpad = 0;
         }
 
         nand_chip->chip_delay = 20;             /* 20us command delay time */
@@ -514,7 +470,7 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
                 goto err_scan_ident;
         }
 
-        if (nand_chip->ecc.mode == NAND_ECC_HW_SYNDROME) {
+        if (nand_chip->ecc.mode == NAND_ECC_HW) {
                 /* ECC is calculated for the whole page (1 step) */
                 nand_chip->ecc.size = mtd->writesize;
 
@@ -522,8 +478,6 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
                 switch (mtd->writesize) {
                 case 512:
                         nand_chip->ecc.layout = &atmel_oobinfo_small;
-                        nand_chip->ecc.read_oob = atmel_nand_read_oob_512;
-                        nand_chip->ecc.write_oob = atmel_nand_write_oob_512;
                         ecc_writel(host->ecc, MR, ATMEL_ECC_PAGESIZE_528);
                         break;
                 case 1024:
diff --git a/drivers/mtd/nand/cs553x_nand.c b/drivers/mtd/nand/cs553x_nand.c
index 3370a800fd36..9f1b451005ca 100644
--- a/drivers/mtd/nand/cs553x_nand.c
+++ b/drivers/mtd/nand/cs553x_nand.c
@@ -289,8 +289,10 @@ static int __init cs553x_init(void)
         int i;
         uint64_t val;
 
+#ifdef CONFIG_MTD_PARTITIONS
         int mtd_parts_nb = 0;
         struct mtd_partition *mtd_parts = NULL;
+#endif
 
         /* If the CPU isn't a Geode GX or LX, abort */
         if (!is_geode())
diff --git a/drivers/mtd/nand/fsl_elbc_nand.c b/drivers/mtd/nand/fsl_elbc_nand.c
index 98ad3cefcaf4..4aa5bd6158da 100644
--- a/drivers/mtd/nand/fsl_elbc_nand.c
+++ b/drivers/mtd/nand/fsl_elbc_nand.c
@@ -918,8 +918,7 @@ static int __devinit fsl_elbc_chip_probe(struct fsl_elbc_ctrl *ctrl,
 
 #ifdef CONFIG_MTD_OF_PARTS
         if (ret == 0) {
-                ret = of_mtd_parse_partitions(priv->dev, &priv->mtd,
-                                              node, &parts);
+                ret = of_mtd_parse_partitions(priv->dev, node, &parts);
                 if (ret < 0)
                         goto err;
         }
diff --git a/drivers/mtd/nand/fsl_upm.c b/drivers/mtd/nand/fsl_upm.c
index 1ebfd87f00b4..024e3fffd4bb 100644
--- a/drivers/mtd/nand/fsl_upm.c
+++ b/drivers/mtd/nand/fsl_upm.c
@@ -13,6 +13,7 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/delay.h>
 #include <linux/mtd/nand.h>
 #include <linux/mtd/nand_ecc.h>
 #include <linux/mtd/partitions.h>
@@ -36,8 +37,6 @@ struct fsl_upm_nand {
         uint8_t upm_cmd_offset;
         void __iomem *io_base;
         int rnb_gpio;
-        const uint32_t *wait_pattern;
-        const uint32_t *wait_write;
         int chip_delay;
 };
 
@@ -61,10 +60,11 @@ static void fun_wait_rnb(struct fsl_upm_nand *fun)
         if (fun->rnb_gpio >= 0) {
                 while (--cnt && !fun_chip_ready(&fun->mtd))
                         cpu_relax();
+                if (!cnt)
+                        dev_err(fun->dev, "tired waiting for RNB\n");
+        } else {
+                ndelay(100);
         }
-
-        if (!cnt)
-                dev_err(fun->dev, "tired waiting for RNB\n");
 }
 
 static void fun_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
@@ -89,8 +89,7 @@ static void fun_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 
         fsl_upm_run_pattern(&fun->upm, fun->io_base, cmd);
 
-        if (fun->wait_pattern)
-                fun_wait_rnb(fun);
+        fun_wait_rnb(fun);
 }
 
 static uint8_t fun_read_byte(struct mtd_info *mtd)
@@ -116,14 +115,16 @@ static void fun_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 
         for (i = 0; i < len; i++) {
                 out_8(fun->chip.IO_ADDR_W, buf[i]);
-                if (fun->wait_write)
-                        fun_wait_rnb(fun);
+                fun_wait_rnb(fun);
         }
 }
 
-static int __devinit fun_chip_init(struct fsl_upm_nand *fun)
+static int __devinit fun_chip_init(struct fsl_upm_nand *fun,
+                                   const struct device_node *upm_np,
+                                   const struct resource *io_res)
 {
         int ret;
+        struct device_node *flash_np;
 #ifdef CONFIG_MTD_PARTITIONS
         static const char *part_types[] = { "cmdlinepart", NULL, };
 #endif
@@ -143,18 +144,37 @@ static int __devinit fun_chip_init(struct fsl_upm_nand *fun)
         fun->mtd.priv = &fun->chip;
         fun->mtd.owner = THIS_MODULE;
 
+        flash_np = of_get_next_child(upm_np, NULL);
+        if (!flash_np)
+                return -ENODEV;
+
+        fun->mtd.name = kasprintf(GFP_KERNEL, "%x.%s", io_res->start,
+                                  flash_np->name);
+        if (!fun->mtd.name) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
         ret = nand_scan(&fun->mtd, 1);
         if (ret)
-                return ret;
-
-        fun->mtd.name = fun->dev->bus_id;
+                goto err;
 
 #ifdef CONFIG_MTD_PARTITIONS
         ret = parse_mtd_partitions(&fun->mtd, part_types, &fun->parts, 0);
+
+#ifdef CONFIG_MTD_OF_PARTS
+        if (ret == 0)
+                ret = of_mtd_parse_partitions(fun->dev, &fun->mtd,
+                                              flash_np, &fun->parts);
+#endif
         if (ret > 0)
-                return add_mtd_partitions(&fun->mtd, fun->parts, ret);
+                ret = add_mtd_partitions(&fun->mtd, fun->parts, ret);
+        else
 #endif
-        return add_mtd_device(&fun->mtd);
+                ret = add_mtd_device(&fun->mtd);
+err:
+        of_node_put(flash_np);
+        return ret;
 }
 
 static int __devinit fun_probe(struct of_device *ofdev,
@@ -211,6 +231,12 @@ static int __devinit fun_probe(struct of_device *ofdev,
                 goto err2;
         }
 
+        prop = of_get_property(ofdev->node, "chip-delay", NULL);
+        if (prop)
+                fun->chip_delay = *prop;
+        else
+                fun->chip_delay = 50;
+
         fun->io_base = devm_ioremap_nocache(&ofdev->dev, io_res.start,
                                           io_res.end - io_res.start + 1);
         if (!fun->io_base) {
@@ -220,17 +246,8 @@ static int __devinit fun_probe(struct of_device *ofdev,
 
         fun->dev = &ofdev->dev;
         fun->last_ctrl = NAND_CLE;
-        fun->wait_pattern = of_get_property(ofdev->node, "fsl,wait-pattern",
-                                            NULL);
-        fun->wait_write = of_get_property(ofdev->node, "fsl,wait-write", NULL);
-
-        prop = of_get_property(ofdev->node, "chip-delay", NULL);
-        if (prop)
-                fun->chip_delay = *prop;
-        else
-                fun->chip_delay = 50;
 
-        ret = fun_chip_init(fun);
+        ret = fun_chip_init(fun, ofdev->node, &io_res);
         if (ret)
                 goto err2;
 
@@ -251,6 +268,7 @@ static int __devexit fun_remove(struct of_device *ofdev)
         struct fsl_upm_nand *fun = dev_get_drvdata(&ofdev->dev);
 
         nand_release(&fun->mtd);
+        kfree(fun->mtd.name);
 
         if (fun->rnb_gpio >= 0)
                 gpio_free(fun->rnb_gpio);
diff --git a/drivers/mtd/nand/gpio.c b/drivers/mtd/nand/gpio.c
new file mode 100644
index 000000000000..8f902e75aa85
--- /dev/null
+++ b/drivers/mtd/nand/gpio.c
@@ -0,0 +1,375 @@
+/*
+ * drivers/mtd/nand/gpio.c
+ *
+ * Updated, and converted to generic GPIO based driver by Russell King.
+ *
+ * Written by Ben Dooks <ben@simtec.co.uk>
+ *   Based on 2.4 version by Mark Whittaker
+ *
+ * © 2004 Simtec Electronics
+ *
+ * Device driver for NAND connected via GPIO
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/io.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <linux/mtd/nand-gpio.h>
+
+struct gpiomtd {
+        void __iomem            *io_sync;
+        struct mtd_info         mtd_info;
+        struct nand_chip        nand_chip;
+        struct gpio_nand_platdata plat;
+};
+
+#define gpio_nand_getpriv(x) container_of(x, struct gpiomtd, mtd_info)
+
+
+#ifdef CONFIG_ARM
+/* gpio_nand_dosync()
+ *
+ * Make sure the GPIO state changes occur in-order with writes to NAND
+ * memory region.
+ * Needed on PXA due to bus-reordering within the SoC itself (see section on
+ * I/O ordering in PXA manual (section 2.3, p35)
+ */
+static void gpio_nand_dosync(struct gpiomtd *gpiomtd)
+{
+        unsigned long tmp;
+
+        if (gpiomtd->io_sync) {
+                /*
+                 * Linux memory barriers don't cater for what's required here.
+                 * What's required is what's here - a read from a separate
+                 * region with a dependency on that read.
+                 */
+                tmp = readl(gpiomtd->io_sync);
+                asm volatile("mov %1, %0\n" : "=r" (tmp) : "r" (tmp));
+        }
+}
+#else
+static inline void gpio_nand_dosync(struct gpiomtd *gpiomtd) {}
+#endif
+
+static void gpio_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
+{
+        struct gpiomtd *gpiomtd = gpio_nand_getpriv(mtd);
+
+        gpio_nand_dosync(gpiomtd);
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+                gpio_set_value(gpiomtd->plat.gpio_nce, !(ctrl & NAND_NCE));
+                gpio_set_value(gpiomtd->plat.gpio_cle, !!(ctrl & NAND_CLE));
+                gpio_set_value(gpiomtd->plat.gpio_ale, !!(ctrl & NAND_ALE));
+                gpio_nand_dosync(gpiomtd);
+        }
+        if (cmd == NAND_CMD_NONE)
+                return;
+
+        writeb(cmd, gpiomtd->nand_chip.IO_ADDR_W);
+        gpio_nand_dosync(gpiomtd);
+}
+
+static void gpio_nand_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
+{
+        struct nand_chip *this = mtd->priv;
+
+        writesb(this->IO_ADDR_W, buf, len);
+}
+
+static void gpio_nand_readbuf(struct mtd_info *mtd, u_char *buf, int len)
+{
+        struct nand_chip *this = mtd->priv;
+
+        readsb(this->IO_ADDR_R, buf, len);
+}
+
+static int gpio_nand_verifybuf(struct mtd_info *mtd, const u_char *buf, int len)
+{
+        struct nand_chip *this = mtd->priv;
+        unsigned char read, *p = (unsigned char *) buf;
+        int i, err = 0;
+
+        for (i = 0; i < len; i++) {
+                read = readb(this->IO_ADDR_R);
+                if (read != p[i]) {
+                        pr_debug("%s: err at %d (read %04x vs %04x)\n",
+                               __func__, i, read, p[i]);
+                        err = -EFAULT;
+                }
+        }
+        return err;
+}
+
+static void gpio_nand_writebuf16(struct mtd_info *mtd, const u_char *buf,
+                                 int len)
+{
+        struct nand_chip *this = mtd->priv;
+
+        if (IS_ALIGNED((unsigned long)buf, 2)) {
+                writesw(this->IO_ADDR_W, buf, len>>1);
+        } else {
+                int i;
+                unsigned short *ptr = (unsigned short *)buf;
+
+                for (i = 0; i < len; i += 2, ptr++)
+                        writew(*ptr, this->IO_ADDR_W);
+        }
+}
+
+static void gpio_nand_readbuf16(struct mtd_info *mtd, u_char *buf, int len)
+{
+        struct nand_chip *this = mtd->priv;
+
+        if (IS_ALIGNED((unsigned long)buf, 2)) {
+                readsw(this->IO_ADDR_R, buf, len>>1);
+        } else {
+                int i;
+                unsigned short *ptr = (unsigned short *)buf;
+
+                for (i = 0; i < len; i += 2, ptr++)
+                        *ptr = readw(this->IO_ADDR_R);
+        }
+}
+
+static int gpio_nand_verifybuf16(struct mtd_info *mtd, const u_char *buf,
+                                 int len)
+{
+        struct nand_chip *this = mtd->priv;
+        unsigned short read, *p = (unsigned short *) buf;
+        int i, err = 0;
+        len >>= 1;
+
+        for (i = 0; i < len; i++) {
+                read = readw(this->IO_ADDR_R);
+                if (read != p[i]) {
+                        pr_debug("%s: err at %d (read %04x vs %04x)\n",
+                               __func__, i, read, p[i]);
+                        err = -EFAULT;
+                }
+        }
+        return err;
+}
+
+
+static int gpio_nand_devready(struct mtd_info *mtd)
+{
+        struct gpiomtd *gpiomtd = gpio_nand_getpriv(mtd);
+        return gpio_get_value(gpiomtd->plat.gpio_rdy);
+}
+
+static int __devexit gpio_nand_remove(struct platform_device *dev)
+{
+        struct gpiomtd *gpiomtd = platform_get_drvdata(dev);
+        struct resource *res;
+
+        nand_release(&gpiomtd->mtd_info);
+
+        res = platform_get_resource(dev, IORESOURCE_MEM, 1);
+        iounmap(gpiomtd->io_sync);
+        if (res)
+                release_mem_region(res->start, res->end - res->start + 1);
+
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        iounmap(gpiomtd->nand_chip.IO_ADDR_R);
+        release_mem_region(res->start, res->end - res->start + 1);
+
+        if (gpio_is_valid(gpiomtd->plat.gpio_nwp))
+                gpio_set_value(gpiomtd->plat.gpio_nwp, 0);
+        gpio_set_value(gpiomtd->plat.gpio_nce, 1);
+
+        gpio_free(gpiomtd->plat.gpio_cle);
+        gpio_free(gpiomtd->plat.gpio_ale);
+        gpio_free(gpiomtd->plat.gpio_nce);
+        if (gpio_is_valid(gpiomtd->plat.gpio_nwp))
+                gpio_free(gpiomtd->plat.gpio_nwp);
+        gpio_free(gpiomtd->plat.gpio_rdy);
+
+        kfree(gpiomtd);
+
+        return 0;
+}
+
+static void __iomem *request_and_remap(struct resource *res, size_t size,
+                                        const char *name, int *err)
+{
+        void __iomem *ptr;
+
+        if (!request_mem_region(res->start, res->end - res->start + 1, name)) {
+                *err = -EBUSY;
+                return NULL;
+        }
+
+        ptr = ioremap(res->start, size);
+        if (!ptr) {
+                release_mem_region(res->start, res->end - res->start + 1);
+                *err = -ENOMEM;
+        }
+        return ptr;
+}
+
+static int __devinit gpio_nand_probe(struct platform_device *dev)
+{
+        struct gpiomtd *gpiomtd;
+        struct nand_chip *this;
+        struct resource *res0, *res1;
+        int ret;
+
+        if (!dev->dev.platform_data)
+                return -EINVAL;
+
+        res0 = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!res0)
+                return -EINVAL;
+
+        gpiomtd = kzalloc(sizeof(*gpiomtd), GFP_KERNEL);
+        if (gpiomtd == NULL) {
+                dev_err(&dev->dev, "failed to create NAND MTD\n");
+                return -ENOMEM;
+        }
+
+        this = &gpiomtd->nand_chip;
+        this->IO_ADDR_R = request_and_remap(res0, 2, "NAND", &ret);
+        if (!this->IO_ADDR_R) {
+                dev_err(&dev->dev, "unable to map NAND\n");
+                goto err_map;
+        }
+
+        res1 = platform_get_resource(dev, IORESOURCE_MEM, 1);
+        if (res1) {
+                gpiomtd->io_sync = request_and_remap(res1, 4, "NAND sync", &ret);
+                if (!gpiomtd->io_sync) {
+                        dev_err(&dev->dev, "unable to map sync NAND\n");
+                        goto err_sync;
+                }
+        }
+
+        memcpy(&gpiomtd->plat, dev->dev.platform_data, sizeof(gpiomtd->plat));
+
+        ret = gpio_request(gpiomtd->plat.gpio_nce, "NAND NCE");
+        if (ret)
+                goto err_nce;
+        gpio_direction_output(gpiomtd->plat.gpio_nce, 1);
+        if (gpio_is_valid(gpiomtd->plat.gpio_nwp)) {
+                ret = gpio_request(gpiomtd->plat.gpio_nwp, "NAND NWP");
+                if (ret)
+                        goto err_nwp;
+                gpio_direction_output(gpiomtd->plat.gpio_nwp, 1);
+        }
+        ret = gpio_request(gpiomtd->plat.gpio_ale, "NAND ALE");
+        if (ret)
+                goto err_ale;
+        gpio_direction_output(gpiomtd->plat.gpio_ale, 0);
+        ret = gpio_request(gpiomtd->plat.gpio_cle, "NAND CLE");
+        if (ret)
+                goto err_cle;
+        gpio_direction_output(gpiomtd->plat.gpio_cle, 0);
+        ret = gpio_request(gpiomtd->plat.gpio_rdy, "NAND RDY");
+        if (ret)
+                goto err_rdy;
+        gpio_direction_input(gpiomtd->plat.gpio_rdy);
+
+
+        this->IO_ADDR_W  = this->IO_ADDR_R;
+        this->ecc.mode   = NAND_ECC_SOFT;
+        this->options    = gpiomtd->plat.options;
+        this->chip_delay = gpiomtd->plat.chip_delay;
+
+        /* install our routines */
+        this->cmd_ctrl   = gpio_nand_cmd_ctrl;
+        this->dev_ready  = gpio_nand_devready;
+
+        if (this->options & NAND_BUSWIDTH_16) {
+                this->read_buf   = gpio_nand_readbuf16;
+                this->write_buf  = gpio_nand_writebuf16;
+                this->verify_buf = gpio_nand_verifybuf16;
+        } else {
+                this->read_buf   = gpio_nand_readbuf;
+                this->write_buf  = gpio_nand_writebuf;
+                this->verify_buf = gpio_nand_verifybuf;
+        }
+
+        /* set the mtd private data for the nand driver */
+        gpiomtd->mtd_info.priv = this;
+        gpiomtd->mtd_info.owner = THIS_MODULE;
+
+        if (nand_scan(&gpiomtd->mtd_info, 1)) {
+                dev_err(&dev->dev, "no nand chips found?\n");
+                ret = -ENXIO;
+                goto err_wp;
+        }
+
+        if (gpiomtd->plat.adjust_parts)
+                gpiomtd->plat.adjust_parts(&gpiomtd->plat,
+                                           gpiomtd->mtd_info.size);
+
+        add_mtd_partitions(&gpiomtd->mtd_info, gpiomtd->plat.parts,
+                           gpiomtd->plat.num_parts);
+        platform_set_drvdata(dev, gpiomtd);
+
+        return 0;
+
+err_wp:
+        if (gpio_is_valid(gpiomtd->plat.gpio_nwp))
+                gpio_set_value(gpiomtd->plat.gpio_nwp, 0);
+        gpio_free(gpiomtd->plat.gpio_rdy);
+err_rdy:
+        gpio_free(gpiomtd->plat.gpio_cle);
+err_cle:
+        gpio_free(gpiomtd->plat.gpio_ale);
+err_ale:
+        if (gpio_is_valid(gpiomtd->plat.gpio_nwp))
+                gpio_free(gpiomtd->plat.gpio_nwp);
+err_nwp:
+        gpio_free(gpiomtd->plat.gpio_nce);
+err_nce:
+        iounmap(gpiomtd->io_sync);
+        if (res1)
+                release_mem_region(res1->start, res1->end - res1->start + 1);
+err_sync:
+        iounmap(gpiomtd->nand_chip.IO_ADDR_R);
+        release_mem_region(res0->start, res0->end - res0->start + 1);
+err_map:
+        kfree(gpiomtd);
+        return ret;
+}
+
+static struct platform_driver gpio_nand_driver = {
+        .probe          = gpio_nand_probe,
+        .remove         = gpio_nand_remove,
+        .driver         = {
+                .name   = "gpio-nand",
+        },
+};
+
+static int __init gpio_nand_init(void)
+{
+        printk(KERN_INFO "GPIO NAND driver, © 2004 Simtec Electronics\n");
+
+        return platform_driver_register(&gpio_nand_driver);
+}
+
+static void __exit gpio_nand_exit(void)
+{
+        platform_driver_unregister(&gpio_nand_driver);
+}
+
+module_init(gpio_nand_init);
+module_exit(gpio_nand_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
+MODULE_DESCRIPTION("GPIO NAND Driver");
diff --git a/drivers/mtd/nand/mxc_nand.c b/drivers/mtd/nand/mxc_nand.c
new file mode 100644
index 000000000000..21fd4f1c4806
--- /dev/null
+++ b/drivers/mtd/nand/mxc_nand.c
@@ -0,0 +1,1077 @@
+/*
+ * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright 2008 Sascha Hauer, kernel@pengutronix.de
+ *
+ * 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., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+
+#include <asm/mach/flash.h>
+#include <mach/mxc_nand.h>
+
+#define DRIVER_NAME "mxc_nand"
+
+/* Addresses for NFC registers */
+#define NFC_BUF_SIZE            0xE00
+#define NFC_BUF_ADDR            0xE04
+#define NFC_FLASH_ADDR          0xE06
+#define NFC_FLASH_CMD           0xE08
+#define NFC_CONFIG              0xE0A
+#define NFC_ECC_STATUS_RESULT   0xE0C
+#define NFC_RSLTMAIN_AREA       0xE0E
+#define NFC_RSLTSPARE_AREA      0xE10
+#define NFC_WRPROT              0xE12
+#define NFC_UNLOCKSTART_BLKADDR 0xE14
+#define NFC_UNLOCKEND_BLKADDR   0xE16
+#define NFC_NF_WRPRST           0xE18
+#define NFC_CONFIG1             0xE1A
+#define NFC_CONFIG2             0xE1C
+
+/* Addresses for NFC RAM BUFFER Main area 0 */
+#define MAIN_AREA0              0x000
+#define MAIN_AREA1              0x200
+#define MAIN_AREA2              0x400
+#define MAIN_AREA3              0x600
+
+/* Addresses for NFC SPARE BUFFER Spare area 0 */
+#define SPARE_AREA0             0x800
+#define SPARE_AREA1             0x810
+#define SPARE_AREA2             0x820
+#define SPARE_AREA3             0x830
+
+/* Set INT to 0, FCMD to 1, rest to 0 in NFC_CONFIG2 Register
+ * for Command operation */
+#define NFC_CMD            0x1
+
+/* Set INT to 0, FADD to 1, rest to 0 in NFC_CONFIG2 Register
+ * for Address operation */
+#define NFC_ADDR           0x2
+
+/* Set INT to 0, FDI to 1, rest to 0 in NFC_CONFIG2 Register
+ * for Input operation */
+#define NFC_INPUT          0x4
+
+/* Set INT to 0, FDO to 001, rest to 0 in NFC_CONFIG2 Register
+ * for Data Output operation */
+#define NFC_OUTPUT         0x8
+
+/* Set INT to 0, FD0 to 010, rest to 0 in NFC_CONFIG2 Register
+ * for Read ID operation */
+#define NFC_ID             0x10
+
+/* Set INT to 0, FDO to 100, rest to 0 in NFC_CONFIG2 Register
+ * for Read Status operation */
+#define NFC_STATUS         0x20
+
+/* Set INT to 1, rest to 0 in NFC_CONFIG2 Register for Read
+ * Status operation */
+#define NFC_INT            0x8000
+
+#define NFC_SP_EN           (1 << 2)
+#define NFC_ECC_EN          (1 << 3)
+#define NFC_INT_MSK         (1 << 4)
+#define NFC_BIG             (1 << 5)
+#define NFC_RST             (1 << 6)
+#define NFC_CE              (1 << 7)
+#define NFC_ONE_CYCLE       (1 << 8)
+
+struct mxc_nand_host {
+        struct mtd_info         mtd;
+        struct nand_chip        nand;
+        struct mtd_partition    *parts;
+        struct device           *dev;
+
+        void __iomem            *regs;
+        int                     spare_only;
+        int                     status_request;
+        int                     pagesize_2k;
+        uint16_t                col_addr;
+        struct clk              *clk;
+        int                     clk_act;
+        int                     irq;
+
+        wait_queue_head_t       irq_waitq;
+};
+
+/* Define delays in microsec for NAND device operations */
+#define TROP_US_DELAY   2000
+/* Macros to get byte and bit positions of ECC */
+#define COLPOS(x)  ((x) >> 3)
+#define BITPOS(x) ((x) & 0xf)
+
+/* Define single bit Error positions in Main & Spare area */
+#define MAIN_SINGLEBIT_ERROR 0x4
+#define SPARE_SINGLEBIT_ERROR 0x1
+
+/* OOB placement block for use with hardware ecc generation */
+static struct nand_ecclayout nand_hw_eccoob_8 = {
+        .eccbytes = 5,
+        .eccpos = {6, 7, 8, 9, 10},
+        .oobfree = {{0, 5}, {11, 5}, }
+};
+
+static struct nand_ecclayout nand_hw_eccoob_16 = {
+        .eccbytes = 5,
+        .eccpos = {6, 7, 8, 9, 10},
+        .oobfree = {{0, 6}, {12, 4}, }
+};
+
+#ifdef CONFIG_MTD_PARTITIONS
+static const char *part_probes[] = { "RedBoot", "cmdlinepart", NULL };
+#endif
+
+static irqreturn_t mxc_nfc_irq(int irq, void *dev_id)
+{
+        struct mxc_nand_host *host = dev_id;
+
+        uint16_t tmp;
+
+        tmp = readw(host->regs + NFC_CONFIG1);
+        tmp |= NFC_INT_MSK; /* Disable interrupt */
+        writew(tmp, host->regs + NFC_CONFIG1);
+
+        wake_up(&host->irq_waitq);
+
+        return IRQ_HANDLED;
+}
+
+/* This function polls the NANDFC to wait for the basic operation to
+ * complete by checking the INT bit of config2 register.
+ */
+static void wait_op_done(struct mxc_nand_host *host, int max_retries,
+                                uint16_t param, int useirq)
+{
+        uint32_t tmp;
+
+        if (useirq) {
+                if ((readw(host->regs + NFC_CONFIG2) & NFC_INT) == 0) {
+
+                        tmp = readw(host->regs + NFC_CONFIG1);
+                        tmp  &= ~NFC_INT_MSK;   /* Enable interrupt */
+                        writew(tmp, host->regs + NFC_CONFIG1);
+
+                        wait_event(host->irq_waitq,
+                                readw(host->regs + NFC_CONFIG2) & NFC_INT);
+
+                        tmp = readw(host->regs + NFC_CONFIG2);
+                        tmp  &= ~NFC_INT;
+                        writew(tmp, host->regs + NFC_CONFIG2);
+                }
+        } else {
+                while (max_retries-- > 0) {
+                        if (readw(host->regs + NFC_CONFIG2) & NFC_INT) {
+                                tmp = readw(host->regs + NFC_CONFIG2);
+                                tmp  &= ~NFC_INT;
+                                writew(tmp, host->regs + NFC_CONFIG2);
+                                break;
+                        }
+                        udelay(1);
+                }
+                if (max_retries <= 0)
+                        DEBUG(MTD_DEBUG_LEVEL0, "%s(%d): INT not set\n",
+                              __func__, param);
+        }
+}
+
+/* This function issues the specified command to the NAND device and
+ * waits for completion. */
+static void send_cmd(struct mxc_nand_host *host, uint16_t cmd, int useirq)
+{
+        DEBUG(MTD_DEBUG_LEVEL3, "send_cmd(host, 0x%x, %d)\n", cmd, useirq);
+
+        writew(cmd, host->regs + NFC_FLASH_CMD);
+        writew(NFC_CMD, host->regs + NFC_CONFIG2);
+
+        /* Wait for operation to complete */
+        wait_op_done(host, TROP_US_DELAY, cmd, useirq);
+}
+
+/* This function sends an address (or partial address) to the
+ * NAND device. The address is used to select the source/destination for
+ * a NAND command. */
+static void send_addr(struct mxc_nand_host *host, uint16_t addr, int islast)
+{
+        DEBUG(MTD_DEBUG_LEVEL3, "send_addr(host, 0x%x %d)\n", addr, islast);
+
+        writew(addr, host->regs + NFC_FLASH_ADDR);
+        writew(NFC_ADDR, host->regs + NFC_CONFIG2);
+
+        /* Wait for operation to complete */
+        wait_op_done(host, TROP_US_DELAY, addr, islast);
+}
+
+/* This function requests the NANDFC to initate the transfer
+ * of data currently in the NANDFC RAM buffer to the NAND device. */
+static void send_prog_page(struct mxc_nand_host *host, uint8_t buf_id,
+                        int spare_only)
+{
+        DEBUG(MTD_DEBUG_LEVEL3, "send_prog_page (%d)\n", spare_only);
+
+        /* NANDFC buffer 0 is used for page read/write */
+        writew(buf_id, host->regs + NFC_BUF_ADDR);
+
+        /* Configure spare or page+spare access */
+        if (!host->pagesize_2k) {
+                uint16_t config1 = readw(host->regs + NFC_CONFIG1);
+                if (spare_only)
+                        config1 |= NFC_SP_EN;
+                else
+                        config1 &= ~(NFC_SP_EN);
+                writew(config1, host->regs + NFC_CONFIG1);
+        }
+
+        writew(NFC_INPUT, host->regs + NFC_CONFIG2);
+
+        /* Wait for operation to complete */
+        wait_op_done(host, TROP_US_DELAY, spare_only, true);
+}
+
+/* Requests NANDFC to initated the transfer of data from the
+ * NAND device into in the NANDFC ram buffer. */
+static void send_read_page(struct mxc_nand_host *host, uint8_t buf_id,
+                int spare_only)
+{
+        DEBUG(MTD_DEBUG_LEVEL3, "send_read_page (%d)\n", spare_only);
+
+        /* NANDFC buffer 0 is used for page read/write */
+        writew(buf_id, host->regs + NFC_BUF_ADDR);
+
+        /* Configure spare or page+spare access */
+        if (!host->pagesize_2k) {
+                uint32_t config1 = readw(host->regs + NFC_CONFIG1);
+                if (spare_only)
+                        config1 |= NFC_SP_EN;
+                else
+                        config1 &= ~NFC_SP_EN;
+                writew(config1, host->regs + NFC_CONFIG1);
+        }
+
+        writew(NFC_OUTPUT, host->regs + NFC_CONFIG2);
+
+        /* Wait for operation to complete */
+        wait_op_done(host, TROP_US_DELAY, spare_only, true);
+}
+
+/* Request the NANDFC to perform a read of the NAND device ID. */
+static void send_read_id(struct mxc_nand_host *host)
+{
+        struct nand_chip *this = &host->nand;
+        uint16_t tmp;
+
+        /* NANDFC buffer 0 is used for device ID output */
+        writew(0x0, host->regs + NFC_BUF_ADDR);
+
+        /* Read ID into main buffer */
+        tmp = readw(host->regs + NFC_CONFIG1);
+        tmp &= ~NFC_SP_EN;
+        writew(tmp, host->regs + NFC_CONFIG1);
+
+        writew(NFC_ID, host->regs + NFC_CONFIG2);
+
+        /* Wait for operation to complete */
+        wait_op_done(host, TROP_US_DELAY, 0, true);
+
+        if (this->options & NAND_BUSWIDTH_16) {
+                void __iomem *main_buf = host->regs + MAIN_AREA0;
+                /* compress the ID info */
+                writeb(readb(main_buf + 2), main_buf + 1);
+                writeb(readb(main_buf + 4), main_buf + 2);
+                writeb(readb(main_buf + 6), main_buf + 3);
+                writeb(readb(main_buf + 8), main_buf + 4);
+                writeb(readb(main_buf + 10), main_buf + 5);
+        }
+}
+
+/* This function requests the NANDFC to perform a read of the
+ * NAND device status and returns the current status. */
+static uint16_t get_dev_status(struct mxc_nand_host *host)
+{
+        void __iomem *main_buf = host->regs + MAIN_AREA1;
+        uint32_t store;
+        uint16_t ret, tmp;
+        /* Issue status request to NAND device */
+
+        /* store the main area1 first word, later do recovery */
+        store = readl(main_buf);
+        /* NANDFC buffer 1 is used for device status to prevent
+         * corruption of read/write buffer on status requests. */
+        writew(1, host->regs + NFC_BUF_ADDR);
+
+        /* Read status into main buffer */
+        tmp = readw(host->regs + NFC_CONFIG1);
+        tmp &= ~NFC_SP_EN;
+        writew(tmp, host->regs + NFC_CONFIG1);
+
+        writew(NFC_STATUS, host->regs + NFC_CONFIG2);
+
+        /* Wait for operation to complete */
+        wait_op_done(host, TROP_US_DELAY, 0, true);
+
+        /* Status is placed in first word of main buffer */
+        /* get status, then recovery area 1 data */
+        ret = readw(main_buf);
+        writel(store, main_buf);
+
+        return ret;
+}
+
+/* This functions is used by upper layer to checks if device is ready */
+static int mxc_nand_dev_ready(struct mtd_info *mtd)
+{
+        /*
+         * NFC handles R/B internally. Therefore, this function
+         * always returns status as ready.
+         */
+        return 1;
+}
+
+static void mxc_nand_enable_hwecc(struct mtd_info *mtd, int mode)
+{
+        /*
+         * If HW ECC is enabled, we turn it on during init. There is
+         * no need to enable again here.
+         */
+}
+
+static int mxc_nand_correct_data(struct mtd_info *mtd, u_char *dat,
+                                 u_char *read_ecc, u_char *calc_ecc)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct mxc_nand_host *host = nand_chip->priv;
+
+        /*
+         * 1-Bit errors are automatically corrected in HW.  No need for
+         * additional correction.  2-Bit errors cannot be corrected by
+         * HW ECC, so we need to return failure
+         */
+        uint16_t ecc_status = readw(host->regs + NFC_ECC_STATUS_RESULT);
+
+        if (((ecc_status & 0x3) == 2) || ((ecc_status >> 2) == 2)) {
+                DEBUG(MTD_DEBUG_LEVEL0,
+                      "MXC_NAND: HWECC uncorrectable 2-bit ECC error\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+static int mxc_nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
+                                  u_char *ecc_code)
+{
+        return 0;
+}
+
+static u_char mxc_nand_read_byte(struct mtd_info *mtd)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct mxc_nand_host *host = nand_chip->priv;
+        uint8_t ret = 0;
+        uint16_t col, rd_word;
+        uint16_t __iomem *main_buf = host->regs + MAIN_AREA0;
+        uint16_t __iomem *spare_buf = host->regs + SPARE_AREA0;
+
+        /* Check for status request */
+        if (host->status_request)
+                return get_dev_status(host) & 0xFF;
+
+        /* Get column for 16-bit access */
+        col = host->col_addr >> 1;
+
+        /* If we are accessing the spare region */
+        if (host->spare_only)
+                rd_word = readw(&spare_buf[col]);
+        else
+                rd_word = readw(&main_buf[col]);
+
+        /* Pick upper/lower byte of word from RAM buffer */
+        if (host->col_addr & 0x1)
+                ret = (rd_word >> 8) & 0xFF;
+        else
+                ret = rd_word & 0xFF;
+
+        /* Update saved column address */
+        host->col_addr++;
+
+        return ret;
+}
+
+static uint16_t mxc_nand_read_word(struct mtd_info *mtd)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct mxc_nand_host *host = nand_chip->priv;
+        uint16_t col, rd_word, ret;
+        uint16_t __iomem *p;
+
+        DEBUG(MTD_DEBUG_LEVEL3,
+              "mxc_nand_read_word(col = %d)\n", host->col_addr);
+
+        col = host->col_addr;
+        /* Adjust saved column address */
+        if (col < mtd->writesize && host->spare_only)
+                col += mtd->writesize;
+
+        if (col < mtd->writesize)
+                p = (host->regs + MAIN_AREA0) + (col >> 1);
+        else
+                p = (host->regs + SPARE_AREA0) + ((col - mtd->writesize) >> 1);
+
+        if (col & 1) {
+                rd_word = readw(p);
+                ret = (rd_word >> 8) & 0xff;
+                rd_word = readw(&p[1]);
+                ret |= (rd_word << 8) & 0xff00;
+
+        } else
+                ret = readw(p);
+
+        /* Update saved column address */
+        host->col_addr = col + 2;
+
+        return ret;
+}
+
+/* Write data of length len to buffer buf. The data to be
+ * written on NAND Flash is first copied to RAMbuffer. After the Data Input
+ * Operation by the NFC, the data is written to NAND Flash */
+static void mxc_nand_write_buf(struct mtd_info *mtd,
+                                const u_char *buf, int len)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct mxc_nand_host *host = nand_chip->priv;
+        int n, col, i = 0;
+
+        DEBUG(MTD_DEBUG_LEVEL3,
+              "mxc_nand_write_buf(col = %d, len = %d)\n", host->col_addr,
+              len);
+
+        col = host->col_addr;
+
+        /* Adjust saved column address */
+        if (col < mtd->writesize && host->spare_only)
+                col += mtd->writesize;
+
+        n = mtd->writesize + mtd->oobsize - col;
+        n = min(len, n);
+
+        DEBUG(MTD_DEBUG_LEVEL3,
+              "%s:%d: col = %d, n = %d\n", __func__, __LINE__, col, n);
+
+        while (n) {
+                void __iomem *p;
+
+                if (col < mtd->writesize)
+                        p = host->regs + MAIN_AREA0 + (col & ~3);
+                else
+                        p = host->regs + SPARE_AREA0 -
+                                                mtd->writesize + (col & ~3);
+
+                DEBUG(MTD_DEBUG_LEVEL3, "%s:%d: p = %p\n", __func__,
+                      __LINE__, p);
+
+                if (((col | (int)&buf[i]) & 3) || n < 16) {
+                        uint32_t data = 0;
+
+                        if (col & 3 || n < 4)
+                                data = readl(p);
+
+                        switch (col & 3) {
+                        case 0:
+                                if (n) {
+                                        data = (data & 0xffffff00) |
+                                            (buf[i++] << 0);
+                                        n--;
+                                        col++;
+                                }
+                        case 1:
+                                if (n) {
+                                        data = (data & 0xffff00ff) |
+                                            (buf[i++] << 8);
+                                        n--;
+                                        col++;
+                                }
+                        case 2:
+                                if (n) {
+                                        data = (data & 0xff00ffff) |
+                                            (buf[i++] << 16);
+                                        n--;
+                                        col++;
+                                }
+                        case 3:
+                                if (n) {
+                                        data = (data & 0x00ffffff) |
+                                            (buf[i++] << 24);
+                                        n--;
+                                        col++;
+                                }
+                        }
+
+                        writel(data, p);
+                } else {
+                        int m = mtd->writesize - col;
+
+                        if (col >= mtd->writesize)
+                                m += mtd->oobsize;
+
+                        m = min(n, m) & ~3;
+
+                        DEBUG(MTD_DEBUG_LEVEL3,
+                              "%s:%d: n = %d, m = %d, i = %d, col = %d\n",
+                              __func__,  __LINE__, n, m, i, col);
+
+                        memcpy(p, &buf[i], m);
+                        col += m;
+                        i += m;
+                        n -= m;
+                }
+        }
+        /* Update saved column address */
+        host->col_addr = col;
+}
+
+/* Read the data buffer from the NAND Flash. To read the data from NAND
+ * Flash first the data output cycle is initiated by the NFC, which copies
+ * the data to RAMbuffer. This data of length len is then copied to buffer buf.
+ */
+static void mxc_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct mxc_nand_host *host = nand_chip->priv;
+        int n, col, i = 0;
+
+        DEBUG(MTD_DEBUG_LEVEL3,
+              "mxc_nand_read_buf(col = %d, len = %d)\n", host->col_addr, len);
+
+        col = host->col_addr;
+
+        /* Adjust saved column address */
+        if (col < mtd->writesize && host->spare_only)
+                col += mtd->writesize;
+
+        n = mtd->writesize + mtd->oobsize - col;
+        n = min(len, n);
+
+        while (n) {
+                void __iomem *p;
+
+                if (col < mtd->writesize)
+                        p = host->regs + MAIN_AREA0 + (col & ~3);
+                else
+                        p = host->regs + SPARE_AREA0 -
+                                        mtd->writesize + (col & ~3);
+
+                if (((col | (int)&buf[i]) & 3) || n < 16) {
+                        uint32_t data;
+
+                        data = readl(p);
+                        switch (col & 3) {
+                        case 0:
+                                if (n) {
+                                        buf[i++] = (uint8_t) (data);
+                                        n--;
+                                        col++;
+                                }
+                        case 1:
+                                if (n) {
+                                        buf[i++] = (uint8_t) (data >> 8);
+                                        n--;
+                                        col++;
+                                }
+                        case 2:
+                                if (n) {
+                                        buf[i++] = (uint8_t) (data >> 16);
+                                        n--;
+                                        col++;
+                                }
+                        case 3:
+                                if (n) {
+                                        buf[i++] = (uint8_t) (data >> 24);
+                                        n--;
+                                        col++;
+                                }
+                        }
+                } else {
+                        int m = mtd->writesize - col;
+
+                        if (col >= mtd->writesize)
+                                m += mtd->oobsize;
+
+                        m = min(n, m) & ~3;
+                        memcpy(&buf[i], p, m);
+                        col += m;
+                        i += m;
+                        n -= m;
+                }
+        }
+        /* Update saved column address */
+        host->col_addr = col;
+
+}
+
+/* Used by the upper layer to verify the data in NAND Flash
+ * with the data in the buf. */
+static int mxc_nand_verify_buf(struct mtd_info *mtd,
+                                const u_char *buf, int len)
+{
+        return -EFAULT;
+}
+
+/* This function is used by upper layer for select and
+ * deselect of the NAND chip */
+static void mxc_nand_select_chip(struct mtd_info *mtd, int chip)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct mxc_nand_host *host = nand_chip->priv;
+
+#ifdef CONFIG_MTD_NAND_MXC_FORCE_CE
+        if (chip > 0) {
+                DEBUG(MTD_DEBUG_LEVEL0,
+                      "ERROR:  Illegal chip select (chip = %d)\n", chip);
+                return;
+        }
+
+        if (chip == -1) {
+                writew(readw(host->regs + NFC_CONFIG1) & ~NFC_CE,
+                                host->regs + NFC_CONFIG1);
+                return;
+        }
+
+        writew(readw(host->regs + NFC_CONFIG1) | NFC_CE,
+                        host->regs + NFC_CONFIG1);
+#endif
+
+        switch (chip) {
+        case -1:
+                /* Disable the NFC clock */
+                if (host->clk_act) {
+                        clk_disable(host->clk);
+                        host->clk_act = 0;
+                }
+                break;
+        case 0:
+                /* Enable the NFC clock */
+                if (!host->clk_act) {
+                        clk_enable(host->clk);
+                        host->clk_act = 1;
+                }
+                break;
+
+        default:
+                break;
+        }
+}
+
+/* Used by the upper layer to write command to NAND Flash for
+ * different operations to be carried out on NAND Flash */
+static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
+                                int column, int page_addr)
+{
+        struct nand_chip *nand_chip = mtd->priv;
+        struct mxc_nand_host *host = nand_chip->priv;
+        int useirq = true;
+
+        DEBUG(MTD_DEBUG_LEVEL3,
+              "mxc_nand_command (cmd = 0x%x, col = 0x%x, page = 0x%x)\n",
+              command, column, page_addr);
+
+        /* Reset command state information */
+        host->status_request = false;
+
+        /* Command pre-processing step */
+        switch (command) {
+
+        case NAND_CMD_STATUS:
+                host->col_addr = 0;
+                host->status_request = true;
+                break;
+
+        case NAND_CMD_READ0:
+                host->col_addr = column;
+                host->spare_only = false;
+                useirq = false;
+                break;
+
+        case NAND_CMD_READOOB:
+                host->col_addr = column;
+                host->spare_only = true;
+                useirq = false;
+                if (host->pagesize_2k)
+                        command = NAND_CMD_READ0; /* only READ0 is valid */
+                break;
+
+        case NAND_CMD_SEQIN:
+                if (column >= mtd->writesize) {
+                        /*
+                         * FIXME: before send SEQIN command for write OOB,
+                         * We must read one page out.
+                         * For K9F1GXX has no READ1 command to set current HW
+                         * pointer to spare area, we must write the whole page
+                         * including OOB together.
+                         */
+                        if (host->pagesize_2k)
+                                /* call ourself to read a page */
+                                mxc_nand_command(mtd, NAND_CMD_READ0, 0,
+                                                page_addr);
+
+                        host->col_addr = column - mtd->writesize;
+                        host->spare_only = true;
+
+                        /* Set program pointer to spare region */
+                        if (!host->pagesize_2k)
+                                send_cmd(host, NAND_CMD_READOOB, false);
+                } else {
+                        host->spare_only = false;
+                        host->col_addr = column;
+
+                        /* Set program pointer to page start */
+                        if (!host->pagesize_2k)
+                                send_cmd(host, NAND_CMD_READ0, false);
+                }
+                useirq = false;
+                break;
+
+        case NAND_CMD_PAGEPROG:
+                send_prog_page(host, 0, host->spare_only);
+
+                if (host->pagesize_2k) {
+                        /* data in 4 areas datas */
+                        send_prog_page(host, 1, host->spare_only);
+                        send_prog_page(host, 2, host->spare_only);
+                        send_prog_page(host, 3, host->spare_only);
+                }
+
+                break;
+
+        case NAND_CMD_ERASE1:
+                useirq = false;
+                break;
+        }
+
+        /* Write out the command to the device. */
+        send_cmd(host, command, useirq);
+
+        /* Write out column address, if necessary */
+        if (column != -1) {
+                /*
+                 * MXC NANDFC can only perform full page+spare or
+                 * spare-only read/write.  When the upper layers
+                 * layers perform a read/write buf operation,
+                 * we will used the saved column adress to index into
+                 * the full page.
+                 */
+                send_addr(host, 0, page_addr == -1);
+                if (host->pagesize_2k)
+                        /* another col addr cycle for 2k page */
+                        send_addr(host, 0, false);
+        }
+
+        /* Write out page address, if necessary */
+        if (page_addr != -1) {
+                /* paddr_0 - p_addr_7 */
+                send_addr(host, (page_addr & 0xff), false);
+
+                if (host->pagesize_2k) {
+                        send_addr(host, (page_addr >> 8) & 0xFF, false);
+                        if (mtd->size >= 0x40000000)
+                                send_addr(host, (page_addr >> 16) & 0xff, true);
+                } else {
+                        /* One more address cycle for higher density devices */
+                        if (mtd->size >= 0x4000000) {
+                                /* paddr_8 - paddr_15 */
+                                send_addr(host, (page_addr >> 8) & 0xff, false);
+                                send_addr(host, (page_addr >> 16) & 0xff, true);
+                        } else
+                                /* paddr_8 - paddr_15 */
+                                send_addr(host, (page_addr >> 8) & 0xff, true);
+                }
+        }
+
+        /* Command post-processing step */
+        switch (command) {
+
+        case NAND_CMD_RESET:
+                break;
+
+        case NAND_CMD_READOOB:
+        case NAND_CMD_READ0:
+                if (host->pagesize_2k) {
+                        /* send read confirm command */
+                        send_cmd(host, NAND_CMD_READSTART, true);
+                        /* read for each AREA */
+                        send_read_page(host, 0, host->spare_only);
+                        send_read_page(host, 1, host->spare_only);
+                        send_read_page(host, 2, host->spare_only);
+                        send_read_page(host, 3, host->spare_only);
+                } else
+                        send_read_page(host, 0, host->spare_only);
+                break;
+
+        case NAND_CMD_READID:
+                send_read_id(host);
+                break;
+
+        case NAND_CMD_PAGEPROG:
+                break;
+
+        case NAND_CMD_STATUS:
+                break;
+
+        case NAND_CMD_ERASE2:
+                break;
+        }
+}
+
+static int __init mxcnd_probe(struct platform_device *pdev)
+{
+        struct nand_chip *this;
+        struct mtd_info *mtd;
+        struct mxc_nand_platform_data *pdata = pdev->dev.platform_data;
+        struct mxc_nand_host *host;
+        struct resource *res;
+        uint16_t tmp;
+        int err = 0, nr_parts = 0;
+
+        /* Allocate memory for MTD device structure and private data */
+        host = kzalloc(sizeof(struct mxc_nand_host), GFP_KERNEL);
+        if (!host)
+                return -ENOMEM;
+
+        host->dev = &pdev->dev;
+        /* structures must be linked */
+        this = &host->nand;
+        mtd = &host->mtd;
+        mtd->priv = this;
+        mtd->owner = THIS_MODULE;
+
+        /* 50 us command delay time */
+        this->chip_delay = 5;
+
+        this->priv = host;
+        this->dev_ready = mxc_nand_dev_ready;
+        this->cmdfunc = mxc_nand_command;
+        this->select_chip = mxc_nand_select_chip;
+        this->read_byte = mxc_nand_read_byte;
+        this->read_word = mxc_nand_read_word;
+        this->write_buf = mxc_nand_write_buf;
+        this->read_buf = mxc_nand_read_buf;
+        this->verify_buf = mxc_nand_verify_buf;
+
+        host->clk = clk_get(&pdev->dev, "nfc_clk");
+        if (IS_ERR(host->clk))
+                goto eclk;
+
+        clk_enable(host->clk);
+        host->clk_act = 1;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                err = -ENODEV;
+                goto eres;
+        }
+
+        host->regs = ioremap(res->start, res->end - res->start + 1);
+        if (!host->regs) {
+                err = -EIO;
+                goto eres;
+        }
+
+        tmp = readw(host->regs + NFC_CONFIG1);
+        tmp |= NFC_INT_MSK;
+        writew(tmp, host->regs + NFC_CONFIG1);
+
+        init_waitqueue_head(&host->irq_waitq);
+
+        host->irq = platform_get_irq(pdev, 0);
+
+        err = request_irq(host->irq, mxc_nfc_irq, 0, "mxc_nd", host);
+        if (err)
+                goto eirq;
+
+        if (pdata->hw_ecc) {
+                this->ecc.calculate = mxc_nand_calculate_ecc;
+                this->ecc.hwctl = mxc_nand_enable_hwecc;
+                this->ecc.correct = mxc_nand_correct_data;
+                this->ecc.mode = NAND_ECC_HW;
+                this->ecc.size = 512;
+                this->ecc.bytes = 3;
+                this->ecc.layout = &nand_hw_eccoob_8;
+                tmp = readw(host->regs + NFC_CONFIG1);
+                tmp |= NFC_ECC_EN;
+                writew(tmp, host->regs + NFC_CONFIG1);
+        } else {
+                this->ecc.size = 512;
+                this->ecc.bytes = 3;
+                this->ecc.layout = &nand_hw_eccoob_8;
+                this->ecc.mode = NAND_ECC_SOFT;
+                tmp = readw(host->regs + NFC_CONFIG1);
+                tmp &= ~NFC_ECC_EN;
+                writew(tmp, host->regs + NFC_CONFIG1);
+        }
+
+        /* Reset NAND */
+        this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+
+        /* preset operation */
+        /* Unlock the internal RAM Buffer */
+        writew(0x2, host->regs + NFC_CONFIG);
+
+        /* Blocks to be unlocked */
+        writew(0x0, host->regs + NFC_UNLOCKSTART_BLKADDR);
+        writew(0x4000, host->regs + NFC_UNLOCKEND_BLKADDR);
+
+        /* Unlock Block Command for given address range */
+        writew(0x4, host->regs + NFC_WRPROT);
+
+        /* NAND bus width determines access funtions used by upper layer */
+        if (pdata->width == 2) {
+                this->options |= NAND_BUSWIDTH_16;
+                this->ecc.layout = &nand_hw_eccoob_16;
+        }
+
+        host->pagesize_2k = 0;
+
+        /* Scan to find existence of the device */
+        if (nand_scan(mtd, 1)) {
+                DEBUG(MTD_DEBUG_LEVEL0,
+                      "MXC_ND: Unable to find any NAND device.\n");
+                err = -ENXIO;
+                goto escan;
+        }
+
+        /* Register the partitions */
+#ifdef CONFIG_MTD_PARTITIONS
+        nr_parts =
+            parse_mtd_partitions(mtd, part_probes, &host->parts, 0);
+        if (nr_parts > 0)
+                add_mtd_partitions(mtd, host->parts, nr_parts);
+        else
+#endif
+        {
+                pr_info("Registering %s as whole device\n", mtd->name);
+                add_mtd_device(mtd);
+        }
+
+        platform_set_drvdata(pdev, host);
+
+        return 0;
+
+escan:
+        free_irq(host->irq, NULL);
+eirq:
+        iounmap(host->regs);
+eres:
+        clk_put(host->clk);
+eclk:
+        kfree(host);
+
+        return err;
+}
+
+static int __devexit mxcnd_remove(struct platform_device *pdev)
+{
+        struct mxc_nand_host *host = platform_get_drvdata(pdev);
+
+        clk_put(host->clk);
+
+        platform_set_drvdata(pdev, NULL);
+
+        nand_release(&host->mtd);
+        free_irq(host->irq, NULL);
+        iounmap(host->regs);
+        kfree(host);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int mxcnd_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct mtd_info *info = platform_get_drvdata(pdev);
+        int ret = 0;
+
+        DEBUG(MTD_DEBUG_LEVEL0, "MXC_ND : NAND suspend\n");
+        if (info)
+                ret = info->suspend(info);
+
+        /* Disable the NFC clock */
+        clk_disable(nfc_clk);   /* FIXME */
+
+        return ret;
+}
+
+static int mxcnd_resume(struct platform_device *pdev)
+{
+        struct mtd_info *info = platform_get_drvdata(pdev);
+        int ret = 0;
+
+        DEBUG(MTD_DEBUG_LEVEL0, "MXC_ND : NAND resume\n");
+        /* Enable the NFC clock */
+        clk_enable(nfc_clk);    /* FIXME */
+
+        if (info)
+                info->resume(info);
+
+        return ret;
+}
+
+#else
+# define mxcnd_suspend   NULL
+# define mxcnd_resume    NULL
+#endif                          /* CONFIG_PM */
+
+static struct platform_driver mxcnd_driver = {
+        .driver = {
+                   .name = DRIVER_NAME,
+                   },
+        .remove = __exit_p(mxcnd_remove),
+        .suspend = mxcnd_suspend,
+        .resume = mxcnd_resume,
+};
+
+static int __init mxc_nd_init(void)
+{
+        /* Register the device driver structure. */
+        pr_info("MXC MTD nand Driver\n");
+        if (platform_driver_probe(&mxcnd_driver, mxcnd_probe) != 0) {
+                printk(KERN_ERR "Driver register failed for mxcnd_driver\n");
+                return -ENODEV;
+        }
+        return 0;
+}
+
+static void __exit mxc_nd_cleanup(void)
+{
+        /* Unregister the device structure */
+        platform_driver_unregister(&mxcnd_driver);
+}
+
+module_init(mxc_nd_init);
+module_exit(mxc_nd_cleanup);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("MXC NAND MTD driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index d1129bae6c27..0a9c9cd33f96 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -801,9 +801,9 @@ static int nand_read_page_swecc(struct mtd_info *mtd, struct nand_chip *chip,
  * nand_read_subpage - [REPLACABLE] software ecc based sub-page read function
  * @mtd:        mtd info structure
  * @chip:       nand chip info structure
- * @dataofs     offset of requested data within the page
- * @readlen     data length
- * @buf:        buffer to store read data
+ * @data_offs:  offset of requested data within the page
+ * @readlen:    data length
+ * @bufpoi:     buffer to store read data
  */
 static int nand_read_subpage(struct mtd_info *mtd, struct nand_chip *chip, uint32_t data_offs, uint32_t readlen, uint8_t *bufpoi)
 {
@@ -2042,7 +2042,7 @@ int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
                 return -EINVAL;
         }
 
-        instr->fail_addr = 0xffffffff;
+        instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
 
         /* Grab the lock and see if the device is available */
         nand_get_device(chip, mtd, FL_ERASING);
@@ -2318,6 +2318,12 @@ static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
         /* Select the device */
         chip->select_chip(mtd, 0);
 
+        /*
+         * Reset the chip, required by some chips (e.g. Micron MT29FxGxxxxx)
+         * after power-up
+         */
+        chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
+
         /* Send the command for reading device ID */
         chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
 
@@ -2488,6 +2494,8 @@ int nand_scan_ident(struct mtd_info *mtd, int maxchips)
         /* Check for a chip array */
         for (i = 1; i < maxchips; i++) {
                 chip->select_chip(mtd, i);
+                /* See comment in nand_get_flash_type for reset */
+                chip->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
                 /* Send the command for reading device ID */
                 chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
                 /* Read manufacturer and device IDs */
diff --git a/drivers/mtd/nand/nand_ecc.c b/drivers/mtd/nand/nand_ecc.c
index 918a806a8471..868147acce2c 100644
--- a/drivers/mtd/nand/nand_ecc.c
+++ b/drivers/mtd/nand/nand_ecc.c
@@ -1,13 +1,18 @@
 /*
- * This file contains an ECC algorithm from Toshiba that detects and
- * corrects 1 bit errors in a 256 byte block of data.
+ * This file contains an ECC algorithm that detects and corrects 1 bit
+ * errors in a 256 byte block of data.
  *
  * drivers/mtd/nand/nand_ecc.c
  *
- * Copyright (C) 2000-2004 Steven J. Hill (sjhill@realitydiluted.com)
- *                         Toshiba America Electronics Components, Inc.
+ * Copyright © 2008 Koninklijke Philips Electronics NV.
+ *                  Author: Frans Meulenbroeks
  *
- * Copyright (C) 2006 Thomas Gleixner <tglx@linutronix.de>
+ * Completely replaces the previous ECC implementation which was written by:
+ *   Steven J. Hill (sjhill@realitydiluted.com)
+ *   Thomas Gleixner (tglx@linutronix.de)
+ *
+ * Information on how this algorithm works and how it was developed
+ * can be found in Documentation/mtd/nand_ecc.txt
  *
  * This file is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
@@ -23,174 +28,475 @@
  * with this file; if not, write to the Free Software Foundation, Inc.,
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  *
- * As a special exception, if other files instantiate templates or use
- * macros or inline functions from these files, or you compile these
- * files and link them with other works to produce a work based on these
- * files, these files do not by themselves cause the resulting work to be
- * covered by the GNU General Public License. However the source code for
- * these files must still be made available in accordance with section (3)
- * of the GNU General Public License.
- *
- * This exception does not invalidate any other reasons why a work based on
- * this file might be covered by the GNU General Public License.
  */
 
+/*
+ * The STANDALONE macro is useful when running the code outside the kernel
+ * e.g. when running the code in a testbed or a benchmark program.
+ * When STANDALONE is used, the module related macros are commented out
+ * as well as the linux include files.
+ * Instead a private definition of mtd_info is given to satisfy the compiler
+ * (the code does not use mtd_info, so the code does not care)
+ */
+#ifndef STANDALONE
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
 #include <linux/mtd/nand_ecc.h>
+#include <asm/byteorder.h>
+#else
+#include <stdint.h>
+struct mtd_info;
+#define EXPORT_SYMBOL(x)  /* x */
+
+#define MODULE_LICENSE(x)       /* x */
+#define MODULE_AUTHOR(x)        /* x */
+#define MODULE_DESCRIPTION(x)   /* x */
+
+#define printk printf
+#define KERN_ERR                ""
+#endif
+
+/*
+ * invparity is a 256 byte table that contains the odd parity
+ * for each byte. So if the number of bits in a byte is even,
+ * the array element is 1, and when the number of bits is odd
+ * the array eleemnt is 0.
+ */
+static const char invparity[256] = {
+        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
+        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
+};
+
+/*
+ * bitsperbyte contains the number of bits per byte
+ * this is only used for testing and repairing parity
+ * (a precalculated value slightly improves performance)
+ */
+static const char bitsperbyte[256] = {
+        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
+};
 
 /*
- * Pre-calculated 256-way 1 byte column parity
+ * addressbits is a lookup table to filter out the bits from the xor-ed
+ * ecc data that identify the faulty location.
+ * this is only used for repairing parity
+ * see the comments in nand_correct_data for more details
  */
-static const u_char nand_ecc_precalc_table[] = {
-        0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00,
-        0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
-        0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
-        0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
-        0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
-        0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
-        0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
-        0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
-        0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
-        0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
-        0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
-        0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
-        0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
-        0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
-        0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
-        0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00
+static const char addressbits[256] = {
+        0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
+        0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
+        0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
+        0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
+        0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
+        0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
+        0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
+        0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
+        0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
+        0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
+        0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01,
+        0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03,
+        0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
+        0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
+        0x04, 0x04, 0x05, 0x05, 0x04, 0x04, 0x05, 0x05,
+        0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x07, 0x07,
+        0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
+        0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
+        0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
+        0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
+        0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
+        0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
+        0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
+        0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
+        0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
+        0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
+        0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x09, 0x09,
+        0x0a, 0x0a, 0x0b, 0x0b, 0x0a, 0x0a, 0x0b, 0x0b,
+        0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
+        0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f,
+        0x0c, 0x0c, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d,
+        0x0e, 0x0e, 0x0f, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f
 };
 
 /**
- * nand_calculate_ecc - [NAND Interface] Calculate 3-byte ECC for 256-byte block
+ * nand_calculate_ecc - [NAND Interface] Calculate 3-byte ECC for 256/512-byte
+ *                       block
  * @mtd:        MTD block structure
- * @dat:        raw data
- * @ecc_code:   buffer for ECC
+ * @buf:        input buffer with raw data
+ * @code:       output buffer with ECC
  */
-int nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
-                       u_char *ecc_code)
+int nand_calculate_ecc(struct mtd_info *mtd, const unsigned char *buf,
+                       unsigned char *code)
 {
-        uint8_t idx, reg1, reg2, reg3, tmp1, tmp2;
         int i;
+        const uint32_t *bp = (uint32_t *)buf;
+        /* 256 or 512 bytes/ecc  */
+        const uint32_t eccsize_mult =
+                        (((struct nand_chip *)mtd->priv)->ecc.size) >> 8;
+        uint32_t cur;           /* current value in buffer */
+        /* rp0..rp15..rp17 are the various accumulated parities (per byte) */
+        uint32_t rp0, rp1, rp2, rp3, rp4, rp5, rp6, rp7;
+        uint32_t rp8, rp9, rp10, rp11, rp12, rp13, rp14, rp15, rp16;
+        uint32_t uninitialized_var(rp17);       /* to make compiler happy */
+        uint32_t par;           /* the cumulative parity for all data */
+        uint32_t tmppar;        /* the cumulative parity for this iteration;
+                                   for rp12, rp14 and rp16 at the end of the
+                                   loop */
+
+        par = 0;
+        rp4 = 0;
+        rp6 = 0;
+        rp8 = 0;
+        rp10 = 0;
+        rp12 = 0;
+        rp14 = 0;
+        rp16 = 0;
+
+        /*
+         * The loop is unrolled a number of times;
+         * This avoids if statements to decide on which rp value to update
+         * Also we process the data by longwords.
+         * Note: passing unaligned data might give a performance penalty.
+         * It is assumed that the buffers are aligned.
+         * tmppar is the cumulative sum of this iteration.
+         * needed for calculating rp12, rp14, rp16 and par
+         * also used as a performance improvement for rp6, rp8 and rp10
+         */
+        for (i = 0; i < eccsize_mult << 2; i++) {
+                cur = *bp++;
+                tmppar = cur;
+                rp4 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp6 ^= tmppar;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp4 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp8 ^= tmppar;
 
-        /* Initialize variables */
-        reg1 = reg2 = reg3 = 0;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp4 ^= cur;
+                rp6 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp6 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp4 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp10 ^= tmppar;
 
-        /* Build up column parity */
-        for(i = 0; i < 256; i++) {
-                /* Get CP0 - CP5 from table */
-                idx = nand_ecc_precalc_table[*dat++];
-                reg1 ^= (idx & 0x3f);
+                cur = *bp++;
+                tmppar ^= cur;
+                rp4 ^= cur;
+                rp6 ^= cur;
+                rp8 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp6 ^= cur;
+                rp8 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp4 ^= cur;
+                rp8 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp8 ^= cur;
 
-                /* All bit XOR = 1 ? */
-                if (idx & 0x40) {
-                        reg3 ^= (uint8_t) i;
-                        reg2 ^= ~((uint8_t) i);
-                }
+                cur = *bp++;
+                tmppar ^= cur;
+                rp4 ^= cur;
+                rp6 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp6 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+                rp4 ^= cur;
+                cur = *bp++;
+                tmppar ^= cur;
+
+                par ^= tmppar;
+                if ((i & 0x1) == 0)
+                        rp12 ^= tmppar;
+                if ((i & 0x2) == 0)
+                        rp14 ^= tmppar;
+                if (eccsize_mult == 2 && (i & 0x4) == 0)
+                        rp16 ^= tmppar;
         }
 
-        /* Create non-inverted ECC code from line parity */
-        tmp1  = (reg3 & 0x80) >> 0; /* B7 -> B7 */
-        tmp1 |= (reg2 & 0x80) >> 1; /* B7 -> B6 */
-        tmp1 |= (reg3 & 0x40) >> 1; /* B6 -> B5 */
-        tmp1 |= (reg2 & 0x40) >> 2; /* B6 -> B4 */
-        tmp1 |= (reg3 & 0x20) >> 2; /* B5 -> B3 */
-        tmp1 |= (reg2 & 0x20) >> 3; /* B5 -> B2 */
-        tmp1 |= (reg3 & 0x10) >> 3; /* B4 -> B1 */
-        tmp1 |= (reg2 & 0x10) >> 4; /* B4 -> B0 */
-
-        tmp2  = (reg3 & 0x08) << 4; /* B3 -> B7 */
-        tmp2 |= (reg2 & 0x08) << 3; /* B3 -> B6 */
-        tmp2 |= (reg3 & 0x04) << 3; /* B2 -> B5 */
-        tmp2 |= (reg2 & 0x04) << 2; /* B2 -> B4 */
-        tmp2 |= (reg3 & 0x02) << 2; /* B1 -> B3 */
-        tmp2 |= (reg2 & 0x02) << 1; /* B1 -> B2 */
-        tmp2 |= (reg3 & 0x01) << 1; /* B0 -> B1 */
-        tmp2 |= (reg2 & 0x01) << 0; /* B7 -> B0 */
-
-        /* Calculate final ECC code */
-#ifdef CONFIG_MTD_NAND_ECC_SMC
-        ecc_code[0] = ~tmp2;
-        ecc_code[1] = ~tmp1;
+        /*
+         * handle the fact that we use longword operations
+         * we'll bring rp4..rp14..rp16 back to single byte entities by
+         * shifting and xoring first fold the upper and lower 16 bits,
+         * then the upper and lower 8 bits.
+         */
+        rp4 ^= (rp4 >> 16);
+        rp4 ^= (rp4 >> 8);
+        rp4 &= 0xff;
+        rp6 ^= (rp6 >> 16);
+        rp6 ^= (rp6 >> 8);
+        rp6 &= 0xff;
+        rp8 ^= (rp8 >> 16);
+        rp8 ^= (rp8 >> 8);
+        rp8 &= 0xff;
+        rp10 ^= (rp10 >> 16);
+        rp10 ^= (rp10 >> 8);
+        rp10 &= 0xff;
+        rp12 ^= (rp12 >> 16);
+        rp12 ^= (rp12 >> 8);
+        rp12 &= 0xff;
+        rp14 ^= (rp14 >> 16);
+        rp14 ^= (rp14 >> 8);
+        rp14 &= 0xff;
+        if (eccsize_mult == 2) {
+                rp16 ^= (rp16 >> 16);
+                rp16 ^= (rp16 >> 8);
+                rp16 &= 0xff;
+        }
+
+        /*
+         * we also need to calculate the row parity for rp0..rp3
+         * This is present in par, because par is now
+         * rp3 rp3 rp2 rp2 in little endian and
+         * rp2 rp2 rp3 rp3 in big endian
+         * as well as
+         * rp1 rp0 rp1 rp0 in little endian and
+         * rp0 rp1 rp0 rp1 in big endian
+         * First calculate rp2 and rp3
+         */
+#ifdef __BIG_ENDIAN
+        rp2 = (par >> 16);
+        rp2 ^= (rp2 >> 8);
+        rp2 &= 0xff;
+        rp3 = par & 0xffff;
+        rp3 ^= (rp3 >> 8);
+        rp3 &= 0xff;
 #else
-        ecc_code[0] = ~tmp1;
-        ecc_code[1] = ~tmp2;
+        rp3 = (par >> 16);
+        rp3 ^= (rp3 >> 8);
+        rp3 &= 0xff;
+        rp2 = par & 0xffff;
+        rp2 ^= (rp2 >> 8);
+        rp2 &= 0xff;
 #endif
-        ecc_code[2] = ((~reg1) << 2) | 0x03;
 
-        return 0;
-}
-EXPORT_SYMBOL(nand_calculate_ecc);
+        /* reduce par to 16 bits then calculate rp1 and rp0 */
+        par ^= (par >> 16);
+#ifdef __BIG_ENDIAN
+        rp0 = (par >> 8) & 0xff;
+        rp1 = (par & 0xff);
+#else
+        rp1 = (par >> 8) & 0xff;
+        rp0 = (par & 0xff);
+#endif
 
-static inline int countbits(uint32_t byte)
-{
-        int res = 0;
+        /* finally reduce par to 8 bits */
+        par ^= (par >> 8);
+        par &= 0xff;
 
-        for (;byte; byte >>= 1)
-                res += byte & 0x01;
-        return res;
+        /*
+         * and calculate rp5..rp15..rp17
+         * note that par = rp4 ^ rp5 and due to the commutative property
+         * of the ^ operator we can say:
+         * rp5 = (par ^ rp4);
+         * The & 0xff seems superfluous, but benchmarking learned that
+         * leaving it out gives slightly worse results. No idea why, probably
+         * it has to do with the way the pipeline in pentium is organized.
+         */
+        rp5 = (par ^ rp4) & 0xff;
+        rp7 = (par ^ rp6) & 0xff;
+        rp9 = (par ^ rp8) & 0xff;
+        rp11 = (par ^ rp10) & 0xff;
+        rp13 = (par ^ rp12) & 0xff;
+        rp15 = (par ^ rp14) & 0xff;
+        if (eccsize_mult == 2)
+                rp17 = (par ^ rp16) & 0xff;
+
+        /*
+         * Finally calculate the ecc bits.
+         * Again here it might seem that there are performance optimisations
+         * possible, but benchmarks showed that on the system this is developed
+         * the code below is the fastest
+         */
+#ifdef CONFIG_MTD_NAND_ECC_SMC
+        code[0] =
+            (invparity[rp7] << 7) |
+            (invparity[rp6] << 6) |
+            (invparity[rp5] << 5) |
+            (invparity[rp4] << 4) |
+            (invparity[rp3] << 3) |
+            (invparity[rp2] << 2) |
+            (invparity[rp1] << 1) |
+            (invparity[rp0]);
+        code[1] =
+            (invparity[rp15] << 7) |
+            (invparity[rp14] << 6) |
+            (invparity[rp13] << 5) |
+            (invparity[rp12] << 4) |
+            (invparity[rp11] << 3) |
+            (invparity[rp10] << 2) |
+            (invparity[rp9] << 1)  |
+            (invparity[rp8]);
+#else
+        code[1] =
+            (invparity[rp7] << 7) |
+            (invparity[rp6] << 6) |
+            (invparity[rp5] << 5) |
+            (invparity[rp4] << 4) |
+            (invparity[rp3] << 3) |
+            (invparity[rp2] << 2) |
+            (invparity[rp1] << 1) |
+            (invparity[rp0]);
+        code[0] =
+            (invparity[rp15] << 7) |
+            (invparity[rp14] << 6) |
+            (invparity[rp13] << 5) |
+            (invparity[rp12] << 4) |
+            (invparity[rp11] << 3) |
+            (invparity[rp10] << 2) |
+            (invparity[rp9] << 1)  |
+            (invparity[rp8]);
+#endif
+        if (eccsize_mult == 1)
+                code[2] =
+                    (invparity[par & 0xf0] << 7) |
+                    (invparity[par & 0x0f] << 6) |
+                    (invparity[par & 0xcc] << 5) |
+                    (invparity[par & 0x33] << 4) |
+                    (invparity[par & 0xaa] << 3) |
+                    (invparity[par & 0x55] << 2) |
+                    3;
+        else
+                code[2] =
+                    (invparity[par & 0xf0] << 7) |
+                    (invparity[par & 0x0f] << 6) |
+                    (invparity[par & 0xcc] << 5) |
+                    (invparity[par & 0x33] << 4) |
+                    (invparity[par & 0xaa] << 3) |
+                    (invparity[par & 0x55] << 2) |
+                    (invparity[rp17] << 1) |
+                    (invparity[rp16] << 0);
+        return 0;
 }
+EXPORT_SYMBOL(nand_calculate_ecc);
 
 /**
  * nand_correct_data - [NAND Interface] Detect and correct bit error(s)
  * @mtd:        MTD block structure
- * @dat:        raw data read from the chip
+ * @buf:        raw data read from the chip
  * @read_ecc:   ECC from the chip
  * @calc_ecc:   the ECC calculated from raw data
  *
- * Detect and correct a 1 bit error for 256 byte block
+ * Detect and correct a 1 bit error for 256/512 byte block
  */
-int nand_correct_data(struct mtd_info *mtd, u_char *dat,
-                      u_char *read_ecc, u_char *calc_ecc)
+int nand_correct_data(struct mtd_info *mtd, unsigned char *buf,
+                      unsigned char *read_ecc, unsigned char *calc_ecc)
 {
-        uint8_t s0, s1, s2;
+        unsigned char b0, b1, b2;
+        unsigned char byte_addr, bit_addr;
+        /* 256 or 512 bytes/ecc  */
+        const uint32_t eccsize_mult =
+                        (((struct nand_chip *)mtd->priv)->ecc.size) >> 8;
 
+        /*
+         * b0 to b2 indicate which bit is faulty (if any)
+         * we might need the xor result  more than once,
+         * so keep them in a local var
+        */
 #ifdef CONFIG_MTD_NAND_ECC_SMC
-        s0 = calc_ecc[0] ^ read_ecc[0];
-        s1 = calc_ecc[1] ^ read_ecc[1];
-        s2 = calc_ecc[2] ^ read_ecc[2];
+        b0 = read_ecc[0] ^ calc_ecc[0];
+        b1 = read_ecc[1] ^ calc_ecc[1];
 #else
-        s1 = calc_ecc[0] ^ read_ecc[0];
-        s0 = calc_ecc[1] ^ read_ecc[1];
-        s2 = calc_ecc[2] ^ read_ecc[2];
+        b0 = read_ecc[1] ^ calc_ecc[1];
+        b1 = read_ecc[0] ^ calc_ecc[0];
 #endif
-        if ((s0 | s1 | s2) == 0)
-                return 0;
-
-        /* Check for a single bit error */
-        if( ((s0 ^ (s0 >> 1)) & 0x55) == 0x55 &&
-            ((s1 ^ (s1 >> 1)) & 0x55) == 0x55 &&
-            ((s2 ^ (s2 >> 1)) & 0x54) == 0x54) {
+        b2 = read_ecc[2] ^ calc_ecc[2];
 
-                uint32_t byteoffs, bitnum;
+        /* check if there are any bitfaults */
 
-                byteoffs = (s1 << 0) & 0x80;
-                byteoffs |= (s1 << 1) & 0x40;
-                byteoffs |= (s1 << 2) & 0x20;
-                byteoffs |= (s1 << 3) & 0x10;
+        /* repeated if statements are slightly more efficient than switch ... */
+        /* ordered in order of likelihood */
 
-                byteoffs |= (s0 >> 4) & 0x08;
-                byteoffs |= (s0 >> 3) & 0x04;
-                byteoffs |= (s0 >> 2) & 0x02;
-                byteoffs |= (s0 >> 1) & 0x01;
-
-                bitnum = (s2 >> 5) & 0x04;
-                bitnum |= (s2 >> 4) & 0x02;
-                bitnum |= (s2 >> 3) & 0x01;
-
-                dat[byteoffs] ^= (1 << bitnum);
+        if ((b0 | b1 | b2) == 0)
+                return 0;       /* no error */
 
+        if ((((b0 ^ (b0 >> 1)) & 0x55) == 0x55) &&
+            (((b1 ^ (b1 >> 1)) & 0x55) == 0x55) &&
+            ((eccsize_mult == 1 && ((b2 ^ (b2 >> 1)) & 0x54) == 0x54) ||
+             (eccsize_mult == 2 && ((b2 ^ (b2 >> 1)) & 0x55) == 0x55))) {
+        /* single bit error */
+                /*
+                 * rp17/rp15/13/11/9/7/5/3/1 indicate which byte is the faulty
+                 * byte, cp 5/3/1 indicate the faulty bit.
+                 * A lookup table (called addressbits) is used to filter
+                 * the bits from the byte they are in.
+                 * A marginal optimisation is possible by having three
+                 * different lookup tables.
+                 * One as we have now (for b0), one for b2
+                 * (that would avoid the >> 1), and one for b1 (with all values
+                 * << 4). However it was felt that introducing two more tables
+                 * hardly justify the gain.
+                 *
+                 * The b2 shift is there to get rid of the lowest two bits.
+                 * We could also do addressbits[b2] >> 1 but for the
+                 * performace it does not make any difference
+                 */
+                if (eccsize_mult == 1)
+                        byte_addr = (addressbits[b1] << 4) + addressbits[b0];
+                else
+                        byte_addr = (addressbits[b2 & 0x3] << 8) +
+                                    (addressbits[b1] << 4) + addressbits[b0];
+                bit_addr = addressbits[b2 >> 2];
+                /* flip the bit */
+                buf[byte_addr] ^= (1 << bit_addr);
                 return 1;
-        }
 
-        if(countbits(s0 | ((uint32_t)s1 << 8) | ((uint32_t)s2 <<16)) == 1)
-                return 1;
+        }
+        /* count nr of bits; use table lookup, faster than calculating it */
+        if ((bitsperbyte[b0] + bitsperbyte[b1] + bitsperbyte[b2]) == 1)
+                return 1;       /* error in ecc data; no action needed */
 
-        return -EBADMSG;
+        printk(KERN_ERR "uncorrectable error : ");
+        return -1;
 }
 EXPORT_SYMBOL(nand_correct_data);
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Steven J. Hill <sjhill@realitydiluted.com>");
+MODULE_AUTHOR("Frans Meulenbroeks <fransmeulenbroeks@gmail.com>");
 MODULE_DESCRIPTION("Generic NAND ECC support");
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index 556e8131ecdc..ae7c57781a68 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -38,7 +38,6 @@
 #include <linux/delay.h>
 #include <linux/list.h>
 #include <linux/random.h>
-#include <asm/div64.h>
 
 /* Default simulator parameters values */
 #if !defined(CONFIG_NANDSIM_FIRST_ID_BYTE)  || \
diff --git a/drivers/mtd/nand/pxa3xx_nand.c b/drivers/mtd/nand/pxa3xx_nand.c
index a64ad15b8fdd..c0fa9c9edf08 100644
--- a/drivers/mtd/nand/pxa3xx_nand.c
+++ b/drivers/mtd/nand/pxa3xx_nand.c
@@ -115,55 +115,11 @@ enum {
         STATE_PIO_WRITING,
 };
 
-struct pxa3xx_nand_timing {
-        unsigned int    tCH;  /* Enable signal hold time */
-        unsigned int    tCS;  /* Enable signal setup time */
-        unsigned int    tWH;  /* ND_nWE high duration */
-        unsigned int    tWP;  /* ND_nWE pulse time */
-        unsigned int    tRH;  /* ND_nRE high duration */
-        unsigned int    tRP;  /* ND_nRE pulse width */
-        unsigned int    tR;   /* ND_nWE high to ND_nRE low for read */
-        unsigned int    tWHR; /* ND_nWE high to ND_nRE low for status read */
-        unsigned int    tAR;  /* ND_ALE low to ND_nRE low delay */
-};
-
-struct pxa3xx_nand_cmdset {
-        uint16_t        read1;
-        uint16_t        read2;
-        uint16_t        program;
-        uint16_t        read_status;
-        uint16_t        read_id;
-        uint16_t        erase;
-        uint16_t        reset;
-        uint16_t        lock;
-        uint16_t        unlock;
-        uint16_t        lock_status;
-};
-
-struct pxa3xx_nand_flash {
-        struct pxa3xx_nand_timing *timing; /* NAND Flash timing */
-        struct pxa3xx_nand_cmdset *cmdset;
-
-        uint32_t page_per_block;/* Pages per block (PG_PER_BLK) */
-        uint32_t page_size;     /* Page size in bytes (PAGE_SZ) */
-        uint32_t flash_width;   /* Width of Flash memory (DWIDTH_M) */
-        uint32_t dfc_width;     /* Width of flash controller(DWIDTH_C) */
-        uint32_t num_blocks;    /* Number of physical blocks in Flash */
-        uint32_t chip_id;
-
-        /* NOTE: these are automatically calculated, do not define */
-        size_t          oob_size;
-        size_t          read_id_bytes;
-
-        unsigned int    col_addr_cycles;
-        unsigned int    row_addr_cycles;
-};
-
 struct pxa3xx_nand_info {
         struct nand_chip        nand_chip;
 
         struct platform_device   *pdev;
-        struct pxa3xx_nand_flash *flash_info;
+        const struct pxa3xx_nand_flash *flash_info;
 
         struct clk              *clk;
         void __iomem            *mmio_base;
@@ -202,12 +158,20 @@ struct pxa3xx_nand_info {
         uint32_t                ndcb0;
         uint32_t                ndcb1;
         uint32_t                ndcb2;
+
+        /* calculated from pxa3xx_nand_flash data */
+        size_t          oob_size;
+        size_t          read_id_bytes;
+
+        unsigned int    col_addr_cycles;
+        unsigned int    row_addr_cycles;
 };
 
 static int use_dma = 1;
 module_param(use_dma, bool, 0444);
 MODULE_PARM_DESC(use_dma, "enable DMA for data transfering to/from NAND HW");
 
+#ifdef CONFIG_MTD_NAND_PXA3xx_BUILTIN
 static struct pxa3xx_nand_cmdset smallpage_cmdset = {
         .read1          = 0x0000,
         .read2          = 0x0050,
@@ -291,11 +255,35 @@ static struct pxa3xx_nand_flash micron1GbX16 = {
         .chip_id        = 0xb12c,
 };
 
+static struct pxa3xx_nand_timing stm2GbX16_timing = {
+        .tCH = 10,
+        .tCS = 35,
+        .tWH = 15,
+        .tWP = 25,
+        .tRH = 15,
+        .tRP = 25,
+        .tR = 25000,
+        .tWHR = 60,
+        .tAR = 10,
+};
+
+static struct pxa3xx_nand_flash stm2GbX16 = {
+        .timing = &stm2GbX16_timing,
+        .page_per_block = 64,
+        .page_size = 2048,
+        .flash_width = 16,
+        .dfc_width = 16,
+        .num_blocks = 2048,
+        .chip_id = 0xba20,
+};
+
 static struct pxa3xx_nand_flash *builtin_flash_types[] = {
         &samsung512MbX16,
         &micron1GbX8,
         &micron1GbX16,
+        &stm2GbX16,
 };
+#endif /* CONFIG_MTD_NAND_PXA3xx_BUILTIN */
 
 #define NDTR0_tCH(c)    (min((c), 7) << 19)
 #define NDTR0_tCS(c)    (min((c), 7) << 16)
@@ -312,7 +300,7 @@ static struct pxa3xx_nand_flash *builtin_flash_types[] = {
 #define ns2cycle(ns, clk)       (int)(((ns) * (clk / 1000000) / 1000) + 1)
 
 static void pxa3xx_nand_set_timing(struct pxa3xx_nand_info *info,
-                                   struct pxa3xx_nand_timing *t)
+                                   const struct pxa3xx_nand_timing *t)
 {
         unsigned long nand_clk = clk_get_rate(info->clk);
         uint32_t ndtr0, ndtr1;
@@ -354,8 +342,8 @@ static int wait_for_event(struct pxa3xx_nand_info *info, uint32_t event)
 static int prepare_read_prog_cmd(struct pxa3xx_nand_info *info,
                         uint16_t cmd, int column, int page_addr)
 {
-        struct pxa3xx_nand_flash *f = info->flash_info;
-        struct pxa3xx_nand_cmdset *cmdset = f->cmdset;
+        const struct pxa3xx_nand_flash *f = info->flash_info;
+        const struct pxa3xx_nand_cmdset *cmdset = f->cmdset;
 
         /* calculate data size */
         switch (f->page_size) {
@@ -373,14 +361,14 @@ static int prepare_read_prog_cmd(struct pxa3xx_nand_info *info,
         info->ndcb0 = cmd | ((cmd & 0xff00) ? NDCB0_DBC : 0);
         info->ndcb1 = 0;
         info->ndcb2 = 0;
-        info->ndcb0 |= NDCB0_ADDR_CYC(f->row_addr_cycles + f->col_addr_cycles);
+        info->ndcb0 |= NDCB0_ADDR_CYC(info->row_addr_cycles + info->col_addr_cycles);
 
-        if (f->col_addr_cycles == 2) {
+        if (info->col_addr_cycles == 2) {
                 /* large block, 2 cycles for column address
                  * row address starts from 3rd cycle
                  */
                 info->ndcb1 |= (page_addr << 16) | (column & 0xffff);
-                if (f->row_addr_cycles == 3)
+                if (info->row_addr_cycles == 3)
                         info->ndcb2 = (page_addr >> 16) & 0xff;
         } else
                 /* small block, 1 cycles for column address
@@ -406,7 +394,7 @@ static int prepare_erase_cmd(struct pxa3xx_nand_info *info,
 
 static int prepare_other_cmd(struct pxa3xx_nand_info *info, uint16_t cmd)
 {
-        struct pxa3xx_nand_cmdset *cmdset = info->flash_info->cmdset;
+        const struct pxa3xx_nand_cmdset *cmdset = info->flash_info->cmdset;
 
         info->ndcb0 = cmd | ((cmd & 0xff00) ? NDCB0_DBC : 0);
         info->ndcb1 = 0;
@@ -641,8 +629,8 @@ static void pxa3xx_nand_cmdfunc(struct mtd_info *mtd, unsigned command,
                                 int column, int page_addr)
 {
         struct pxa3xx_nand_info *info = mtd->priv;
-        struct pxa3xx_nand_flash *flash_info = info->flash_info;
-        struct pxa3xx_nand_cmdset *cmdset = flash_info->cmdset;
+        const struct pxa3xx_nand_flash *flash_info = info->flash_info;
+        const struct pxa3xx_nand_cmdset *cmdset = flash_info->cmdset;
         int ret;
 
         info->use_dma = (use_dma) ? 1 : 0;
@@ -720,7 +708,7 @@ static void pxa3xx_nand_cmdfunc(struct mtd_info *mtd, unsigned command,
                 info->use_dma = 0;      /* force PIO read */
                 info->buf_start = 0;
                 info->buf_count = (command == NAND_CMD_READID) ?
-                                flash_info->read_id_bytes : 1;
+                                info->read_id_bytes : 1;
 
                 if (prepare_other_cmd(info, (command == NAND_CMD_READID) ?
                                 cmdset->read_id : cmdset->read_status))
@@ -861,8 +849,8 @@ static int pxa3xx_nand_ecc_correct(struct mtd_info *mtd,
 
 static int __readid(struct pxa3xx_nand_info *info, uint32_t *id)
 {
-        struct pxa3xx_nand_flash *f = info->flash_info;
-        struct pxa3xx_nand_cmdset *cmdset = f->cmdset;
+        const struct pxa3xx_nand_flash *f = info->flash_info;
+        const struct pxa3xx_nand_cmdset *cmdset = f->cmdset;
         uint32_t ndcr;
         uint8_t  id_buff[8];
 
@@ -891,7 +879,7 @@ fail_timeout:
 }
 
 static int pxa3xx_nand_config_flash(struct pxa3xx_nand_info *info,
-                                    struct pxa3xx_nand_flash *f)
+                                    const struct pxa3xx_nand_flash *f)
 {
         struct platform_device *pdev = info->pdev;
         struct pxa3xx_nand_platform_data *pdata = pdev->dev.platform_data;
@@ -904,25 +892,25 @@ static int pxa3xx_nand_config_flash(struct pxa3xx_nand_info *info,
                 return -EINVAL;
 
         /* calculate flash information */
-        f->oob_size = (f->page_size == 2048) ? 64 : 16;
-        f->read_id_bytes = (f->page_size == 2048) ? 4 : 2;
+        info->oob_size = (f->page_size == 2048) ? 64 : 16;
+        info->read_id_bytes = (f->page_size == 2048) ? 4 : 2;
 
         /* calculate addressing information */
-        f->col_addr_cycles = (f->page_size == 2048) ? 2 : 1;
+        info->col_addr_cycles = (f->page_size == 2048) ? 2 : 1;
 
         if (f->num_blocks * f->page_per_block > 65536)
-                f->row_addr_cycles = 3;
+                info->row_addr_cycles = 3;
         else
-                f->row_addr_cycles = 2;
+                info->row_addr_cycles = 2;
 
         ndcr |= (pdata->enable_arbiter) ? NDCR_ND_ARB_EN : 0;
-        ndcr |= (f->col_addr_cycles == 2) ? NDCR_RA_START : 0;
+        ndcr |= (info->col_addr_cycles == 2) ? NDCR_RA_START : 0;
         ndcr |= (f->page_per_block == 64) ? NDCR_PG_PER_BLK : 0;
         ndcr |= (f->page_size == 2048) ? NDCR_PAGE_SZ : 0;
         ndcr |= (f->flash_width == 16) ? NDCR_DWIDTH_M : 0;
         ndcr |= (f->dfc_width == 16) ? NDCR_DWIDTH_C : 0;
 
-        ndcr |= NDCR_RD_ID_CNT(f->read_id_bytes);
+        ndcr |= NDCR_RD_ID_CNT(info->read_id_bytes);
         ndcr |= NDCR_SPARE_EN; /* enable spare by default */
 
         info->reg_ndcr = ndcr;
@@ -932,12 +920,27 @@ static int pxa3xx_nand_config_flash(struct pxa3xx_nand_info *info,
         return 0;
 }
 
-static int pxa3xx_nand_detect_flash(struct pxa3xx_nand_info *info)
+static int pxa3xx_nand_detect_flash(struct pxa3xx_nand_info *info,
+                                    const struct pxa3xx_nand_platform_data *pdata)
 {
-        struct pxa3xx_nand_flash *f;
-        uint32_t id;
+        const struct pxa3xx_nand_flash *f;
+        uint32_t id = -1;
         int i;
 
+        for (i = 0; i<pdata->num_flash; ++i) {
+                f = pdata->flash + i;
+
+                if (pxa3xx_nand_config_flash(info, f))
+                        continue;
+
+                if (__readid(info, &id))
+                        continue;
+
+                if (id == f->chip_id)
+                        return 0;
+        }
+
+#ifdef CONFIG_MTD_NAND_PXA3xx_BUILTIN
         for (i = 0; i < ARRAY_SIZE(builtin_flash_types); i++) {
 
                 f = builtin_flash_types[i];
@@ -951,7 +954,11 @@ static int pxa3xx_nand_detect_flash(struct pxa3xx_nand_info *info)
                 if (id == f->chip_id)
                         return 0;
         }
+#endif
 
+        dev_warn(&info->pdev->dev,
+                 "failed to detect configured nand flash; found %04x instead of\n",
+                 id);
         return -ENODEV;
 }
 
@@ -1014,7 +1021,7 @@ static struct nand_ecclayout hw_largepage_ecclayout = {
 static void pxa3xx_nand_init_mtd(struct mtd_info *mtd,
                                  struct pxa3xx_nand_info *info)
 {
-        struct pxa3xx_nand_flash *f = info->flash_info;
+        const struct pxa3xx_nand_flash *f = info->flash_info;
         struct nand_chip *this = &info->nand_chip;
 
         this->options = (f->flash_width == 16) ? NAND_BUSWIDTH_16: 0;
@@ -1135,7 +1142,7 @@ static int pxa3xx_nand_probe(struct platform_device *pdev)
                 goto fail_free_buf;
         }
 
-        ret = pxa3xx_nand_detect_flash(info);
+        ret = pxa3xx_nand_detect_flash(info, pdata);
         if (ret) {
                 dev_err(&pdev->dev, "failed to detect flash\n");
                 ret = -ENODEV;
diff --git a/drivers/mtd/nand/sh_flctl.c b/drivers/mtd/nand/sh_flctl.c
new file mode 100644
index 000000000000..821acb08ff1c
--- /dev/null
+++ b/drivers/mtd/nand/sh_flctl.c
@@ -0,0 +1,878 @@
+/*
+ * SuperH FLCTL nand controller
+ *
+ * Copyright © 2008 Renesas Solutions Corp.
+ * Copyright © 2008 Atom Create Engineering Co., Ltd.
+ *
+ * Based on fsl_elbc_nand.c, Copyright © 2006-2007 Freescale Semiconductor
+ *
+ * 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; version 2 of the License.
+ *
+ * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <linux/mtd/sh_flctl.h>
+
+static struct nand_ecclayout flctl_4secc_oob_16 = {
+        .eccbytes = 10,
+        .eccpos = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+        .oobfree = {
+                {.offset = 12,
+                . length = 4} },
+};
+
+static struct nand_ecclayout flctl_4secc_oob_64 = {
+        .eccbytes = 10,
+        .eccpos = {48, 49, 50, 51, 52, 53, 54, 55, 56, 57},
+        .oobfree = {
+                {.offset = 60,
+                . length = 4} },
+};
+
+static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
+
+static struct nand_bbt_descr flctl_4secc_smallpage = {
+        .options = NAND_BBT_SCAN2NDPAGE,
+        .offs = 11,
+        .len = 1,
+        .pattern = scan_ff_pattern,
+};
+
+static struct nand_bbt_descr flctl_4secc_largepage = {
+        .options = 0,
+        .offs = 58,
+        .len = 2,
+        .pattern = scan_ff_pattern,
+};
+
+static void empty_fifo(struct sh_flctl *flctl)
+{
+        writel(0x000c0000, FLINTDMACR(flctl));  /* FIFO Clear */
+        writel(0x00000000, FLINTDMACR(flctl));  /* Clear Error flags */
+}
+
+static void start_translation(struct sh_flctl *flctl)
+{
+        writeb(TRSTRT, FLTRCR(flctl));
+}
+
+static void wait_completion(struct sh_flctl *flctl)
+{
+        uint32_t timeout = LOOP_TIMEOUT_MAX;
+
+        while (timeout--) {
+                if (readb(FLTRCR(flctl)) & TREND) {
+                        writeb(0x0, FLTRCR(flctl));
+                        return;
+                }
+                udelay(1);
+        }
+
+        printk(KERN_ERR "wait_completion(): Timeout occured \n");
+        writeb(0x0, FLTRCR(flctl));
+}
+
+static void set_addr(struct mtd_info *mtd, int column, int page_addr)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        uint32_t addr = 0;
+
+        if (column == -1) {
+                addr = page_addr;       /* ERASE1 */
+        } else if (page_addr != -1) {
+                /* SEQIN, READ0, etc.. */
+                if (flctl->page_size) {
+                        addr = column & 0x0FFF;
+                        addr |= (page_addr & 0xff) << 16;
+                        addr |= ((page_addr >> 8) & 0xff) << 24;
+                        /* big than 128MB */
+                        if (flctl->rw_ADRCNT == ADRCNT2_E) {
+                                uint32_t        addr2;
+                                addr2 = (page_addr >> 16) & 0xff;
+                                writel(addr2, FLADR2(flctl));
+                        }
+                } else {
+                        addr = column;
+                        addr |= (page_addr & 0xff) << 8;
+                        addr |= ((page_addr >> 8) & 0xff) << 16;
+                        addr |= ((page_addr >> 16) & 0xff) << 24;
+                }
+        }
+        writel(addr, FLADR(flctl));
+}
+
+static void wait_rfifo_ready(struct sh_flctl *flctl)
+{
+        uint32_t timeout = LOOP_TIMEOUT_MAX;
+
+        while (timeout--) {
+                uint32_t val;
+                /* check FIFO */
+                val = readl(FLDTCNTR(flctl)) >> 16;
+                if (val & 0xFF)
+                        return;
+                udelay(1);
+        }
+        printk(KERN_ERR "wait_rfifo_ready(): Timeout occured \n");
+}
+
+static void wait_wfifo_ready(struct sh_flctl *flctl)
+{
+        uint32_t len, timeout = LOOP_TIMEOUT_MAX;
+
+        while (timeout--) {
+                /* check FIFO */
+                len = (readl(FLDTCNTR(flctl)) >> 16) & 0xFF;
+                if (len >= 4)
+                        return;
+                udelay(1);
+        }
+        printk(KERN_ERR "wait_wfifo_ready(): Timeout occured \n");
+}
+
+static int wait_recfifo_ready(struct sh_flctl *flctl)
+{
+        uint32_t timeout = LOOP_TIMEOUT_MAX;
+        int checked[4];
+        void __iomem *ecc_reg[4];
+        int i;
+        uint32_t data, size;
+
+        memset(checked, 0, sizeof(checked));
+
+        while (timeout--) {
+                size = readl(FLDTCNTR(flctl)) >> 24;
+                if (size & 0xFF)
+                        return 0;       /* success */
+
+                if (readl(FL4ECCCR(flctl)) & _4ECCFA)
+                        return 1;       /* can't correct */
+
+                udelay(1);
+                if (!(readl(FL4ECCCR(flctl)) & _4ECCEND))
+                        continue;
+
+                /* start error correction */
+                ecc_reg[0] = FL4ECCRESULT0(flctl);
+                ecc_reg[1] = FL4ECCRESULT1(flctl);
+                ecc_reg[2] = FL4ECCRESULT2(flctl);
+                ecc_reg[3] = FL4ECCRESULT3(flctl);
+
+                for (i = 0; i < 3; i++) {
+                        data = readl(ecc_reg[i]);
+                        if (data != INIT_FL4ECCRESULT_VAL && !checked[i]) {
+                                uint8_t org;
+                                int index;
+
+                                index = data >> 16;
+                                org = flctl->done_buff[index];
+                                flctl->done_buff[index] = org ^ (data & 0xFF);
+                                checked[i] = 1;
+                        }
+                }
+
+                writel(0, FL4ECCCR(flctl));
+        }
+
+        printk(KERN_ERR "wait_recfifo_ready(): Timeout occured \n");
+        return 1;       /* timeout */
+}
+
+static void wait_wecfifo_ready(struct sh_flctl *flctl)
+{
+        uint32_t timeout = LOOP_TIMEOUT_MAX;
+        uint32_t len;
+
+        while (timeout--) {
+                /* check FLECFIFO */
+                len = (readl(FLDTCNTR(flctl)) >> 24) & 0xFF;
+                if (len >= 4)
+                        return;
+                udelay(1);
+        }
+        printk(KERN_ERR "wait_wecfifo_ready(): Timeout occured \n");
+}
+
+static void read_datareg(struct sh_flctl *flctl, int offset)
+{
+        unsigned long data;
+        unsigned long *buf = (unsigned long *)&flctl->done_buff[offset];
+
+        wait_completion(flctl);
+
+        data = readl(FLDATAR(flctl));
+        *buf = le32_to_cpu(data);
+}
+
+static void read_fiforeg(struct sh_flctl *flctl, int rlen, int offset)
+{
+        int i, len_4align;
+        unsigned long *buf = (unsigned long *)&flctl->done_buff[offset];
+        void *fifo_addr = (void *)FLDTFIFO(flctl);
+
+        len_4align = (rlen + 3) / 4;
+
+        for (i = 0; i < len_4align; i++) {
+                wait_rfifo_ready(flctl);
+                buf[i] = readl(fifo_addr);
+                buf[i] = be32_to_cpu(buf[i]);
+        }
+}
+
+static int read_ecfiforeg(struct sh_flctl *flctl, uint8_t *buff)
+{
+        int i;
+        unsigned long *ecc_buf = (unsigned long *)buff;
+        void *fifo_addr = (void *)FLECFIFO(flctl);
+
+        for (i = 0; i < 4; i++) {
+                if (wait_recfifo_ready(flctl))
+                        return 1;
+                ecc_buf[i] = readl(fifo_addr);
+                ecc_buf[i] = be32_to_cpu(ecc_buf[i]);
+        }
+
+        return 0;
+}
+
+static void write_fiforeg(struct sh_flctl *flctl, int rlen, int offset)
+{
+        int i, len_4align;
+        unsigned long *data = (unsigned long *)&flctl->done_buff[offset];
+        void *fifo_addr = (void *)FLDTFIFO(flctl);
+
+        len_4align = (rlen + 3) / 4;
+        for (i = 0; i < len_4align; i++) {
+                wait_wfifo_ready(flctl);
+                writel(cpu_to_be32(data[i]), fifo_addr);
+        }
+}
+
+static void set_cmd_regs(struct mtd_info *mtd, uint32_t cmd, uint32_t flcmcdr_val)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        uint32_t flcmncr_val = readl(FLCMNCR(flctl));
+        uint32_t flcmdcr_val, addr_len_bytes = 0;
+
+        /* Set SNAND bit if page size is 2048byte */
+        if (flctl->page_size)
+                flcmncr_val |= SNAND_E;
+        else
+                flcmncr_val &= ~SNAND_E;
+
+        /* default FLCMDCR val */
+        flcmdcr_val = DOCMD1_E | DOADR_E;
+
+        /* Set for FLCMDCR */
+        switch (cmd) {
+        case NAND_CMD_ERASE1:
+                addr_len_bytes = flctl->erase_ADRCNT;
+                flcmdcr_val |= DOCMD2_E;
+                break;
+        case NAND_CMD_READ0:
+        case NAND_CMD_READOOB:
+                addr_len_bytes = flctl->rw_ADRCNT;
+                flcmdcr_val |= CDSRC_E;
+                break;
+        case NAND_CMD_SEQIN:
+                /* This case is that cmd is READ0 or READ1 or READ00 */
+                flcmdcr_val &= ~DOADR_E;        /* ONLY execute 1st cmd */
+                break;
+        case NAND_CMD_PAGEPROG:
+                addr_len_bytes = flctl->rw_ADRCNT;
+                flcmdcr_val |= DOCMD2_E | CDSRC_E | SELRW;
+                break;
+        case NAND_CMD_READID:
+                flcmncr_val &= ~SNAND_E;
+                addr_len_bytes = ADRCNT_1;
+                break;
+        case NAND_CMD_STATUS:
+        case NAND_CMD_RESET:
+                flcmncr_val &= ~SNAND_E;
+                flcmdcr_val &= ~(DOADR_E | DOSR_E);
+                break;
+        default:
+                break;
+        }
+
+        /* Set address bytes parameter */
+        flcmdcr_val |= addr_len_bytes;
+
+        /* Now actually write */
+        writel(flcmncr_val, FLCMNCR(flctl));
+        writel(flcmdcr_val, FLCMDCR(flctl));
+        writel(flcmcdr_val, FLCMCDR(flctl));
+}
+
+static int flctl_read_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
+                                uint8_t *buf)
+{
+        int i, eccsize = chip->ecc.size;
+        int eccbytes = chip->ecc.bytes;
+        int eccsteps = chip->ecc.steps;
+        uint8_t *p = buf;
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
+                chip->read_buf(mtd, p, eccsize);
+
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
+                if (flctl->hwecc_cant_correct[i])
+                        mtd->ecc_stats.failed++;
+                else
+                        mtd->ecc_stats.corrected += 0;
+        }
+
+        return 0;
+}
+
+static void flctl_write_page_hwecc(struct mtd_info *mtd, struct nand_chip *chip,
+                                   const uint8_t *buf)
+{
+        int i, eccsize = chip->ecc.size;
+        int eccbytes = chip->ecc.bytes;
+        int eccsteps = chip->ecc.steps;
+        const uint8_t *p = buf;
+
+        for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize)
+                chip->write_buf(mtd, p, eccsize);
+}
+
+static void execmd_read_page_sector(struct mtd_info *mtd, int page_addr)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        int sector, page_sectors;
+
+        if (flctl->page_size)
+                page_sectors = 4;
+        else
+                page_sectors = 1;
+
+        writel(readl(FLCMNCR(flctl)) | ACM_SACCES_MODE | _4ECCCORRECT,
+                 FLCMNCR(flctl));
+
+        set_cmd_regs(mtd, NAND_CMD_READ0,
+                (NAND_CMD_READSTART << 8) | NAND_CMD_READ0);
+
+        for (sector = 0; sector < page_sectors; sector++) {
+                int ret;
+
+                empty_fifo(flctl);
+                writel(readl(FLCMDCR(flctl)) | 1, FLCMDCR(flctl));
+                writel(page_addr << 2 | sector, FLADR(flctl));
+
+                start_translation(flctl);
+                read_fiforeg(flctl, 512, 512 * sector);
+
+                ret = read_ecfiforeg(flctl,
+                        &flctl->done_buff[mtd->writesize + 16 * sector]);
+
+                if (ret)
+                        flctl->hwecc_cant_correct[sector] = 1;
+
+                writel(0x0, FL4ECCCR(flctl));
+                wait_completion(flctl);
+        }
+        writel(readl(FLCMNCR(flctl)) & ~(ACM_SACCES_MODE | _4ECCCORRECT),
+                        FLCMNCR(flctl));
+}
+
+static void execmd_read_oob(struct mtd_info *mtd, int page_addr)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+
+        set_cmd_regs(mtd, NAND_CMD_READ0,
+                (NAND_CMD_READSTART << 8) | NAND_CMD_READ0);
+
+        empty_fifo(flctl);
+        if (flctl->page_size) {
+                int i;
+                /* In case that the page size is 2k */
+                for (i = 0; i < 16 * 3; i++)
+                        flctl->done_buff[i] = 0xFF;
+
+                set_addr(mtd, 3 * 528 + 512, page_addr);
+                writel(16, FLDTCNTR(flctl));
+
+                start_translation(flctl);
+                read_fiforeg(flctl, 16, 16 * 3);
+                wait_completion(flctl);
+        } else {
+                /* In case that the page size is 512b */
+                set_addr(mtd, 512, page_addr);
+                writel(16, FLDTCNTR(flctl));
+
+                start_translation(flctl);
+                read_fiforeg(flctl, 16, 0);
+                wait_completion(flctl);
+        }
+}
+
+static void execmd_write_page_sector(struct mtd_info *mtd)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        int i, page_addr = flctl->seqin_page_addr;
+        int sector, page_sectors;
+
+        if (flctl->page_size)
+                page_sectors = 4;
+        else
+                page_sectors = 1;
+
+        writel(readl(FLCMNCR(flctl)) | ACM_SACCES_MODE, FLCMNCR(flctl));
+
+        set_cmd_regs(mtd, NAND_CMD_PAGEPROG,
+                        (NAND_CMD_PAGEPROG << 8) | NAND_CMD_SEQIN);
+
+        for (sector = 0; sector < page_sectors; sector++) {
+                empty_fifo(flctl);
+                writel(readl(FLCMDCR(flctl)) | 1, FLCMDCR(flctl));
+                writel(page_addr << 2 | sector, FLADR(flctl));
+
+                start_translation(flctl);
+                write_fiforeg(flctl, 512, 512 * sector);
+
+                for (i = 0; i < 4; i++) {
+                        wait_wecfifo_ready(flctl); /* wait for write ready */
+                        writel(0xFFFFFFFF, FLECFIFO(flctl));
+                }
+                wait_completion(flctl);
+        }
+
+        writel(readl(FLCMNCR(flctl)) & ~ACM_SACCES_MODE, FLCMNCR(flctl));
+}
+
+static void execmd_write_oob(struct mtd_info *mtd)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        int page_addr = flctl->seqin_page_addr;
+        int sector, page_sectors;
+
+        if (flctl->page_size) {
+                sector = 3;
+                page_sectors = 4;
+        } else {
+                sector = 0;
+                page_sectors = 1;
+        }
+
+        set_cmd_regs(mtd, NAND_CMD_PAGEPROG,
+                        (NAND_CMD_PAGEPROG << 8) | NAND_CMD_SEQIN);
+
+        for (; sector < page_sectors; sector++) {
+                empty_fifo(flctl);
+                set_addr(mtd, sector * 528 + 512, page_addr);
+                writel(16, FLDTCNTR(flctl));    /* set read size */
+
+                start_translation(flctl);
+                write_fiforeg(flctl, 16, 16 * sector);
+                wait_completion(flctl);
+        }
+}
+
+static void flctl_cmdfunc(struct mtd_info *mtd, unsigned int command,
+                        int column, int page_addr)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        uint32_t read_cmd = 0;
+
+        flctl->read_bytes = 0;
+        if (command != NAND_CMD_PAGEPROG)
+                flctl->index = 0;
+
+        switch (command) {
+        case NAND_CMD_READ1:
+        case NAND_CMD_READ0:
+                if (flctl->hwecc) {
+                        /* read page with hwecc */
+                        execmd_read_page_sector(mtd, page_addr);
+                        break;
+                }
+                empty_fifo(flctl);
+                if (flctl->page_size)
+                        set_cmd_regs(mtd, command, (NAND_CMD_READSTART << 8)
+                                | command);
+                else
+                        set_cmd_regs(mtd, command, command);
+
+                set_addr(mtd, 0, page_addr);
+
+                flctl->read_bytes = mtd->writesize + mtd->oobsize;
+                flctl->index += column;
+                goto read_normal_exit;
+
+        case NAND_CMD_READOOB:
+                if (flctl->hwecc) {
+                        /* read page with hwecc */
+                        execmd_read_oob(mtd, page_addr);
+                        break;
+                }
+
+                empty_fifo(flctl);
+                if (flctl->page_size) {
+                        set_cmd_regs(mtd, command, (NAND_CMD_READSTART << 8)
+                                | NAND_CMD_READ0);
+                        set_addr(mtd, mtd->writesize, page_addr);
+                } else {
+                        set_cmd_regs(mtd, command, command);
+                        set_addr(mtd, 0, page_addr);
+                }
+                flctl->read_bytes = mtd->oobsize;
+                goto read_normal_exit;
+
+        case NAND_CMD_READID:
+                empty_fifo(flctl);
+                set_cmd_regs(mtd, command, command);
+                set_addr(mtd, 0, 0);
+
+                flctl->read_bytes = 4;
+                writel(flctl->read_bytes, FLDTCNTR(flctl)); /* set read size */
+                start_translation(flctl);
+                read_datareg(flctl, 0); /* read and end */
+                break;
+
+        case NAND_CMD_ERASE1:
+                flctl->erase1_page_addr = page_addr;
+                break;
+
+        case NAND_CMD_ERASE2:
+                set_cmd_regs(mtd, NAND_CMD_ERASE1,
+                        (command << 8) | NAND_CMD_ERASE1);
+                set_addr(mtd, -1, flctl->erase1_page_addr);
+                start_translation(flctl);
+                wait_completion(flctl);
+                break;
+
+        case NAND_CMD_SEQIN:
+                if (!flctl->page_size) {
+                        /* output read command */
+                        if (column >= mtd->writesize) {
+                                column -= mtd->writesize;
+                                read_cmd = NAND_CMD_READOOB;
+                        } else if (column < 256) {
+                                read_cmd = NAND_CMD_READ0;
+                        } else {
+                                column -= 256;
+                                read_cmd = NAND_CMD_READ1;
+                        }
+                }
+                flctl->seqin_column = column;
+                flctl->seqin_page_addr = page_addr;
+                flctl->seqin_read_cmd = read_cmd;
+                break;
+
+        case NAND_CMD_PAGEPROG:
+                empty_fifo(flctl);
+                if (!flctl->page_size) {
+                        set_cmd_regs(mtd, NAND_CMD_SEQIN,
+                                        flctl->seqin_read_cmd);
+                        set_addr(mtd, -1, -1);
+                        writel(0, FLDTCNTR(flctl));     /* set 0 size */
+                        start_translation(flctl);
+                        wait_completion(flctl);
+                }
+                if (flctl->hwecc) {
+                        /* write page with hwecc */
+                        if (flctl->seqin_column == mtd->writesize)
+                                execmd_write_oob(mtd);
+                        else if (!flctl->seqin_column)
+                                execmd_write_page_sector(mtd);
+                        else
+                                printk(KERN_ERR "Invalid address !?\n");
+                        break;
+                }
+                set_cmd_regs(mtd, command, (command << 8) | NAND_CMD_SEQIN);
+                set_addr(mtd, flctl->seqin_column, flctl->seqin_page_addr);
+                writel(flctl->index, FLDTCNTR(flctl));  /* set write size */
+                start_translation(flctl);
+                write_fiforeg(flctl, flctl->index, 0);
+                wait_completion(flctl);
+                break;
+
+        case NAND_CMD_STATUS:
+                set_cmd_regs(mtd, command, command);
+                set_addr(mtd, -1, -1);
+
+                flctl->read_bytes = 1;
+                writel(flctl->read_bytes, FLDTCNTR(flctl)); /* set read size */
+                start_translation(flctl);
+                read_datareg(flctl, 0); /* read and end */
+                break;
+
+        case NAND_CMD_RESET:
+                set_cmd_regs(mtd, command, command);
+                set_addr(mtd, -1, -1);
+
+                writel(0, FLDTCNTR(flctl));     /* set 0 size */
+                start_translation(flctl);
+                wait_completion(flctl);
+                break;
+
+        default:
+                break;
+        }
+        return;
+
+read_normal_exit:
+        writel(flctl->read_bytes, FLDTCNTR(flctl));     /* set read size */
+        start_translation(flctl);
+        read_fiforeg(flctl, flctl->read_bytes, 0);
+        wait_completion(flctl);
+        return;
+}
+
+static void flctl_select_chip(struct mtd_info *mtd, int chipnr)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        uint32_t flcmncr_val = readl(FLCMNCR(flctl));
+
+        switch (chipnr) {
+        case -1:
+                flcmncr_val &= ~CE0_ENABLE;
+                writel(flcmncr_val, FLCMNCR(flctl));
+                break;
+        case 0:
+                flcmncr_val |= CE0_ENABLE;
+                writel(flcmncr_val, FLCMNCR(flctl));
+                break;
+        default:
+                BUG();
+        }
+}
+
+static void flctl_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        int i, index = flctl->index;
+
+        for (i = 0; i < len; i++)
+                flctl->done_buff[index + i] = buf[i];
+        flctl->index += len;
+}
+
+static uint8_t flctl_read_byte(struct mtd_info *mtd)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        int index = flctl->index;
+        uint8_t data;
+
+        data = flctl->done_buff[index];
+        flctl->index++;
+        return data;
+}
+
+static void flctl_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
+{
+        int i;
+
+        for (i = 0; i < len; i++)
+                buf[i] = flctl_read_byte(mtd);
+}
+
+static int flctl_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
+{
+        int i;
+
+        for (i = 0; i < len; i++)
+                if (buf[i] != flctl_read_byte(mtd))
+                        return -EFAULT;
+        return 0;
+}
+
+static void flctl_register_init(struct sh_flctl *flctl, unsigned long val)
+{
+        writel(val, FLCMNCR(flctl));
+}
+
+static int flctl_chip_init_tail(struct mtd_info *mtd)
+{
+        struct sh_flctl *flctl = mtd_to_flctl(mtd);
+        struct nand_chip *chip = &flctl->chip;
+
+        if (mtd->writesize == 512) {
+                flctl->page_size = 0;
+                if (chip->chipsize > (32 << 20)) {
+                        /* big than 32MB */
+                        flctl->rw_ADRCNT = ADRCNT_4;
+                        flctl->erase_ADRCNT = ADRCNT_3;
+                } else if (chip->chipsize > (2 << 16)) {
+                        /* big than 128KB */
+                        flctl->rw_ADRCNT = ADRCNT_3;
+                        flctl->erase_ADRCNT = ADRCNT_2;
+                } else {
+                        flctl->rw_ADRCNT = ADRCNT_2;
+                        flctl->erase_ADRCNT = ADRCNT_1;
+                }
+        } else {
+                flctl->page_size = 1;
+                if (chip->chipsize > (128 << 20)) {
+                        /* big than 128MB */
+                        flctl->rw_ADRCNT = ADRCNT2_E;
+                        flctl->erase_ADRCNT = ADRCNT_3;
+                } else if (chip->chipsize > (8 << 16)) {
+                        /* big than 512KB */
+                        flctl->rw_ADRCNT = ADRCNT_4;
+                        flctl->erase_ADRCNT = ADRCNT_2;
+                } else {
+                        flctl->rw_ADRCNT = ADRCNT_3;
+                        flctl->erase_ADRCNT = ADRCNT_1;
+                }
+        }
+
+        if (flctl->hwecc) {
+                if (mtd->writesize == 512) {
+                        chip->ecc.layout = &flctl_4secc_oob_16;
+                        chip->badblock_pattern = &flctl_4secc_smallpage;
+                } else {
+                        chip->ecc.layout = &flctl_4secc_oob_64;
+                        chip->badblock_pattern = &flctl_4secc_largepage;
+                }
+
+                chip->ecc.size = 512;
+                chip->ecc.bytes = 10;
+                chip->ecc.read_page = flctl_read_page_hwecc;
+                chip->ecc.write_page = flctl_write_page_hwecc;
+                chip->ecc.mode = NAND_ECC_HW;
+
+                /* 4 symbols ECC enabled */
+                writel(readl(FLCMNCR(flctl)) | _4ECCEN | ECCPOS2 | ECCPOS_02,
+                                FLCMNCR(flctl));
+        } else {
+                chip->ecc.mode = NAND_ECC_SOFT;
+        }
+
+        return 0;
+}
+
+static int __init flctl_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct sh_flctl *flctl;
+        struct mtd_info *flctl_mtd;
+        struct nand_chip *nand;
+        struct sh_flctl_platform_data *pdata;
+        int ret;
+
+        pdata = pdev->dev.platform_data;
+        if (pdata == NULL) {
+                printk(KERN_ERR "sh_flctl platform_data not found.\n");
+                return -ENODEV;
+        }
+
+        flctl = kzalloc(sizeof(struct sh_flctl), GFP_KERNEL);
+        if (!flctl) {
+                printk(KERN_ERR "Unable to allocate NAND MTD dev structure.\n");
+                return -ENOMEM;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                printk(KERN_ERR "%s: resource not found.\n", __func__);
+                ret = -ENODEV;
+                goto err;
+        }
+
+        flctl->reg = ioremap(res->start, res->end - res->start + 1);
+        if (flctl->reg == NULL) {
+                printk(KERN_ERR "%s: ioremap error.\n", __func__);
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        platform_set_drvdata(pdev, flctl);
+        flctl_mtd = &flctl->mtd;
+        nand = &flctl->chip;
+        flctl_mtd->priv = nand;
+        flctl->hwecc = pdata->has_hwecc;
+
+        flctl_register_init(flctl, pdata->flcmncr_val);
+
+        nand->options = NAND_NO_AUTOINCR;
+
+        /* Set address of hardware control function */
+        /* 20 us command delay time */
+        nand->chip_delay = 20;
+
+        nand->read_byte = flctl_read_byte;
+        nand->write_buf = flctl_write_buf;
+        nand->read_buf = flctl_read_buf;
+        nand->verify_buf = flctl_verify_buf;
+        nand->select_chip = flctl_select_chip;
+        nand->cmdfunc = flctl_cmdfunc;
+
+        ret = nand_scan_ident(flctl_mtd, 1);
+        if (ret)
+                goto err;
+
+        ret = flctl_chip_init_tail(flctl_mtd);
+        if (ret)
+                goto err;
+
+        ret = nand_scan_tail(flctl_mtd);
+        if (ret)
+                goto err;
+
+        add_mtd_partitions(flctl_mtd, pdata->parts, pdata->nr_parts);
+
+        return 0;
+
+err:
+        kfree(flctl);
+        return ret;
+}
+
+static int __exit flctl_remove(struct platform_device *pdev)
+{
+        struct sh_flctl *flctl = platform_get_drvdata(pdev);
+
+        nand_release(&flctl->mtd);
+        kfree(flctl);
+
+        return 0;
+}
+
+static struct platform_driver flctl_driver = {
+        .probe          = flctl_probe,
+        .remove         = flctl_remove,
+        .driver = {
+                .name   = "sh_flctl",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init flctl_nand_init(void)
+{
+        return platform_driver_register(&flctl_driver);
+}
+
+static void __exit flctl_nand_cleanup(void)
+{
+        platform_driver_unregister(&flctl_driver);
+}
+
+module_init(flctl_nand_init);
+module_exit(flctl_nand_cleanup);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Yoshihiro Shimoda");
+MODULE_DESCRIPTION("SuperH FLCTL driver");
+MODULE_ALIAS("platform:sh_flctl");
diff --git a/drivers/mtd/nand/toto.c b/drivers/mtd/nand/toto.c
deleted file mode 100644
index bbf492e6830d..000000000000
--- a/drivers/mtd/nand/toto.c
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- *  drivers/mtd/nand/toto.c
- *
- *  Copyright (c) 2003 Texas Instruments
- *
- *  Derived from drivers/mtd/autcpu12.c
- *
- *  Copyright (c) 2002 Thomas Gleixner <tgxl@linutronix.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- *  Overview:
- *   This is a device driver for the NAND flash device found on the
- *   TI fido board. It supports 32MiB and 64MiB cards
- */
-
-#include <linux/slab.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/nand.h>
-#include <linux/mtd/partitions.h>
-#include <asm/io.h>
-#include <asm/arch/hardware.h>
-#include <asm/sizes.h>
-#include <asm/arch/toto.h>
-#include <asm/arch-omap1510/hardware.h>
-#include <asm/arch/gpio.h>
-
-#define CONFIG_NAND_WORKAROUND 1
-
-/*
- * MTD structure for TOTO board
- */
-static struct mtd_info *toto_mtd = NULL;
-
-static unsigned long toto_io_base = OMAP_FLASH_1_BASE;
-
-/*
- * Define partitions for flash devices
- */
-
-static struct mtd_partition partition_info64M[] = {
-        { .name =       "toto kernel partition 1",
-          .offset =     0,
-          .size =       2 * SZ_1M },
-        { .name =       "toto file sys partition 2",
-          .offset =     2 * SZ_1M,
-          .size =       14 * SZ_1M },
-        { .name =       "toto user partition 3",
-          .offset =     16 * SZ_1M,
-          .size =       16 * SZ_1M },
-        { .name =       "toto devboard extra partition 4",
-          .offset =     32 * SZ_1M,
-          .size =       32 * SZ_1M },
-};
-
-static struct mtd_partition partition_info32M[] = {
-        { .name =       "toto kernel partition 1",
-          .offset =     0,
-          .size =       2 * SZ_1M },
-        { .name =       "toto file sys partition 2",
-          .offset =     2 * SZ_1M,
-          .size =       14 * SZ_1M },
-        { .name =       "toto user partition 3",
-          .offset =     16 * SZ_1M,
-          .size =       16 * SZ_1M },
-};
-
-#define NUM_PARTITIONS32M 3
-#define NUM_PARTITIONS64M 4
-
-/*
- *      hardware specific access to control-lines
- *
- *      ctrl:
- *      NAND_NCE: bit 0 -> bit 14 (0x4000)
- *      NAND_CLE: bit 1 -> bit 12 (0x1000)
- *      NAND_ALE: bit 2 -> bit 1  (0x0002)
- */
-static void toto_hwcontrol(struct mtd_info *mtd, int cmd,
-                           unsigned int ctrl)
-{
-        struct nand_chip *chip = mtd->priv;
-
-        if (ctrl & NAND_CTRL_CHANGE) {
-                unsigned long bits;
-
-                /* hopefully enough time for tc make proceding write to clear */
-                udelay(1);
-
-                bits = (~ctrl & NAND_NCE) << 14;
-                bits |= (ctrl & NAND_CLE) << 12;
-                bits |= (ctrl & NAND_ALE) >> 1;
-
-#warning Wild guess as gpiosetout() is nowhere defined in the kernel source - tglx
-                gpiosetout(0x5002, bits);
-
-#ifdef CONFIG_NAND_WORKAROUND
-                /* "some" dev boards busted, blue wired to rts2 :( */
-                rts2setout(2, (ctrl & NAND_CLE) << 1);
-#endif
-                /* allow time to ensure gpio state to over take memory write */
-                udelay(1);
-        }
-
-        if (cmd != NAND_CMD_NONE)
-                writeb(cmd, chip->IO_ADDR_W);
-}
-
-/*
- * Main initialization routine
- */
-static int __init toto_init(void)
-{
-        struct nand_chip *this;
-        int err = 0;
-
-        /* Allocate memory for MTD device structure and private data */
-        toto_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
-        if (!toto_mtd) {
-                printk(KERN_WARNING "Unable to allocate toto NAND MTD device structure.\n");
-                err = -ENOMEM;
-                goto out;
-        }
-
-        /* Get pointer to private data */
-        this = (struct nand_chip *)(&toto_mtd[1]);
-
-        /* Initialize structures */
-        memset(toto_mtd, 0, sizeof(struct mtd_info));
-        memset(this, 0, sizeof(struct nand_chip));
-
-        /* Link the private data with the MTD structure */
-        toto_mtd->priv = this;
-        toto_mtd->owner = THIS_MODULE;
-
-        /* Set address of NAND IO lines */
-        this->IO_ADDR_R = toto_io_base;
-        this->IO_ADDR_W = toto_io_base;
-        this->cmd_ctrl = toto_hwcontrol;
-        this->dev_ready = NULL;
-        /* 25 us command delay time */
-        this->chip_delay = 30;
-        this->ecc.mode = NAND_ECC_SOFT;
-
-        /* Scan to find existance of the device */
-        if (nand_scan(toto_mtd, 1)) {
-                err = -ENXIO;
-                goto out_mtd;
-        }
-
-        /* Register the partitions */
-        switch (toto_mtd->size) {
-        case SZ_64M:
-                add_mtd_partitions(toto_mtd, partition_info64M, NUM_PARTITIONS64M);
-                break;
-        case SZ_32M:
-                add_mtd_partitions(toto_mtd, partition_info32M, NUM_PARTITIONS32M);
-                break;
-        default:{
-                        printk(KERN_WARNING "Unsupported Nand device\n");
-                        err = -ENXIO;
-                        goto out_buf;
-                }
-        }
-
-        gpioreserve(NAND_MASK); /* claim our gpios */
-        archflashwp(0, 0);      /* open up flash for writing */
-
-        goto out;
-
- out_mtd:
-        kfree(toto_mtd);
- out:
-        return err;
-}
-
-module_init(toto_init);
-
-/*
- * Clean up routine
- */
-static void __exit toto_cleanup(void)
-{
-        /* Release resources, unregister device */
-        nand_release(toto_mtd);
-
-        /* Free the MTD device structure */
-        kfree(toto_mtd);
-
-        /* stop flash writes */
-        archflashwp(0, 1);
-
-        /* release gpios to system */
-        gpiorelease(NAND_MASK);
-}
-
-module_exit(toto_cleanup);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Richard Woodruff <r-woodruff2@ti.com>");
-MODULE_DESCRIPTION("Glue layer for NAND flash on toto board");
diff --git a/drivers/mtd/ofpart.c b/drivers/mtd/ofpart.c
index 4f80c2fd89af..9e45b3f39c0e 100644
--- a/drivers/mtd/ofpart.c
+++ b/drivers/mtd/ofpart.c
@@ -20,7 +20,6 @@
 #include <linux/mtd/partitions.h>
 
 int __devinit of_mtd_parse_partitions(struct device *dev,
-                                      struct mtd_info *mtd,
                                       struct device_node *node,
                                       struct mtd_partition **pparts)
 {
diff --git a/drivers/mtd/onenand/Kconfig b/drivers/mtd/onenand/Kconfig
index cb41cbca64f7..79fa79e8f8de 100644
--- a/drivers/mtd/onenand/Kconfig
+++ b/drivers/mtd/onenand/Kconfig
@@ -27,8 +27,16 @@ config MTD_ONENAND_GENERIC
         help
           Support for OneNAND flash via platform device driver.
 
+config MTD_ONENAND_OMAP2
+        tristate "OneNAND on OMAP2/OMAP3 support"
+        depends on MTD_ONENAND && (ARCH_OMAP2 || ARCH_OMAP3)
+        help
+          Support for a OneNAND flash device connected to an OMAP2/OMAP3 CPU
+          via the GPMC memory controller.
+
 config MTD_ONENAND_OTP
         bool "OneNAND OTP Support"
+        select HAVE_MTD_OTP
         help
           One Block of the NAND Flash Array memory is reserved as
           a One-Time Programmable Block memory area.
diff --git a/drivers/mtd/onenand/Makefile b/drivers/mtd/onenand/Makefile
index 4d2eacfd7e11..64b6cc61a520 100644
--- a/drivers/mtd/onenand/Makefile
+++ b/drivers/mtd/onenand/Makefile
@@ -7,6 +7,7 @@ obj-$(CONFIG_MTD_ONENAND)		+= onenand.o
 
 # Board specific.
 obj-$(CONFIG_MTD_ONENAND_GENERIC)       += generic.o
+obj-$(CONFIG_MTD_ONENAND_OMAP2)         += omap2.o
 
 # Simulator
 obj-$(CONFIG_MTD_ONENAND_SIM)           += onenand_sim.o
diff --git a/drivers/mtd/onenand/omap2.c b/drivers/mtd/onenand/omap2.c
new file mode 100644
index 000000000000..8387e05daae2
--- /dev/null
+++ b/drivers/mtd/onenand/omap2.c
@@ -0,0 +1,802 @@
+/*
+ *  linux/drivers/mtd/onenand/omap2.c
+ *
+ *  OneNAND driver for OMAP2 / OMAP3
+ *
+ *  Copyright © 2005-2006 Nokia Corporation
+ *
+ *  Author: Jarkko Lavinen <jarkko.lavinen@nokia.com> and Juha Yrjölä
+ *  IRQ and DMA support written by Timo Teras
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This 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; see the file COPYING. If not, write to the Free Software
+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/onenand.h>
+#include <linux/mtd/partitions.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+
+#include <asm/io.h>
+#include <asm/mach/flash.h>
+#include <asm/arch/gpmc.h>
+#include <asm/arch/onenand.h>
+#include <asm/arch/gpio.h>
+#include <asm/arch/gpmc.h>
+#include <asm/arch/pm.h>
+
+#include <linux/dma-mapping.h>
+#include <asm/dma-mapping.h>
+#include <asm/arch/dma.h>
+
+#include <asm/arch/board.h>
+
+#define DRIVER_NAME "omap2-onenand"
+
+#define ONENAND_IO_SIZE         SZ_128K
+#define ONENAND_BUFRAM_SIZE     (1024 * 5)
+
+struct omap2_onenand {
+        struct platform_device *pdev;
+        int gpmc_cs;
+        unsigned long phys_base;
+        int gpio_irq;
+        struct mtd_info mtd;
+        struct mtd_partition *parts;
+        struct onenand_chip onenand;
+        struct completion irq_done;
+        struct completion dma_done;
+        int dma_channel;
+        int freq;
+        int (*setup)(void __iomem *base, int freq);
+};
+
+static void omap2_onenand_dma_cb(int lch, u16 ch_status, void *data)
+{
+        struct omap2_onenand *c = data;
+
+        complete(&c->dma_done);
+}
+
+static irqreturn_t omap2_onenand_interrupt(int irq, void *dev_id)
+{
+        struct omap2_onenand *c = dev_id;
+
+        complete(&c->irq_done);
+
+        return IRQ_HANDLED;
+}
+
+static inline unsigned short read_reg(struct omap2_onenand *c, int reg)
+{
+        return readw(c->onenand.base + reg);
+}
+
+static inline void write_reg(struct omap2_onenand *c, unsigned short value,
+                             int reg)
+{
+        writew(value, c->onenand.base + reg);
+}
+
+static void wait_err(char *msg, int state, unsigned int ctrl, unsigned int intr)
+{
+        printk(KERN_ERR "onenand_wait: %s! state %d ctrl 0x%04x intr 0x%04x\n",
+               msg, state, ctrl, intr);
+}
+
+static void wait_warn(char *msg, int state, unsigned int ctrl,
+                      unsigned int intr)
+{
+        printk(KERN_WARNING "onenand_wait: %s! state %d ctrl 0x%04x "
+               "intr 0x%04x\n", msg, state, ctrl, intr);
+}
+
+static int omap2_onenand_wait(struct mtd_info *mtd, int state)
+{
+        struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
+        unsigned int intr = 0;
+        unsigned int ctrl;
+        unsigned long timeout;
+        u32 syscfg;
+
+        if (state == FL_RESETING) {
+                int i;
+
+                for (i = 0; i < 20; i++) {
+                        udelay(1);
+                        intr = read_reg(c, ONENAND_REG_INTERRUPT);
+                        if (intr & ONENAND_INT_MASTER)
+                                break;
+                }
+                ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
+                if (ctrl & ONENAND_CTRL_ERROR) {
+                        wait_err("controller error", state, ctrl, intr);
+                        return -EIO;
+                }
+                if (!(intr & ONENAND_INT_RESET)) {
+                        wait_err("timeout", state, ctrl, intr);
+                        return -EIO;
+                }
+                return 0;
+        }
+
+        if (state != FL_READING) {
+                int result;
+
+                /* Turn interrupts on */
+                syscfg = read_reg(c, ONENAND_REG_SYS_CFG1);
+                if (!(syscfg & ONENAND_SYS_CFG1_IOBE)) {
+                        syscfg |= ONENAND_SYS_CFG1_IOBE;
+                        write_reg(c, syscfg, ONENAND_REG_SYS_CFG1);
+                        if (cpu_is_omap34xx())
+                                /* Add a delay to let GPIO settle */
+                                syscfg = read_reg(c, ONENAND_REG_SYS_CFG1);
+                }
+
+                INIT_COMPLETION(c->irq_done);
+                if (c->gpio_irq) {
+                        result = omap_get_gpio_datain(c->gpio_irq);
+                        if (result == -1) {
+                                ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
+                                intr = read_reg(c, ONENAND_REG_INTERRUPT);
+                                wait_err("gpio error", state, ctrl, intr);
+                                return -EIO;
+                        }
+                } else
+                        result = 0;
+                if (result == 0) {
+                        int retry_cnt = 0;
+retry:
+                        result = wait_for_completion_timeout(&c->irq_done,
+                                                    msecs_to_jiffies(20));
+                        if (result == 0) {
+                                /* Timeout after 20ms */
+                                ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
+                                if (ctrl & ONENAND_CTRL_ONGO) {
+                                        /*
+                                         * The operation seems to be still going
+                                         * so give it some more time.
+                                         */
+                                        retry_cnt += 1;
+                                        if (retry_cnt < 3)
+                                                goto retry;
+                                        intr = read_reg(c,
+                                                        ONENAND_REG_INTERRUPT);
+                                        wait_err("timeout", state, ctrl, intr);
+                                        return -EIO;
+                                }
+                                intr = read_reg(c, ONENAND_REG_INTERRUPT);
+                                if ((intr & ONENAND_INT_MASTER) == 0)
+                                        wait_warn("timeout", state, ctrl, intr);
+                        }
+                }
+        } else {
+                int retry_cnt = 0;
+
+                /* Turn interrupts off */
+                syscfg = read_reg(c, ONENAND_REG_SYS_CFG1);
+                syscfg &= ~ONENAND_SYS_CFG1_IOBE;
+                write_reg(c, syscfg, ONENAND_REG_SYS_CFG1);
+
+                timeout = jiffies + msecs_to_jiffies(20);
+                while (1) {
+                        if (time_before(jiffies, timeout)) {
+                                intr = read_reg(c, ONENAND_REG_INTERRUPT);
+                                if (intr & ONENAND_INT_MASTER)
+                                        break;
+                        } else {
+                                /* Timeout after 20ms */
+                                ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
+                                if (ctrl & ONENAND_CTRL_ONGO) {
+                                        /*
+                                         * The operation seems to be still going
+                                         * so give it some more time.
+                                         */
+                                        retry_cnt += 1;
+                                        if (retry_cnt < 3) {
+                                                timeout = jiffies +
+                                                          msecs_to_jiffies(20);
+                                                continue;
+                                        }
+                                }
+                                break;
+                        }
+                }
+        }
+
+        intr = read_reg(c, ONENAND_REG_INTERRUPT);
+        ctrl = read_reg(c, ONENAND_REG_CTRL_STATUS);
+
+        if (intr & ONENAND_INT_READ) {
+                int ecc = read_reg(c, ONENAND_REG_ECC_STATUS);
+
+                if (ecc) {
+                        unsigned int addr1, addr8;
+
+                        addr1 = read_reg(c, ONENAND_REG_START_ADDRESS1);
+                        addr8 = read_reg(c, ONENAND_REG_START_ADDRESS8);
+                        if (ecc & ONENAND_ECC_2BIT_ALL) {
+                                printk(KERN_ERR "onenand_wait: ECC error = "
+                                       "0x%04x, addr1 %#x, addr8 %#x\n",
+                                       ecc, addr1, addr8);
+                                mtd->ecc_stats.failed++;
+                                return -EBADMSG;
+                        } else if (ecc & ONENAND_ECC_1BIT_ALL) {
+                                printk(KERN_NOTICE "onenand_wait: correctable "
+                                       "ECC error = 0x%04x, addr1 %#x, "
+                                       "addr8 %#x\n", ecc, addr1, addr8);
+                                mtd->ecc_stats.corrected++;
+                        }
+                }
+        } else if (state == FL_READING) {
+                wait_err("timeout", state, ctrl, intr);
+                return -EIO;
+        }
+
+        if (ctrl & ONENAND_CTRL_ERROR) {
+                wait_err("controller error", state, ctrl, intr);
+                if (ctrl & ONENAND_CTRL_LOCK)
+                        printk(KERN_ERR "onenand_wait: "
+                                        "Device is write protected!!!\n");
+                return -EIO;
+        }
+
+        if (ctrl & 0xFE9F)
+                wait_warn("unexpected controller status", state, ctrl, intr);
+
+        return 0;
+}
+
+static inline int omap2_onenand_bufferram_offset(struct mtd_info *mtd, int area)
+{
+        struct onenand_chip *this = mtd->priv;
+
+        if (ONENAND_CURRENT_BUFFERRAM(this)) {
+                if (area == ONENAND_DATARAM)
+                        return mtd->writesize;
+                if (area == ONENAND_SPARERAM)
+                        return mtd->oobsize;
+        }
+
+        return 0;
+}
+
+#if defined(CONFIG_ARCH_OMAP3) || defined(MULTI_OMAP2)
+
+static int omap3_onenand_read_bufferram(struct mtd_info *mtd, int area,
+                                        unsigned char *buffer, int offset,
+                                        size_t count)
+{
+        struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
+        struct onenand_chip *this = mtd->priv;
+        dma_addr_t dma_src, dma_dst;
+        int bram_offset;
+        unsigned long timeout;
+        void *buf = (void *)buffer;
+        size_t xtra;
+        volatile unsigned *done;
+
+        bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
+        if (bram_offset & 3 || (size_t)buf & 3 || count < 384)
+                goto out_copy;
+
+        if (buf >= high_memory) {
+                struct page *p1;
+
+                if (((size_t)buf & PAGE_MASK) !=
+                    ((size_t)(buf + count - 1) & PAGE_MASK))
+                        goto out_copy;
+                p1 = vmalloc_to_page(buf);
+                if (!p1)
+                        goto out_copy;
+                buf = page_address(p1) + ((size_t)buf & ~PAGE_MASK);
+        }
+
+        xtra = count & 3;
+        if (xtra) {
+                count -= xtra;
+                memcpy(buf + count, this->base + bram_offset + count, xtra);
+        }
+
+        dma_src = c->phys_base + bram_offset;
+        dma_dst = dma_map_single(&c->pdev->dev, buf, count, DMA_FROM_DEVICE);
+        if (dma_mapping_error(&c->pdev->dev, dma_dst)) {
+                dev_err(&c->pdev->dev,
+                        "Couldn't DMA map a %d byte buffer\n",
+                        count);
+                goto out_copy;
+        }
+
+        omap_set_dma_transfer_params(c->dma_channel, OMAP_DMA_DATA_TYPE_S32,
+                                     count >> 2, 1, 0, 0, 0);
+        omap_set_dma_src_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
+                                dma_src, 0, 0);
+        omap_set_dma_dest_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
+                                 dma_dst, 0, 0);
+
+        INIT_COMPLETION(c->dma_done);
+        omap_start_dma(c->dma_channel);
+
+        timeout = jiffies + msecs_to_jiffies(20);
+        done = &c->dma_done.done;
+        while (time_before(jiffies, timeout))
+                if (*done)
+                        break;
+
+        dma_unmap_single(&c->pdev->dev, dma_dst, count, DMA_FROM_DEVICE);
+
+        if (!*done) {
+                dev_err(&c->pdev->dev, "timeout waiting for DMA\n");
+                goto out_copy;
+        }
+
+        return 0;
+
+out_copy:
+        memcpy(buf, this->base + bram_offset, count);
+        return 0;
+}
+
+static int omap3_onenand_write_bufferram(struct mtd_info *mtd, int area,
+                                         const unsigned char *buffer,
+                                         int offset, size_t count)
+{
+        struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
+        struct onenand_chip *this = mtd->priv;
+        dma_addr_t dma_src, dma_dst;
+        int bram_offset;
+        unsigned long timeout;
+        void *buf = (void *)buffer;
+        volatile unsigned *done;
+
+        bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
+        if (bram_offset & 3 || (size_t)buf & 3 || count < 384)
+                goto out_copy;
+
+        /* panic_write() may be in an interrupt context */
+        if (in_interrupt())
+                goto out_copy;
+
+        if (buf >= high_memory) {
+                struct page *p1;
+
+                if (((size_t)buf & PAGE_MASK) !=
+                    ((size_t)(buf + count - 1) & PAGE_MASK))
+                        goto out_copy;
+                p1 = vmalloc_to_page(buf);
+                if (!p1)
+                        goto out_copy;
+                buf = page_address(p1) + ((size_t)buf & ~PAGE_MASK);
+        }
+
+        dma_src = dma_map_single(&c->pdev->dev, buf, count, DMA_TO_DEVICE);
+        dma_dst = c->phys_base + bram_offset;
+        if (dma_mapping_error(&c->pdev->dev, dma_dst)) {
+                dev_err(&c->pdev->dev,
+                        "Couldn't DMA map a %d byte buffer\n",
+                        count);
+                return -1;
+        }
+
+        omap_set_dma_transfer_params(c->dma_channel, OMAP_DMA_DATA_TYPE_S32,
+                                     count >> 2, 1, 0, 0, 0);
+        omap_set_dma_src_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
+                                dma_src, 0, 0);
+        omap_set_dma_dest_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
+                                 dma_dst, 0, 0);
+
+        INIT_COMPLETION(c->dma_done);
+        omap_start_dma(c->dma_channel);
+
+        timeout = jiffies + msecs_to_jiffies(20);
+        done = &c->dma_done.done;
+        while (time_before(jiffies, timeout))
+                if (*done)
+                        break;
+
+        dma_unmap_single(&c->pdev->dev, dma_dst, count, DMA_TO_DEVICE);
+
+        if (!*done) {
+                dev_err(&c->pdev->dev, "timeout waiting for DMA\n");
+                goto out_copy;
+        }
+
+        return 0;
+
+out_copy:
+        memcpy(this->base + bram_offset, buf, count);
+        return 0;
+}
+
+#else
+
+int omap3_onenand_read_bufferram(struct mtd_info *mtd, int area,
+                                 unsigned char *buffer, int offset,
+                                 size_t count);
+
+int omap3_onenand_write_bufferram(struct mtd_info *mtd, int area,
+                                  const unsigned char *buffer,
+                                  int offset, size_t count);
+
+#endif
+
+#if defined(CONFIG_ARCH_OMAP2) || defined(MULTI_OMAP2)
+
+static int omap2_onenand_read_bufferram(struct mtd_info *mtd, int area,
+                                        unsigned char *buffer, int offset,
+                                        size_t count)
+{
+        struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
+        struct onenand_chip *this = mtd->priv;
+        dma_addr_t dma_src, dma_dst;
+        int bram_offset;
+
+        bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
+        /* DMA is not used.  Revisit PM requirements before enabling it. */
+        if (1 || (c->dma_channel < 0) ||
+            ((void *) buffer >= (void *) high_memory) || (bram_offset & 3) ||
+            (((unsigned int) buffer) & 3) || (count < 1024) || (count & 3)) {
+                memcpy(buffer, (__force void *)(this->base + bram_offset),
+                       count);
+                return 0;
+        }
+
+        dma_src = c->phys_base + bram_offset;
+        dma_dst = dma_map_single(&c->pdev->dev, buffer, count,
+                                 DMA_FROM_DEVICE);
+        if (dma_mapping_error(&c->pdev->dev, dma_dst)) {
+                dev_err(&c->pdev->dev,
+                        "Couldn't DMA map a %d byte buffer\n",
+                        count);
+                return -1;
+        }
+
+        omap_set_dma_transfer_params(c->dma_channel, OMAP_DMA_DATA_TYPE_S32,
+                                     count / 4, 1, 0, 0, 0);
+        omap_set_dma_src_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
+                                dma_src, 0, 0);
+        omap_set_dma_dest_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
+                                 dma_dst, 0, 0);
+
+        INIT_COMPLETION(c->dma_done);
+        omap_start_dma(c->dma_channel);
+        wait_for_completion(&c->dma_done);
+
+        dma_unmap_single(&c->pdev->dev, dma_dst, count, DMA_FROM_DEVICE);
+
+        return 0;
+}
+
+static int omap2_onenand_write_bufferram(struct mtd_info *mtd, int area,
+                                         const unsigned char *buffer,
+                                         int offset, size_t count)
+{
+        struct omap2_onenand *c = container_of(mtd, struct omap2_onenand, mtd);
+        struct onenand_chip *this = mtd->priv;
+        dma_addr_t dma_src, dma_dst;
+        int bram_offset;
+
+        bram_offset = omap2_onenand_bufferram_offset(mtd, area) + area + offset;
+        /* DMA is not used.  Revisit PM requirements before enabling it. */
+        if (1 || (c->dma_channel < 0) ||
+            ((void *) buffer >= (void *) high_memory) || (bram_offset & 3) ||
+            (((unsigned int) buffer) & 3) || (count < 1024) || (count & 3)) {
+                memcpy((__force void *)(this->base + bram_offset), buffer,
+                       count);
+                return 0;
+        }
+
+        dma_src = dma_map_single(&c->pdev->dev, (void *) buffer, count,
+                                 DMA_TO_DEVICE);
+        dma_dst = c->phys_base + bram_offset;
+        if (dma_mapping_error(&c->pdev->dev, dma_dst)) {
+                dev_err(&c->pdev->dev,
+                        "Couldn't DMA map a %d byte buffer\n",
+                        count);
+                return -1;
+        }
+
+        omap_set_dma_transfer_params(c->dma_channel, OMAP_DMA_DATA_TYPE_S16,
+                                     count / 2, 1, 0, 0, 0);
+        omap_set_dma_src_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
+                                dma_src, 0, 0);
+        omap_set_dma_dest_params(c->dma_channel, 0, OMAP_DMA_AMODE_POST_INC,
+                                 dma_dst, 0, 0);
+
+        INIT_COMPLETION(c->dma_done);
+        omap_start_dma(c->dma_channel);
+        wait_for_completion(&c->dma_done);
+
+        dma_unmap_single(&c->pdev->dev, dma_dst, count, DMA_TO_DEVICE);
+
+        return 0;
+}
+
+#else
+
+int omap2_onenand_read_bufferram(struct mtd_info *mtd, int area,
+                                 unsigned char *buffer, int offset,
+                                 size_t count);
+
+int omap2_onenand_write_bufferram(struct mtd_info *mtd, int area,
+                                  const unsigned char *buffer,
+                                  int offset, size_t count);
+
+#endif
+
+static struct platform_driver omap2_onenand_driver;
+
+static int __adjust_timing(struct device *dev, void *data)
+{
+        int ret = 0;
+        struct omap2_onenand *c;
+
+        c = dev_get_drvdata(dev);
+
+        BUG_ON(c->setup == NULL);
+
+        /* DMA is not in use so this is all that is needed */
+        /* Revisit for OMAP3! */
+        ret = c->setup(c->onenand.base, c->freq);
+
+        return ret;
+}
+
+int omap2_onenand_rephase(void)
+{
+        return driver_for_each_device(&omap2_onenand_driver.driver, NULL,
+                                      NULL, __adjust_timing);
+}
+
+static void __devexit omap2_onenand_shutdown(struct platform_device *pdev)
+{
+        struct omap2_onenand *c = dev_get_drvdata(&pdev->dev);
+
+        /* With certain content in the buffer RAM, the OMAP boot ROM code
+         * can recognize the flash chip incorrectly. Zero it out before
+         * soft reset.
+         */
+        memset((__force void *)c->onenand.base, 0, ONENAND_BUFRAM_SIZE);
+}
+
+static int __devinit omap2_onenand_probe(struct platform_device *pdev)
+{
+        struct omap_onenand_platform_data *pdata;
+        struct omap2_onenand *c;
+        int r;
+
+        pdata = pdev->dev.platform_data;
+        if (pdata == NULL) {
+                dev_err(&pdev->dev, "platform data missing\n");
+                return -ENODEV;
+        }
+
+        c = kzalloc(sizeof(struct omap2_onenand), GFP_KERNEL);
+        if (!c)
+                return -ENOMEM;
+
+        init_completion(&c->irq_done);
+        init_completion(&c->dma_done);
+        c->gpmc_cs = pdata->cs;
+        c->gpio_irq = pdata->gpio_irq;
+        c->dma_channel = pdata->dma_channel;
+        if (c->dma_channel < 0) {
+                /* if -1, don't use DMA */
+                c->gpio_irq = 0;
+        }
+
+        r = gpmc_cs_request(c->gpmc_cs, ONENAND_IO_SIZE, &c->phys_base);
+        if (r < 0) {
+                dev_err(&pdev->dev, "Cannot request GPMC CS\n");
+                goto err_kfree;
+        }
+
+        if (request_mem_region(c->phys_base, ONENAND_IO_SIZE,
+                               pdev->dev.driver->name) == NULL) {
+                dev_err(&pdev->dev, "Cannot reserve memory region at 0x%08lx, "
+                        "size: 0x%x\n", c->phys_base, ONENAND_IO_SIZE);
+                r = -EBUSY;
+                goto err_free_cs;
+        }
+        c->onenand.base = ioremap(c->phys_base, ONENAND_IO_SIZE);
+        if (c->onenand.base == NULL) {
+                r = -ENOMEM;
+                goto err_release_mem_region;
+        }
+
+        if (pdata->onenand_setup != NULL) {
+                r = pdata->onenand_setup(c->onenand.base, c->freq);
+                if (r < 0) {
+                        dev_err(&pdev->dev, "Onenand platform setup failed: "
+                                "%d\n", r);
+                        goto err_iounmap;
+                }
+                c->setup = pdata->onenand_setup;
+        }
+
+        if (c->gpio_irq) {
+                if ((r = omap_request_gpio(c->gpio_irq)) < 0) {
+                        dev_err(&pdev->dev,  "Failed to request GPIO%d for "
+                                "OneNAND\n", c->gpio_irq);
+                        goto err_iounmap;
+        }
+        omap_set_gpio_direction(c->gpio_irq, 1);
+
+        if ((r = request_irq(OMAP_GPIO_IRQ(c->gpio_irq),
+                             omap2_onenand_interrupt, IRQF_TRIGGER_RISING,
+                             pdev->dev.driver->name, c)) < 0)
+                goto err_release_gpio;
+        }
+
+        if (c->dma_channel >= 0) {
+                r = omap_request_dma(0, pdev->dev.driver->name,
+                                     omap2_onenand_dma_cb, (void *) c,
+                                     &c->dma_channel);
+                if (r == 0) {
+                        omap_set_dma_write_mode(c->dma_channel,
+                                                OMAP_DMA_WRITE_NON_POSTED);
+                        omap_set_dma_src_data_pack(c->dma_channel, 1);
+                        omap_set_dma_src_burst_mode(c->dma_channel,
+                                                    OMAP_DMA_DATA_BURST_8);
+                        omap_set_dma_dest_data_pack(c->dma_channel, 1);
+                        omap_set_dma_dest_burst_mode(c->dma_channel,
+                                                     OMAP_DMA_DATA_BURST_8);
+                } else {
+                        dev_info(&pdev->dev,
+                                 "failed to allocate DMA for OneNAND, "
+                                 "using PIO instead\n");
+                        c->dma_channel = -1;
+                }
+        }
+
+        dev_info(&pdev->dev, "initializing on CS%d, phys base 0x%08lx, virtual "
+                 "base %p\n", c->gpmc_cs, c->phys_base,
+                 c->onenand.base);
+
+        c->pdev = pdev;
+        c->mtd.name = pdev->dev.bus_id;
+        c->mtd.priv = &c->onenand;
+        c->mtd.owner = THIS_MODULE;
+
+        if (c->dma_channel >= 0) {
+                struct onenand_chip *this = &c->onenand;
+
+                this->wait = omap2_onenand_wait;
+                if (cpu_is_omap34xx()) {
+                        this->read_bufferram = omap3_onenand_read_bufferram;
+                        this->write_bufferram = omap3_onenand_write_bufferram;
+                } else {
+                        this->read_bufferram = omap2_onenand_read_bufferram;
+                        this->write_bufferram = omap2_onenand_write_bufferram;
+                }
+        }
+
+        if ((r = onenand_scan(&c->mtd, 1)) < 0)
+                goto err_release_dma;
+
+        switch ((c->onenand.version_id >> 4) & 0xf) {
+        case 0:
+                c->freq = 40;
+                break;
+        case 1:
+                c->freq = 54;
+                break;
+        case 2:
+                c->freq = 66;
+                break;
+        case 3:
+                c->freq = 83;
+                break;
+        }
+
+#ifdef CONFIG_MTD_PARTITIONS
+        if (pdata->parts != NULL)
+                r = add_mtd_partitions(&c->mtd, pdata->parts,
+                                       pdata->nr_parts);
+        else
+#endif
+                r = add_mtd_device(&c->mtd);
+        if (r < 0)
+                goto err_release_onenand;
+
+        platform_set_drvdata(pdev, c);
+
+        return 0;
+
+err_release_onenand:
+        onenand_release(&c->mtd);
+err_release_dma:
+        if (c->dma_channel != -1)
+                omap_free_dma(c->dma_channel);
+        if (c->gpio_irq)
+                free_irq(OMAP_GPIO_IRQ(c->gpio_irq), c);
+err_release_gpio:
+        if (c->gpio_irq)
+                omap_free_gpio(c->gpio_irq);
+err_iounmap:
+        iounmap(c->onenand.base);
+err_release_mem_region:
+        release_mem_region(c->phys_base, ONENAND_IO_SIZE);
+err_free_cs:
+        gpmc_cs_free(c->gpmc_cs);
+err_kfree:
+        kfree(c);
+
+        return r;
+}
+
+static int __devexit omap2_onenand_remove(struct platform_device *pdev)
+{
+        struct omap2_onenand *c = dev_get_drvdata(&pdev->dev);
+
+        BUG_ON(c == NULL);
+
+#ifdef CONFIG_MTD_PARTITIONS
+        if (c->parts)
+                del_mtd_partitions(&c->mtd);
+        else
+                del_mtd_device(&c->mtd);
+#else
+        del_mtd_device(&c->mtd);
+#endif
+
+        onenand_release(&c->mtd);
+        if (c->dma_channel != -1)
+                omap_free_dma(c->dma_channel);
+        omap2_onenand_shutdown(pdev);
+        platform_set_drvdata(pdev, NULL);
+        if (c->gpio_irq) {
+                free_irq(OMAP_GPIO_IRQ(c->gpio_irq), c);
+                omap_free_gpio(c->gpio_irq);
+        }
+        iounmap(c->onenand.base);
+        release_mem_region(c->phys_base, ONENAND_IO_SIZE);
+        kfree(c);
+
+        return 0;
+}
+
+static struct platform_driver omap2_onenand_driver = {
+        .probe          = omap2_onenand_probe,
+        .remove         = omap2_onenand_remove,
+        .shutdown       = omap2_onenand_shutdown,
+        .driver         = {
+                .name   = DRIVER_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init omap2_onenand_init(void)
+{
+        printk(KERN_INFO "OneNAND driver initializing\n");
+        return platform_driver_register(&omap2_onenand_driver);
+}
+
+static void __exit omap2_onenand_exit(void)
+{
+        platform_driver_unregister(&omap2_onenand_driver);
+}
+
+module_init(omap2_onenand_init);
+module_exit(omap2_onenand_exit);
+
+MODULE_ALIAS(DRIVER_NAME);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jarkko Lavinen <jarkko.lavinen@nokia.com>");
+MODULE_DESCRIPTION("Glue layer for OneNAND flash on OMAP2 / OMAP3");
diff --git a/drivers/mtd/onenand/onenand_base.c b/drivers/mtd/onenand/onenand_base.c
index 926cf3a4135d..90ed319f26e6 100644
--- a/drivers/mtd/onenand/onenand_base.c
+++ b/drivers/mtd/onenand/onenand_base.c
@@ -1794,7 +1794,7 @@ static int onenand_erase(struct mtd_info *mtd, struct erase_info *instr)
                 return -EINVAL;
         }
 
-        instr->fail_addr = 0xffffffff;
+        instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
 
         /* Grab the lock and see if the device is available */
         onenand_get_device(mtd, FL_ERASING);
diff --git a/drivers/mtd/ssfdc.c b/drivers/mtd/ssfdc.c
index a5f3d60047d4..33a5d6ed6f18 100644
--- a/drivers/mtd/ssfdc.c
+++ b/drivers/mtd/ssfdc.c
@@ -321,8 +321,7 @@ static void ssfdcr_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
         DEBUG(MTD_DEBUG_LEVEL1,
                 "SSFDC_RO: cis_block=%d,erase_size=%d,map_len=%d,n_zones=%d\n",
                 ssfdc->cis_block, ssfdc->erase_size, ssfdc->map_len,
-                (ssfdc->map_len + MAX_PHYS_BLK_PER_ZONE - 1) /
-                MAX_PHYS_BLK_PER_ZONE);
+                DIV_ROUND_UP(ssfdc->map_len, MAX_PHYS_BLK_PER_ZONE));
 
         /* Set geometry */
         ssfdc->heads = 16;
diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index 03c759b4eeb5..b30a0b83d7f1 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -104,12 +104,9 @@ static int vol_cdev_open(struct inode *inode, struct file *file)
         struct ubi_volume_desc *desc;
         int vol_id = iminor(inode) - 1, mode, ubi_num;
 
-        lock_kernel();
         ubi_num = ubi_major2num(imajor(inode));
-        if (ubi_num < 0) {
-                unlock_kernel();
+        if (ubi_num < 0)
                 return ubi_num;
-        }
 
         if (file->f_mode & FMODE_WRITE)
                 mode = UBI_READWRITE;
@@ -119,7 +116,6 @@ static int vol_cdev_open(struct inode *inode, struct file *file)
         dbg_gen("open volume %d, mode %d", vol_id, mode);
 
         desc = ubi_open_volume(ubi_num, vol_id, mode);
-        unlock_kernel();
         if (IS_ERR(desc))
                 return PTR_ERR(desc);
 
diff --git a/drivers/mtd/ubi/scan.c b/drivers/mtd/ubi/scan.c
index 967bb4406df9..4f2daa5bbecf 100644
--- a/drivers/mtd/ubi/scan.c
+++ b/drivers/mtd/ubi/scan.c
@@ -387,7 +387,7 @@ int ubi_scan_add_used(struct ubi_device *ubi, struct ubi_scan_info *si,
                 pnum, vol_id, lnum, ec, sqnum, bitflips);
 
         sv = add_volume(si, vol_id, pnum, vid_hdr);
-        if (IS_ERR(sv) < 0)
+        if (IS_ERR(sv))
                 return PTR_ERR(sv);
 
         if (si->max_sqnum < sqnum)
diff --git a/drivers/mtd/ubi/vtbl.c b/drivers/mtd/ubi/vtbl.c
index 217d0e111b2a..333c8941552f 100644
--- a/drivers/mtd/ubi/vtbl.c
+++ b/drivers/mtd/ubi/vtbl.c
@@ -244,8 +244,8 @@ static int vtbl_check(const struct ubi_device *ubi,
                 }
 
                 if (reserved_pebs > ubi->good_peb_count) {
-                        dbg_err("too large reserved_pebs, good PEBs %d",
-                                ubi->good_peb_count);
+                        dbg_err("too large reserved_pebs %d, good PEBs %d",
+                                reserved_pebs, ubi->good_peb_count);
                         err = 9;
                         goto bad;
                 }
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index 491ee16da5c1..9ba295d9dd97 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -90,7 +90,7 @@ static int vortex_debug = 1;
 #include <linux/eisa.h>
 #include <linux/bitops.h>
 #include <linux/jiffies.h>
-#include <asm/irq.h>                    /* For NR_IRQS only. */
+#include <asm/irq.h>                    /* For nr_irqs only. */
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
@@ -1221,7 +1221,7 @@ static int __devinit vortex_probe1(struct device *gendev,
         if (print_info)
                 printk(", IRQ %d\n", dev->irq);
         /* Tell them about an invalid IRQ. */
-        if (dev->irq <= 0 || dev->irq >= NR_IRQS)
+        if (dev->irq <= 0 || dev->irq >= nr_irqs)
                 printk(KERN_WARNING " *** Warning: IRQ %d is unlikely to work! ***\n",
                            dev->irq);
 
diff --git a/drivers/net/hamradio/baycom_ser_fdx.c b/drivers/net/hamradio/baycom_ser_fdx.c
index 17ac6975d70d..b6a816e60c0f 100644
--- a/drivers/net/hamradio/baycom_ser_fdx.c
+++ b/drivers/net/hamradio/baycom_ser_fdx.c
@@ -416,10 +416,10 @@ static int ser12_open(struct net_device *dev)
         if (!dev || !bc)
                 return -ENXIO;
         if (!dev->base_addr || dev->base_addr > 0xffff-SER12_EXTENT ||
-            dev->irq < 2 || dev->irq > NR_IRQS) {
+            dev->irq < 2 || dev->irq > nr_irqs) {
                 printk(KERN_INFO "baycom_ser_fdx: invalid portnumber (max %u) "
                                 "or irq (2 <= irq <= %d)\n",
-                                0xffff-SER12_EXTENT, NR_IRQS);
+                                0xffff-SER12_EXTENT, nr_irqs);
                 return -ENXIO;
         }
         if (bc->baud < 300 || bc->baud > 4800) {
diff --git a/drivers/net/hamradio/scc.c b/drivers/net/hamradio/scc.c
index 45ae9d1191d7..c17e39bc5460 100644
--- a/drivers/net/hamradio/scc.c
+++ b/drivers/net/hamradio/scc.c
@@ -1465,7 +1465,7 @@ static void z8530_init(void)
         printk(KERN_INFO "Init Z8530 driver: %u channels, IRQ", Nchips*2);
         
         flag=" ";
-        for (k = 0; k < NR_IRQS; k++)
+        for (k = 0; k < nr_irqs; k++)
                 if (Ivec[k].used) 
                 {
                         printk("%s%d", flag, k);
@@ -1728,7 +1728,7 @@ static int scc_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 
                         if (hwcfg.irq == 2) hwcfg.irq = 9;
 
-                        if (hwcfg.irq < 0 || hwcfg.irq >= NR_IRQS)
+                        if (hwcfg.irq < 0 || hwcfg.irq >= nr_irqs)
                                 return -EINVAL;
                                 
                         if (!Ivec[hwcfg.irq].used && hwcfg.irq)
@@ -2148,7 +2148,7 @@ static void __exit scc_cleanup_driver(void)
                 }
                 
         /* To unload the port must be closed so no real IRQ pending */
-        for (k=0; k < NR_IRQS ; k++)
+        for (k = 0; k < nr_irqs ; k++)
                 if (Ivec[k].used) free_irq(k, NULL);
                 
         local_irq_enable();
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index b39d1cc1ef04..a24bb68887ab 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -1205,11 +1205,12 @@ static int sh_eth_drv_probe(struct platform_device *pdev)
                 devno = 0;
 
         ndev->dma = -1;
-        ndev->irq = platform_get_irq(pdev, 0);
-        if (ndev->irq < 0) {
+        ret = platform_get_irq(pdev, 0);
+        if (ret < 0) {
                 ret = -ENODEV;
                 goto out_release;
         }
+        ndev->irq = ret;
 
         SET_NETDEV_DEV(ndev, &pdev->dev);
 
diff --git a/drivers/net/usb/pegasus.c b/drivers/net/usb/pegasus.c
index 38b90e7a7ed3..7914867110ed 100644
--- a/drivers/net/usb/pegasus.c
+++ b/drivers/net/usb/pegasus.c
@@ -168,7 +168,7 @@ static int get_registers(pegasus_t * pegasus, __u16 indx, __u16 size,
                         netif_device_detach(pegasus->net);
                 if (netif_msg_drv(pegasus) && printk_ratelimit())
                         dev_err(&pegasus->intf->dev, "%s, status %d\n",
-                                        __FUNCTION__, ret);
+                                        __func__, ret);
                 goto out;
         }
 
@@ -192,7 +192,7 @@ static int set_registers(pegasus_t * pegasus, __u16 indx, __u16 size,
         if (!buffer) {
                 if (netif_msg_drv(pegasus))
                         dev_warn(&pegasus->intf->dev, "out of memory in %s\n",
-                                        __FUNCTION__);
+                                        __func__);
                 return -ENOMEM;
         }
         memcpy(buffer, data, size);
diff --git a/drivers/net/wan/sbni.c b/drivers/net/wan/sbni.c
index f972fef87c98..ee51b6a5e605 100644
--- a/drivers/net/wan/sbni.c
+++ b/drivers/net/wan/sbni.c
@@ -318,7 +318,7 @@ sbni_pci_probe( struct net_device  *dev )
                                 continue;
                 }
 
-                if( pci_irq_line <= 0  ||  pci_irq_line >= NR_IRQS )
+                if (pci_irq_line <= 0 || pci_irq_line >= nr_irqs)
                         printk( KERN_WARNING "  WARNING: The PCI BIOS assigned "
                                 "this PCI card to IRQ %d, which is unlikely "
                                 "to work!.\n"
diff --git a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
index b30e38f3a50d..dcc1e9958d2f 100644
--- a/drivers/parisc/ccio-dma.c
+++ b/drivers/parisc/ccio-dma.c
@@ -66,15 +66,8 @@
 #undef DEBUG_CCIO_RUN_SG
 
 #ifdef CONFIG_PROC_FS
-/*
- * CCIO_SEARCH_TIME can help measure how fast the bitmap search is.
- * impacts performance though - ditch it if you don't use it.
- */
-#define CCIO_SEARCH_TIME
-#undef CCIO_MAP_STATS
-#else
-#undef CCIO_SEARCH_TIME
-#undef CCIO_MAP_STATS
+/* depends on proc fs support. But costs CPU performance. */
+#undef CCIO_COLLECT_STATS
 #endif
 
 #include <linux/proc_fs.h>
@@ -239,12 +232,10 @@ struct ioc {
         u32 res_size;                   /* size of resource map in bytes */
         spinlock_t res_lock;
 
-#ifdef CCIO_SEARCH_TIME
+#ifdef CCIO_COLLECT_STATS
 #define CCIO_SEARCH_SAMPLE 0x100
         unsigned long avg_search[CCIO_SEARCH_SAMPLE];
         unsigned long avg_idx;            /* current index into avg_search */
-#endif
-#ifdef CCIO_MAP_STATS
         unsigned long used_pages;
         unsigned long msingle_calls;
         unsigned long msingle_pages;
@@ -351,7 +342,7 @@ ccio_alloc_range(struct ioc *ioc, struct device *dev, size_t size)
         unsigned int pages_needed = size >> IOVP_SHIFT;
         unsigned int res_idx;
         unsigned long boundary_size;
-#ifdef CCIO_SEARCH_TIME
+#ifdef CCIO_COLLECT_STATS
         unsigned long cr_start = mfctl(16);
 #endif
         
@@ -406,7 +397,7 @@ resource_found:
         DBG_RES("%s() res_idx %d res_hint: %d\n",
                 __func__, res_idx, ioc->res_hint);
 
-#ifdef CCIO_SEARCH_TIME
+#ifdef CCIO_COLLECT_STATS
         {
                 unsigned long cr_end = mfctl(16);
                 unsigned long tmp = cr_end - cr_start;
@@ -416,7 +407,7 @@ resource_found:
         ioc->avg_search[ioc->avg_idx++] = cr_start;
         ioc->avg_idx &= CCIO_SEARCH_SAMPLE - 1;
 #endif
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
         ioc->used_pages += pages_needed;
 #endif
         /* 
@@ -452,7 +443,7 @@ ccio_free_range(struct ioc *ioc, dma_addr_t iova, unsigned long pages_mapped)
         DBG_RES("%s():  res_idx: %d pages_mapped %d\n", 
                 __func__, res_idx, pages_mapped);
 
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
         ioc->used_pages -= pages_mapped;
 #endif
 
@@ -764,7 +755,7 @@ ccio_map_single(struct device *dev, void *addr, size_t size,
         size = ALIGN(size + offset, IOVP_SIZE);
         spin_lock_irqsave(&ioc->res_lock, flags);
 
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
         ioc->msingle_calls++;
         ioc->msingle_pages += size >> IOVP_SHIFT;
 #endif
@@ -828,7 +819,7 @@ ccio_unmap_single(struct device *dev, dma_addr_t iova, size_t size,
 
         spin_lock_irqsave(&ioc->res_lock, flags);
 
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
         ioc->usingle_calls++;
         ioc->usingle_pages += size >> IOVP_SHIFT;
 #endif
@@ -894,7 +885,7 @@ ccio_free_consistent(struct device *dev, size_t size, void *cpu_addr,
 */
 #define PIDE_FLAG 0x80000000UL
 
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
 #define IOMMU_MAP_STATS
 #endif
 #include "iommu-helpers.h"
@@ -938,7 +929,7 @@ ccio_map_sg(struct device *dev, struct scatterlist *sglist, int nents,
         
         spin_lock_irqsave(&ioc->res_lock, flags);
 
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
         ioc->msg_calls++;
 #endif
 
@@ -997,13 +988,13 @@ ccio_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents,
         DBG_RUN_SG("%s() START %d entries,  %08lx,%x\n",
                 __func__, nents, sg_virt_addr(sglist), sglist->length);
 
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
         ioc->usg_calls++;
 #endif
 
         while(sg_dma_len(sglist) && nents--) {
 
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
                 ioc->usg_pages += sg_dma_len(sglist) >> PAGE_SHIFT;
 #endif
                 ccio_unmap_single(dev, sg_dma_address(sglist),
@@ -1048,7 +1039,7 @@ static int ccio_proc_info(struct seq_file *m, void *p)
                 len += seq_printf(m, "IO PDIR size    : %d bytes (%d entries)\n",
                                total_pages * 8, total_pages);
 
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
                 len += seq_printf(m, "IO PDIR entries : %ld free  %ld used (%d%%)\n",
                                   total_pages - ioc->used_pages, ioc->used_pages,
                                   (int)(ioc->used_pages * 100 / total_pages));
@@ -1057,7 +1048,7 @@ static int ccio_proc_info(struct seq_file *m, void *p)
                 len += seq_printf(m, "Resource bitmap : %d bytes (%d pages)\n", 
                                   ioc->res_size, total_pages);
 
-#ifdef CCIO_SEARCH_TIME
+#ifdef CCIO_COLLECT_STATS
                 min = max = ioc->avg_search[0];
                 for(j = 0; j < CCIO_SEARCH_SAMPLE; ++j) {
                         avg += ioc->avg_search[j];
@@ -1070,7 +1061,7 @@ static int ccio_proc_info(struct seq_file *m, void *p)
                 len += seq_printf(m, "  Bitmap search : %ld/%ld/%ld (min/avg/max CPU Cycles)\n",
                                   min, avg, max);
 #endif
-#ifdef CCIO_MAP_STATS
+#ifdef CCIO_COLLECT_STATS
                 len += seq_printf(m, "pci_map_single(): %8ld calls  %8ld pages (avg %d/1000)\n",
                                   ioc->msingle_calls, ioc->msingle_pages,
                                   (int)((ioc->msingle_pages * 1000)/ioc->msingle_calls));
@@ -1088,7 +1079,7 @@ static int ccio_proc_info(struct seq_file *m, void *p)
                 len += seq_printf(m, "pci_unmap_sg()  : %8ld calls  %8ld pages (avg %d/1000)\n\n\n",
                                   ioc->usg_calls, ioc->usg_pages,
                                   (int)((ioc->usg_pages * 1000)/ioc->usg_calls));
-#endif  /* CCIO_MAP_STATS */
+#endif  /* CCIO_COLLECT_STATS */
 
                 ioc = ioc->next;
         }
diff --git a/drivers/parisc/dino.c b/drivers/parisc/dino.c
index fd56128525d1..3bc54b30c3a1 100644
--- a/drivers/parisc/dino.c
+++ b/drivers/parisc/dino.c
@@ -298,7 +298,8 @@ struct pci_port_ops dino_port_ops = {
 
 static void dino_disable_irq(unsigned int irq)
 {
-        struct dino_device *dino_dev = irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct dino_device *dino_dev = desc->chip_data;
         int local_irq = gsc_find_local_irq(irq, dino_dev->global_irq, DINO_LOCAL_IRQS);
 
         DBG(KERN_WARNING "%s(0x%p, %d)\n", __func__, dino_dev, irq);
@@ -310,7 +311,8 @@ static void dino_disable_irq(unsigned int irq)
 
 static void dino_enable_irq(unsigned int irq)
 {
-        struct dino_device *dino_dev = irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct dino_device *dino_dev = desc->chip_data;
         int local_irq = gsc_find_local_irq(irq, dino_dev->global_irq, DINO_LOCAL_IRQS);
         u32 tmp;
 
diff --git a/drivers/parisc/eisa.c b/drivers/parisc/eisa.c
index 771cef592542..7891db50c483 100644
--- a/drivers/parisc/eisa.c
+++ b/drivers/parisc/eisa.c
@@ -346,10 +346,10 @@ static int __init eisa_probe(struct parisc_device *dev)
         }
         
         /* Reserve IRQ2 */
-        irq_desc[2].action = &irq2_action;
+        irq_to_desc(2)->action = &irq2_action;
         
         for (i = 0; i < 16; i++) {
-                irq_desc[i].chip = &eisa_interrupt_type;
+                irq_to_desc(i)->chip = &eisa_interrupt_type;
         }
         
         EISA_bus = 1;
diff --git a/drivers/parisc/gsc.c b/drivers/parisc/gsc.c
index f7d088b897ee..e76db9e4d504 100644
--- a/drivers/parisc/gsc.c
+++ b/drivers/parisc/gsc.c
@@ -108,7 +108,8 @@ int gsc_find_local_irq(unsigned int irq, int *global_irqs, int limit)
 
 static void gsc_asic_disable_irq(unsigned int irq)
 {
-        struct gsc_asic *irq_dev = irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct gsc_asic *irq_dev = desc->chip_data;
         int local_irq = gsc_find_local_irq(irq, irq_dev->global_irq, 32);
         u32 imr;
 
@@ -123,7 +124,8 @@ static void gsc_asic_disable_irq(unsigned int irq)
 
 static void gsc_asic_enable_irq(unsigned int irq)
 {
-        struct gsc_asic *irq_dev = irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct gsc_asic *irq_dev = desc->chip_data;
         int local_irq = gsc_find_local_irq(irq, irq_dev->global_irq, 32);
         u32 imr;
 
@@ -159,12 +161,14 @@ static struct hw_interrupt_type gsc_asic_interrupt_type = {
 int gsc_assign_irq(struct hw_interrupt_type *type, void *data)
 {
         static int irq = GSC_IRQ_BASE;
+        struct irq_desc *desc;
 
         if (irq > GSC_IRQ_MAX)
                 return NO_IRQ;
 
-        irq_desc[irq].chip = type;
-        irq_desc[irq].chip_data = data;
+        desc = irq_to_desc(irq);
+        desc->chip = type;
+        desc->chip_data = data;
         return irq++;
 }
 
diff --git a/drivers/parisc/iosapic.c b/drivers/parisc/iosapic.c
index 6fb3f7979f21..7beffcab2745 100644
--- a/drivers/parisc/iosapic.c
+++ b/drivers/parisc/iosapic.c
@@ -619,7 +619,9 @@ iosapic_set_irt_data( struct vector_info *vi, u32 *dp0, u32 *dp1)
 
 static struct vector_info *iosapic_get_vector(unsigned int irq)
 {
-        return irq_desc[irq].chip_data;
+        struct irq_desc *desc = irq_to_desc(irq);
+
+        return desc->chip_data;
 }
 
 static void iosapic_disable_irq(unsigned int irq)
diff --git a/drivers/parisc/superio.c b/drivers/parisc/superio.c
index 1e8d2d17f04c..1e93c837514f 100644
--- a/drivers/parisc/superio.c
+++ b/drivers/parisc/superio.c
@@ -363,7 +363,9 @@ int superio_fixup_irq(struct pci_dev *pcidev)
 #endif
 
         for (i = 0; i < 16; i++) {
-                irq_desc[i].chip = &superio_interrupt_type;
+                struct irq_desc *desc = irq_to_desc(i);
+
+                desc->chip = &superio_interrupt_type;
         }
 
         /*
diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c
index 529d9d7727b0..999cc4088b59 100644
--- a/drivers/pci/bus.c
+++ b/drivers/pci/bus.c
@@ -151,6 +151,13 @@ void pci_bus_add_devices(struct pci_bus *bus)
                         if (retval)
                                 dev_err(&dev->dev, "Error creating cpuaffinity"
                                         " file, continuing...\n");
+
+                        retval = device_create_file(&child_bus->dev,
+                                                &dev_attr_cpulistaffinity);
+                        if (retval)
+                                dev_err(&dev->dev,
+                                        "Error creating cpulistaffinity"
+                                        " file, continuing...\n");
                 }
         }
 }
diff --git a/drivers/pci/dmar.c b/drivers/pci/dmar.c
index e842e756308a..8b29c307f1a1 100644
--- a/drivers/pci/dmar.c
+++ b/drivers/pci/dmar.c
@@ -193,7 +193,7 @@ dmar_parse_dev(struct dmar_drhd_unit *dmaru)
 {
         struct acpi_dmar_hardware_unit *drhd;
         static int include_all;
-        int ret;
+        int ret = 0;
 
         drhd = (struct acpi_dmar_hardware_unit *) dmaru->hdr;
 
@@ -212,7 +212,7 @@ dmar_parse_dev(struct dmar_drhd_unit *dmaru)
                 include_all = 1;
         }
 
-        if (ret || (dmaru->devices_cnt == 0 && !dmaru->include_all)) {
+        if (ret) {
                 list_del(&dmaru->list);
                 kfree(dmaru);
         }
@@ -289,6 +289,24 @@ dmar_table_print_dmar_entry(struct acpi_dmar_header *header)
         }
 }
 
+/**
+ * dmar_table_detect - checks to see if the platform supports DMAR devices
+ */
+static int __init dmar_table_detect(void)
+{
+        acpi_status status = AE_OK;
+
+        /* if we could find DMAR table, then there are DMAR devices */
+        status = acpi_get_table(ACPI_SIG_DMAR, 0,
+                                (struct acpi_table_header **)&dmar_tbl);
+
+        if (ACPI_SUCCESS(status) && !dmar_tbl) {
+                printk (KERN_WARNING PREFIX "Unable to map DMAR\n");
+                status = AE_NOT_FOUND;
+        }
+
+        return (ACPI_SUCCESS(status) ? 1 : 0);
+}
 
 /**
  * parse_dmar_table - parses the DMA reporting table
@@ -300,6 +318,12 @@ parse_dmar_table(void)
         struct acpi_dmar_header *entry_header;
         int ret = 0;
 
+        /*
+         * Do it again, earlier dmar_tbl mapping could be mapped with
+         * fixed map.
+         */
+        dmar_table_detect();
+
         dmar = (struct acpi_table_dmar *)dmar_tbl;
         if (!dmar)
                 return -ENODEV;
@@ -373,10 +397,10 @@ dmar_find_matched_drhd_unit(struct pci_dev *dev)
 
 int __init dmar_dev_scope_init(void)
 {
-        struct dmar_drhd_unit *drhd;
+        struct dmar_drhd_unit *drhd, *drhd_n;
         int ret = -ENODEV;
 
-        for_each_drhd_unit(drhd) {
+        list_for_each_entry_safe(drhd, drhd_n, &dmar_drhd_units, list) {
                 ret = dmar_parse_dev(drhd);
                 if (ret)
                         return ret;
@@ -384,8 +408,8 @@ int __init dmar_dev_scope_init(void)
 
 #ifdef CONFIG_DMAR
         {
-                struct dmar_rmrr_unit *rmrr;
-                for_each_rmrr_units(rmrr) {
+                struct dmar_rmrr_unit *rmrr, *rmrr_n;
+                list_for_each_entry_safe(rmrr, rmrr_n, &dmar_rmrr_units, list) {
                         ret = rmrr_parse_dev(rmrr);
                         if (ret)
                                 return ret;
@@ -430,30 +454,11 @@ int __init dmar_table_init(void)
         return 0;
 }
 
-/**
- * early_dmar_detect - checks to see if the platform supports DMAR devices
- */
-int __init early_dmar_detect(void)
-{
-        acpi_status status = AE_OK;
-
-        /* if we could find DMAR table, then there are DMAR devices */
-        status = acpi_get_table(ACPI_SIG_DMAR, 0,
-                                (struct acpi_table_header **)&dmar_tbl);
-
-        if (ACPI_SUCCESS(status) && !dmar_tbl) {
-                printk (KERN_WARNING PREFIX "Unable to map DMAR\n");
-                status = AE_NOT_FOUND;
-        }
-
-        return (ACPI_SUCCESS(status) ? 1 : 0);
-}
-
 void __init detect_intel_iommu(void)
 {
         int ret;
 
-        ret = early_dmar_detect();
+        ret = dmar_table_detect();
 
 #ifdef CONFIG_DMAR
         {
@@ -479,14 +484,16 @@ void __init detect_intel_iommu(void)
                                " x2apic support\n");
 
                         dmar_disabled = 1;
-                        return;
+                        goto end;
                 }
 
                 if (ret && !no_iommu && !iommu_detected && !swiotlb &&
                     !dmar_disabled)
                         iommu_detected = 1;
         }
+end:
 #endif
+        dmar_tbl = NULL;
 }
 
 
diff --git a/drivers/pci/hotplug/ibmphp_ebda.c b/drivers/pci/hotplug/ibmphp_ebda.c
index 7d27631e6e62..8cfd1c4926c8 100644
--- a/drivers/pci/hotplug/ibmphp_ebda.c
+++ b/drivers/pci/hotplug/ibmphp_ebda.c
@@ -123,10 +123,8 @@ static struct ebda_pci_rsrc *alloc_ebda_pci_rsrc (void)
 static void __init print_bus_info (void)
 {
         struct bus_info *ptr;
-        struct list_head *ptr1;
         
-        list_for_each (ptr1, &bus_info_head) {
-                ptr = list_entry (ptr1, struct bus_info, bus_info_list);
+        list_for_each_entry(ptr, &bus_info_head, bus_info_list) {
                 debug ("%s - slot_min = %x\n", __func__, ptr->slot_min);
                 debug ("%s - slot_max = %x\n", __func__, ptr->slot_max);
                 debug ("%s - slot_count = %x\n", __func__, ptr->slot_count);
@@ -146,10 +144,8 @@ static void __init print_bus_info (void)
 static void print_lo_info (void)
 {
         struct rio_detail *ptr;
-        struct list_head *ptr1;
         debug ("print_lo_info ----\n"); 
-        list_for_each (ptr1, &rio_lo_head) {
-                ptr = list_entry (ptr1, struct rio_detail, rio_detail_list);
+        list_for_each_entry(ptr, &rio_lo_head, rio_detail_list) {
                 debug ("%s - rio_node_id = %x\n", __func__, ptr->rio_node_id);
                 debug ("%s - rio_type = %x\n", __func__, ptr->rio_type);
                 debug ("%s - owner_id = %x\n", __func__, ptr->owner_id);
@@ -163,10 +159,8 @@ static void print_lo_info (void)
 static void print_vg_info (void)
 {
         struct rio_detail *ptr;
-        struct list_head *ptr1;
         debug ("%s ---\n", __func__);
-        list_for_each (ptr1, &rio_vg_head) {
-                ptr = list_entry (ptr1, struct rio_detail, rio_detail_list);
+        list_for_each_entry(ptr, &rio_vg_head, rio_detail_list) {
                 debug ("%s - rio_node_id = %x\n", __func__, ptr->rio_node_id);
                 debug ("%s - rio_type = %x\n", __func__, ptr->rio_type);
                 debug ("%s - owner_id = %x\n", __func__, ptr->owner_id);
@@ -180,10 +174,8 @@ static void print_vg_info (void)
 static void __init print_ebda_pci_rsrc (void)
 {
         struct ebda_pci_rsrc *ptr;
-        struct list_head *ptr1;
 
-        list_for_each (ptr1, &ibmphp_ebda_pci_rsrc_head) {
-                ptr = list_entry (ptr1, struct ebda_pci_rsrc, ebda_pci_rsrc_list);
+        list_for_each_entry(ptr, &ibmphp_ebda_pci_rsrc_head, ebda_pci_rsrc_list) {
                 debug ("%s - rsrc type: %x bus#: %x dev_func: %x start addr: %x end addr: %x\n", 
                         __func__, ptr->rsrc_type ,ptr->bus_num, ptr->dev_fun,ptr->start_addr, ptr->end_addr);
         }
@@ -192,10 +184,8 @@ static void __init print_ebda_pci_rsrc (void)
 static void __init print_ibm_slot (void)
 {
         struct slot *ptr;
-        struct list_head *ptr1;
 
-        list_for_each (ptr1, &ibmphp_slot_head) {
-                ptr = list_entry (ptr1, struct slot, ibm_slot_list);
+        list_for_each_entry(ptr, &ibmphp_slot_head, ibm_slot_list) {
                 debug ("%s - slot_number: %x\n", __func__, ptr->number);
         }
 }
@@ -203,10 +193,8 @@ static void __init print_ibm_slot (void)
 static void __init print_opt_vg (void)
 {
         struct opt_rio *ptr;
-        struct list_head *ptr1;
         debug ("%s ---\n", __func__);
-        list_for_each (ptr1, &opt_vg_head) {
-                ptr = list_entry (ptr1, struct opt_rio, opt_rio_list);
+        list_for_each_entry(ptr, &opt_vg_head, opt_rio_list) {
                 debug ("%s - rio_type %x\n", __func__, ptr->rio_type);
                 debug ("%s - chassis_num: %x\n", __func__, ptr->chassis_num);
                 debug ("%s - first_slot_num: %x\n", __func__, ptr->first_slot_num);
@@ -217,13 +205,9 @@ static void __init print_opt_vg (void)
 static void __init print_ebda_hpc (void)
 {
         struct controller *hpc_ptr;
-        struct list_head *ptr1;
         u16 index;
 
-        list_for_each (ptr1, &ebda_hpc_head) {
-
-                hpc_ptr = list_entry (ptr1, struct controller, ebda_hpc_list); 
-
+        list_for_each_entry(hpc_ptr, &ebda_hpc_head, ebda_hpc_list) {
                 for (index = 0; index < hpc_ptr->slot_count; index++) {
                         debug ("%s - physical slot#: %x\n", __func__, hpc_ptr->slots[index].slot_num);
                         debug ("%s - pci bus# of the slot: %x\n", __func__, hpc_ptr->slots[index].slot_bus_num);
@@ -460,9 +444,7 @@ static int __init ebda_rio_table (void)
 static struct opt_rio *search_opt_vg (u8 chassis_num)
 {
         struct opt_rio *ptr;
-        struct list_head *ptr1;
-        list_for_each (ptr1, &opt_vg_head) {
-                ptr = list_entry (ptr1, struct opt_rio, opt_rio_list);
+        list_for_each_entry(ptr, &opt_vg_head, opt_rio_list) {
                 if (ptr->chassis_num == chassis_num)
                         return ptr;
         }               
@@ -473,10 +455,8 @@ static int __init combine_wpg_for_chassis (void)
 {
         struct opt_rio *opt_rio_ptr = NULL;
         struct rio_detail *rio_detail_ptr = NULL;
-        struct list_head *list_head_ptr = NULL;
         
-        list_for_each (list_head_ptr, &rio_vg_head) {
-                rio_detail_ptr = list_entry (list_head_ptr, struct rio_detail, rio_detail_list);
+        list_for_each_entry(rio_detail_ptr, &rio_vg_head, rio_detail_list) {
                 opt_rio_ptr = search_opt_vg (rio_detail_ptr->chassis_num);
                 if (!opt_rio_ptr) {
                         opt_rio_ptr = kzalloc(sizeof(struct opt_rio), GFP_KERNEL);
@@ -497,14 +477,12 @@ static int __init combine_wpg_for_chassis (void)
 }       
 
 /*
- * reorgnizing linked list of expansion box      
+ * reorganizing linked list of expansion box
  */
 static struct opt_rio_lo *search_opt_lo (u8 chassis_num)
 {
         struct opt_rio_lo *ptr;
-        struct list_head *ptr1;
-        list_for_each (ptr1, &opt_lo_head) {
-                ptr = list_entry (ptr1, struct opt_rio_lo, opt_rio_lo_list);
+        list_for_each_entry(ptr, &opt_lo_head, opt_rio_lo_list) {
                 if (ptr->chassis_num == chassis_num)
                         return ptr;
         }               
@@ -515,10 +493,8 @@ static int combine_wpg_for_expansion (void)
 {
         struct opt_rio_lo *opt_rio_lo_ptr = NULL;
         struct rio_detail *rio_detail_ptr = NULL;
-        struct list_head *list_head_ptr = NULL;
         
-        list_for_each (list_head_ptr, &rio_lo_head) {
-                rio_detail_ptr = list_entry (list_head_ptr, struct rio_detail, rio_detail_list);
+        list_for_each_entry(rio_detail_ptr, &rio_lo_head, rio_detail_list) {
                 opt_rio_lo_ptr = search_opt_lo (rio_detail_ptr->chassis_num);
                 if (!opt_rio_lo_ptr) {
                         opt_rio_lo_ptr = kzalloc(sizeof(struct opt_rio_lo), GFP_KERNEL);
@@ -550,20 +526,17 @@ static int first_slot_num (u8 slot_num, u8 first_slot, u8 var)
 {
         struct opt_rio *opt_vg_ptr = NULL;
         struct opt_rio_lo *opt_lo_ptr = NULL;
-        struct list_head *ptr = NULL;
         int rc = 0;
 
         if (!var) {
-                list_for_each (ptr, &opt_vg_head) {
-                        opt_vg_ptr = list_entry (ptr, struct opt_rio, opt_rio_list);
+                list_for_each_entry(opt_vg_ptr, &opt_vg_head, opt_rio_list) {
                         if ((first_slot < opt_vg_ptr->first_slot_num) && (slot_num >= opt_vg_ptr->first_slot_num)) { 
                                 rc = -ENODEV;
                                 break;
                         }
                 }
         } else {
-                list_for_each (ptr, &opt_lo_head) {
-                        opt_lo_ptr = list_entry (ptr, struct opt_rio_lo, opt_rio_lo_list);
+                list_for_each_entry(opt_lo_ptr, &opt_lo_head, opt_rio_lo_list) {
                         if ((first_slot < opt_lo_ptr->first_slot_num) && (slot_num >= opt_lo_ptr->first_slot_num)) {
                                 rc = -ENODEV;
                                 break;
@@ -576,10 +549,8 @@ static int first_slot_num (u8 slot_num, u8 first_slot, u8 var)
 static struct opt_rio_lo * find_rxe_num (u8 slot_num)
 {
         struct opt_rio_lo *opt_lo_ptr;
-        struct list_head *ptr;
 
-        list_for_each (ptr, &opt_lo_head) {
-                opt_lo_ptr = list_entry (ptr, struct opt_rio_lo, opt_rio_lo_list);
+        list_for_each_entry(opt_lo_ptr, &opt_lo_head, opt_rio_lo_list) {
                 //check to see if this slot_num belongs to expansion box
                 if ((slot_num >= opt_lo_ptr->first_slot_num) && (!first_slot_num (slot_num, opt_lo_ptr->first_slot_num, 1))) 
                         return opt_lo_ptr;
@@ -590,10 +561,8 @@ static struct opt_rio_lo * find_rxe_num (u8 slot_num)
 static struct opt_rio * find_chassis_num (u8 slot_num)
 {
         struct opt_rio *opt_vg_ptr;
-        struct list_head *ptr;
 
-        list_for_each (ptr, &opt_vg_head) {
-                opt_vg_ptr = list_entry (ptr, struct opt_rio, opt_rio_list);
+        list_for_each_entry(opt_vg_ptr, &opt_vg_head, opt_rio_list) {
                 //check to see if this slot_num belongs to chassis 
                 if ((slot_num >= opt_vg_ptr->first_slot_num) && (!first_slot_num (slot_num, opt_vg_ptr->first_slot_num, 0))) 
                         return opt_vg_ptr;
@@ -607,11 +576,9 @@ static struct opt_rio * find_chassis_num (u8 slot_num)
 static u8 calculate_first_slot (u8 slot_num)
 {
         u8 first_slot = 1;
-        struct list_head * list;
         struct slot * slot_cur;
         
-        list_for_each (list, &ibmphp_slot_head) {
-                slot_cur = list_entry (list, struct slot, ibm_slot_list);
+        list_for_each_entry(slot_cur, &ibmphp_slot_head, ibm_slot_list) {
                 if (slot_cur->ctrl) {
                         if ((slot_cur->ctrl->ctlr_type != 4) && (slot_cur->ctrl->ending_slot_num > first_slot) && (slot_num > slot_cur->ctrl->ending_slot_num)) 
                                 first_slot = slot_cur->ctrl->ending_slot_num;
@@ -767,7 +734,6 @@ static int __init ebda_rsrc_controller (void)
         struct bus_info *bus_info_ptr1, *bus_info_ptr2;
         int rc;
         struct slot *tmp_slot;
-        struct list_head *list;
 
         addr = hpc_list_ptr->phys_addr;
         for (ctlr = 0; ctlr < hpc_list_ptr->num_ctlrs; ctlr++) {
@@ -997,9 +963,7 @@ static int __init ebda_rsrc_controller (void)
 
         }                       /* each hpc  */
 
-        list_for_each (list, &ibmphp_slot_head) {
-                tmp_slot = list_entry (list, struct slot, ibm_slot_list);
-
+        list_for_each_entry(tmp_slot, &ibmphp_slot_head, ibm_slot_list) {
                 snprintf (tmp_slot->hotplug_slot->name, 30, "%s", create_file_name (tmp_slot));
                 pci_hp_register(tmp_slot->hotplug_slot,
                         pci_find_bus(0, tmp_slot->bus), tmp_slot->device);
@@ -1101,10 +1065,8 @@ u16 ibmphp_get_total_controllers (void)
 struct slot *ibmphp_get_slot_from_physical_num (u8 physical_num)
 {
         struct slot *slot;
-        struct list_head *list;
 
-        list_for_each (list, &ibmphp_slot_head) {
-                slot = list_entry (list, struct slot, ibm_slot_list);
+        list_for_each_entry(slot, &ibmphp_slot_head, ibm_slot_list) {
                 if (slot->number == physical_num)
                         return slot;
         }
@@ -1120,10 +1082,8 @@ struct slot *ibmphp_get_slot_from_physical_num (u8 physical_num)
 struct bus_info *ibmphp_find_same_bus_num (u32 num)
 {
         struct bus_info *ptr;
-        struct list_head  *ptr1;
 
-        list_for_each (ptr1, &bus_info_head) {
-                ptr = list_entry (ptr1, struct bus_info, bus_info_list); 
+        list_for_each_entry(ptr, &bus_info_head, bus_info_list) {
                 if (ptr->busno == num) 
                          return ptr;
         }
@@ -1136,10 +1096,8 @@ struct bus_info *ibmphp_find_same_bus_num (u32 num)
 int ibmphp_get_bus_index (u8 num)
 {
         struct bus_info *ptr;
-        struct list_head  *ptr1;
 
-        list_for_each (ptr1, &bus_info_head) {
-                ptr = list_entry (ptr1, struct bus_info, bus_info_list);
+        list_for_each_entry(ptr, &bus_info_head, bus_info_list) {
                 if (ptr->busno == num)  
                         return ptr->index;
         }
@@ -1212,11 +1170,9 @@ static struct pci_driver ibmphp_driver = {
 int ibmphp_register_pci (void)
 {
         struct controller *ctrl;
-        struct list_head *tmp;
         int rc = 0;
 
-        list_for_each (tmp, &ebda_hpc_head) {
-                ctrl = list_entry (tmp, struct controller, ebda_hpc_list);
+        list_for_each_entry(ctrl, &ebda_hpc_head, ebda_hpc_list) {
                 if (ctrl->ctlr_type == 1) {
                         rc = pci_register_driver(&ibmphp_driver);
                         break;
@@ -1227,12 +1183,10 @@ int ibmphp_register_pci (void)
 static int ibmphp_probe (struct pci_dev * dev, const struct pci_device_id *ids)
 {
         struct controller *ctrl;
-        struct list_head *tmp;
 
         debug ("inside ibmphp_probe\n");
         
-        list_for_each (tmp, &ebda_hpc_head) {
-                ctrl = list_entry (tmp, struct controller, ebda_hpc_list);
+        list_for_each_entry(ctrl, &ebda_hpc_head, ebda_hpc_list) {
                 if (ctrl->ctlr_type == 1) {
                         if ((dev->devfn == ctrl->u.pci_ctlr.dev_fun) && (dev->bus->number == ctrl->u.pci_ctlr.bus)) {
                                 ctrl->ctrl_dev = dev;
diff --git a/drivers/pci/hotplug/pci_hotplug_core.c b/drivers/pci/hotplug/pci_hotplug_core.c
index 5f85b1b120e3..2e6c4474644e 100644
--- a/drivers/pci/hotplug/pci_hotplug_core.c
+++ b/drivers/pci/hotplug/pci_hotplug_core.c
@@ -102,13 +102,13 @@ static int get_##name (struct hotplug_slot *slot, type *value)		\
 {                                                                       \
         struct hotplug_slot_ops *ops = slot->ops;                       \
         int retval = 0;                                                 \
-        if (try_module_get(ops->owner)) {                               \
-                if (ops->get_##name)                                    \
-                        retval = ops->get_##name(slot, value);          \
-                else                                                    \
-                        *value = slot->info->name;                      \
-                module_put(ops->owner);                                 \
-        }                                                               \
+        if (!try_module_get(ops->owner))                                \
+                return -ENODEV;                                         \
+        if (ops->get_##name)                                            \
+                retval = ops->get_##name(slot, value);                  \
+        else                                                            \
+                *value = slot->info->name;                              \
+        module_put(ops->owner);                                         \
         return retval;                                                  \
 }
 
diff --git a/drivers/pci/hotplug/pciehp.h b/drivers/pci/hotplug/pciehp.h
index 9e6cec67e1cc..c367978bd7fe 100644
--- a/drivers/pci/hotplug/pciehp.h
+++ b/drivers/pci/hotplug/pciehp.h
@@ -57,6 +57,19 @@ extern struct workqueue_struct *pciehp_wq;
 #define warn(format, arg...)                                            \
         printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)
 
+#define ctrl_dbg(ctrl, format, arg...)                                  \
+        do {                                                            \
+                if (pciehp_debug)                                       \
+                        dev_printk(, &ctrl->pcie->device,               \
+                                        format, ## arg);                \
+        } while (0)
+#define ctrl_err(ctrl, format, arg...)                                  \
+        dev_err(&ctrl->pcie->device, format, ## arg)
+#define ctrl_info(ctrl, format, arg...)                                 \
+        dev_info(&ctrl->pcie->device, format, ## arg)
+#define ctrl_warn(ctrl, format, arg...)                                 \
+        dev_warn(&ctrl->pcie->device, format, ## arg)
+
 #define SLOT_NAME_SIZE 10
 struct slot {
         u8 bus;
@@ -87,6 +100,7 @@ struct controller {
         int num_slots;                  /* Number of slots on ctlr */
         int slot_num_inc;               /* 1 or -1 */
         struct pci_dev *pci_dev;
+        struct pcie_device *pcie;       /* PCI Express port service */
         struct list_head slot_list;
         struct hpc_ops *hpc_ops;
         wait_queue_head_t queue;        /* sleep & wake process */
@@ -170,7 +184,7 @@ static inline struct slot *pciehp_find_slot(struct controller *ctrl, u8 device)
                         return slot;
         }
 
-        err("%s: slot (device=0x%x) not found\n", __func__, device);
+        ctrl_err(ctrl, "%s: slot (device=0x%x) not found\n", __func__, device);
         return NULL;
 }
 
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index 4fd5355bc3b5..c748a19db89d 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -144,9 +144,10 @@ set_lock_exit:
  * sysfs interface which allows the user to toggle the Electro Mechanical
  * Interlock.  Valid values are either 0 or 1.  0 == unlock, 1 == lock
  */
-static ssize_t lock_write_file(struct hotplug_slot *slot, const char *buf,
-                size_t count)
+static ssize_t lock_write_file(struct hotplug_slot *hotplug_slot,
+                const char *buf, size_t count)
 {
+        struct slot *slot = hotplug_slot->private;
         unsigned long llock;
         u8 lock;
         int retval = 0;
@@ -157,10 +158,11 @@ static ssize_t lock_write_file(struct hotplug_slot *slot, const char *buf,
         switch (lock) {
                 case 0:
                 case 1:
-                        retval = set_lock_status(slot, lock);
+                        retval = set_lock_status(hotplug_slot, lock);
                         break;
                 default:
-                        err ("%d is an invalid lock value\n", lock);
+                        ctrl_err(slot->ctrl, "%d is an invalid lock value\n",
+                                 lock);
                         retval = -EINVAL;
         }
         if (retval)
@@ -180,7 +182,10 @@ static struct hotplug_slot_attribute hotplug_slot_attr_lock = {
  */
 static void release_slot(struct hotplug_slot *hotplug_slot)
 {
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        struct slot *slot = hotplug_slot->private;
+
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                 __func__, hotplug_slot->name);
 
         kfree(hotplug_slot->info);
         kfree(hotplug_slot);
@@ -215,9 +220,9 @@ static int init_slots(struct controller *ctrl)
                 get_adapter_status(hotplug_slot, &info->adapter_status);
                 slot->hotplug_slot = hotplug_slot;
 
-                dbg("Registering bus=%x dev=%x hp_slot=%x sun=%x "
-                    "slot_device_offset=%x\n", slot->bus, slot->device,
-                    slot->hp_slot, slot->number, ctrl->slot_device_offset);
+                ctrl_dbg(ctrl, "Registering bus=%x dev=%x hp_slot=%x sun=%x "
+                         "slot_device_offset=%x\n", slot->bus, slot->device,
+                         slot->hp_slot, slot->number, ctrl->slot_device_offset);
 duplicate_name:
                 retval = pci_hp_register(hotplug_slot,
                                          ctrl->pci_dev->subordinate,
@@ -233,9 +238,11 @@ duplicate_name:
                                 if (len < SLOT_NAME_SIZE)
                                         goto duplicate_name;
                                 else
-                                        err("duplicate slot name overflow\n");
+                                        ctrl_err(ctrl, "duplicate slot name "
+                                                 "overflow\n");
                         }
-                        err("pci_hp_register failed with error %d\n", retval);
+                        ctrl_err(ctrl, "pci_hp_register failed with error %d\n",
+                                 retval);
                         goto error_info;
                 }
                 /* create additional sysfs entries */
@@ -244,7 +251,8 @@ duplicate_name:
                                 &hotplug_slot_attr_lock.attr);
                         if (retval) {
                                 pci_hp_deregister(hotplug_slot);
-                                err("cannot create additional sysfs entries\n");
+                                ctrl_err(ctrl, "cannot create additional sysfs "
+                                         "entries\n");
                                 goto error_info;
                         }
                 }
@@ -278,7 +286,8 @@ static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 status)
 {
         struct slot *slot = hotplug_slot->private;
 
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                  __func__, hotplug_slot->name);
 
         hotplug_slot->info->attention_status = status;
 
@@ -293,7 +302,8 @@ static int enable_slot(struct hotplug_slot *hotplug_slot)
 {
         struct slot *slot = hotplug_slot->private;
 
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                 __func__, hotplug_slot->name);
 
         return pciehp_sysfs_enable_slot(slot);
 }
@@ -303,7 +313,8 @@ static int disable_slot(struct hotplug_slot *hotplug_slot)
 {
         struct slot *slot = hotplug_slot->private;
 
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                  __func__, hotplug_slot->name);
 
         return pciehp_sysfs_disable_slot(slot);
 }
@@ -313,7 +324,8 @@ static int get_power_status(struct hotplug_slot *hotplug_slot, u8 *value)
         struct slot *slot = hotplug_slot->private;
         int retval;
 
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                  __func__, hotplug_slot->name);
 
         retval = slot->hpc_ops->get_power_status(slot, value);
         if (retval < 0)
@@ -327,7 +339,8 @@ static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 *value)
         struct slot *slot = hotplug_slot->private;
         int retval;
 
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                  __func__, hotplug_slot->name);
 
         retval = slot->hpc_ops->get_attention_status(slot, value);
         if (retval < 0)
@@ -341,7 +354,8 @@ static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 *value)
         struct slot *slot = hotplug_slot->private;
         int retval;
 
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                 __func__, hotplug_slot->name);
 
         retval = slot->hpc_ops->get_latch_status(slot, value);
         if (retval < 0)
@@ -355,7 +369,8 @@ static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
         struct slot *slot = hotplug_slot->private;
         int retval;
 
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                 __func__, hotplug_slot->name);
 
         retval = slot->hpc_ops->get_adapter_status(slot, value);
         if (retval < 0)
@@ -370,7 +385,8 @@ static int get_max_bus_speed(struct hotplug_slot *hotplug_slot,
         struct slot *slot = hotplug_slot->private;
         int retval;
 
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                 __func__, hotplug_slot->name);
 
         retval = slot->hpc_ops->get_max_bus_speed(slot, value);
         if (retval < 0)
@@ -384,7 +400,8 @@ static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_spe
         struct slot *slot = hotplug_slot->private;
         int retval;
 
-        dbg("%s - physical_slot = %s\n", __func__, hotplug_slot->name);
+        ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
+                 __func__, hotplug_slot->name);
 
         retval = slot->hpc_ops->get_cur_bus_speed(slot, value);
         if (retval < 0)
@@ -402,14 +419,15 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
         struct pci_dev *pdev = dev->port;
 
         if (pciehp_force)
-                dbg("Bypassing BIOS check for pciehp use on %s\n",
-                    pci_name(pdev));
+                dev_info(&dev->device,
+                         "Bypassing BIOS check for pciehp use on %s\n",
+                         pci_name(pdev));
         else if (pciehp_get_hp_hw_control_from_firmware(pdev))
                 goto err_out_none;
 
         ctrl = pcie_init(dev);
         if (!ctrl) {
-                dbg("%s: controller initialization failed\n", PCIE_MODULE_NAME);
+                dev_err(&dev->device, "controller initialization failed\n");
                 goto err_out_none;
         }
         set_service_data(dev, ctrl);
@@ -418,11 +436,10 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
         rc = init_slots(ctrl);
         if (rc) {
                 if (rc == -EBUSY)
-                        warn("%s: slot already registered by another "
-                                "hotplug driver\n", PCIE_MODULE_NAME);
+                        ctrl_warn(ctrl, "slot already registered by another "
+                                  "hotplug driver\n");
                 else
-                        err("%s: slot initialization failed\n",
-                                PCIE_MODULE_NAME);
+                        ctrl_err(ctrl, "slot initialization failed\n");
                 goto err_out_release_ctlr;
         }
 
@@ -461,13 +478,13 @@ static void pciehp_remove (struct pcie_device *dev)
 #ifdef CONFIG_PM
 static int pciehp_suspend (struct pcie_device *dev, pm_message_t state)
 {
-        printk("%s ENTRY\n", __func__);
+        dev_info(&dev->device, "%s ENTRY\n", __func__);
         return 0;
 }
 
 static int pciehp_resume (struct pcie_device *dev)
 {
-        printk("%s ENTRY\n", __func__);
+        dev_info(&dev->device, "%s ENTRY\n", __func__);
         if (pciehp_force) {
                 struct controller *ctrl = get_service_data(dev);
                 struct slot *t_slot;
@@ -497,10 +514,9 @@ static struct pcie_port_service_id port_pci_ids[] = { {
         .driver_data =  0,
         }, { /* end: all zeroes */ }
 };
-static const char device_name[] = "hpdriver";
 
 static struct pcie_port_service_driver hpdriver_portdrv = {
-        .name           = (char *)device_name,
+        .name           = PCIE_MODULE_NAME,
         .id_table       = &port_pci_ids[0],
 
         .probe          = pciehp_probe,
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index 96a5d55a4983..acb7f9efd182 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -58,14 +58,15 @@ static int queue_interrupt_event(struct slot *p_slot, u32 event_type)
 u8 pciehp_handle_attention_button(struct slot *p_slot)
 {
         u32 event_type;
+        struct controller *ctrl = p_slot->ctrl;
 
         /* Attention Button Change */
-        dbg("pciehp:  Attention button interrupt received.\n");
+        ctrl_dbg(ctrl, "Attention button interrupt received.\n");
 
         /*
          *  Button pressed - See if need to TAKE ACTION!!!
          */
-        info("Button pressed on Slot(%s)\n", p_slot->name);
+        ctrl_info(ctrl, "Button pressed on Slot(%s)\n", p_slot->name);
         event_type = INT_BUTTON_PRESS;
 
         queue_interrupt_event(p_slot, event_type);
@@ -77,22 +78,23 @@ u8 pciehp_handle_switch_change(struct slot *p_slot)
 {
         u8 getstatus;
         u32 event_type;
+        struct controller *ctrl = p_slot->ctrl;
 
         /* Switch Change */
-        dbg("pciehp:  Switch interrupt received.\n");
+        ctrl_dbg(ctrl, "Switch interrupt received.\n");
 
         p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
         if (getstatus) {
                 /*
                  * Switch opened
                  */
-                info("Latch open on Slot(%s)\n", p_slot->name);
+                ctrl_info(ctrl, "Latch open on Slot(%s)\n", p_slot->name);
                 event_type = INT_SWITCH_OPEN;
         } else {
                 /*
                  *  Switch closed
                  */
-                info("Latch close on Slot(%s)\n", p_slot->name);
+                ctrl_info(ctrl, "Latch close on Slot(%s)\n", p_slot->name);
                 event_type = INT_SWITCH_CLOSE;
         }
 
@@ -105,9 +107,10 @@ u8 pciehp_handle_presence_change(struct slot *p_slot)
 {
         u32 event_type;
         u8 presence_save;
+        struct controller *ctrl = p_slot->ctrl;
 
         /* Presence Change */
-        dbg("pciehp:  Presence/Notify input change.\n");
+        ctrl_dbg(ctrl, "Presence/Notify input change.\n");
 
         /* Switch is open, assume a presence change
          * Save the presence state
@@ -117,13 +120,13 @@ u8 pciehp_handle_presence_change(struct slot *p_slot)
                 /*
                  * Card Present
                  */
-                info("Card present on Slot(%s)\n", p_slot->name);
+                ctrl_info(ctrl, "Card present on Slot(%s)\n", p_slot->name);
                 event_type = INT_PRESENCE_ON;
         } else {
                 /*
                  * Not Present
                  */
-                info("Card not present on Slot(%s)\n", p_slot->name);
+                ctrl_info(ctrl, "Card not present on Slot(%s)\n", p_slot->name);
                 event_type = INT_PRESENCE_OFF;
         }
 
@@ -135,23 +138,25 @@ u8 pciehp_handle_presence_change(struct slot *p_slot)
 u8 pciehp_handle_power_fault(struct slot *p_slot)
 {
         u32 event_type;
+        struct controller *ctrl = p_slot->ctrl;
 
         /* power fault */
-        dbg("pciehp:  Power fault interrupt received.\n");
+        ctrl_dbg(ctrl, "Power fault interrupt received.\n");
 
         if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {
                 /*
                  * power fault Cleared
                  */
-                info("Power fault cleared on Slot(%s)\n", p_slot->name);
+                ctrl_info(ctrl, "Power fault cleared on Slot(%s)\n",
+                          p_slot->name);
                 event_type = INT_POWER_FAULT_CLEAR;
         } else {
                 /*
                  *   power fault
                  */
-                info("Power fault on Slot(%s)\n", p_slot->name);
+                ctrl_info(ctrl, "Power fault on Slot(%s)\n", p_slot->name);
                 event_type = INT_POWER_FAULT;
-                info("power fault bit %x set\n", 0);
+                ctrl_info(ctrl, "power fault bit %x set\n", 0);
         }
 
         queue_interrupt_event(p_slot, event_type);
@@ -168,8 +173,9 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
         /* turn off slot, turn on Amber LED, turn off Green LED if supported*/
         if (POWER_CTRL(ctrl)) {
                 if (pslot->hpc_ops->power_off_slot(pslot)) {
-                        err("%s: Issue of Slot Power Off command failed\n",
-                            __func__);
+                        ctrl_err(ctrl,
+                                 "%s: Issue of Slot Power Off command failed\n",
+                                 __func__);
                         return;
                 }
         }
@@ -186,8 +192,8 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
 
         if (ATTN_LED(ctrl)) {
                 if (pslot->hpc_ops->set_attention_status(pslot, 1)) {
-                        err("%s: Issue of Set Attention Led command failed\n",
-                            __func__);
+                        ctrl_err(ctrl, "%s: Issue of Set Attention "
+                                 "Led command failed\n", __func__);
                         return;
                 }
         }
@@ -205,9 +211,9 @@ static int board_added(struct slot *p_slot)
         int retval = 0;
         struct controller *ctrl = p_slot->ctrl;
 
-        dbg("%s: slot device, slot offset, hp slot = %d, %d ,%d\n",
-                        __func__, p_slot->device,
-                        ctrl->slot_device_offset, p_slot->hp_slot);
+        ctrl_dbg(ctrl, "%s: slot device, slot offset, hp slot = %d, %d ,%d\n",
+                 __func__, p_slot->device, ctrl->slot_device_offset,
+                 p_slot->hp_slot);
 
         if (POWER_CTRL(ctrl)) {
                 /* Power on slot */
@@ -225,22 +231,22 @@ static int board_added(struct slot *p_slot)
         /* Check link training status */
         retval = p_slot->hpc_ops->check_lnk_status(ctrl);
         if (retval) {
-                err("%s: Failed to check link status\n", __func__);
+                ctrl_err(ctrl, "%s: Failed to check link status\n", __func__);
                 set_slot_off(ctrl, p_slot);
                 return retval;
         }
 
         /* Check for a power fault */
         if (p_slot->hpc_ops->query_power_fault(p_slot)) {
-                dbg("%s: power fault detected\n", __func__);
+                ctrl_dbg(ctrl, "%s: power fault detected\n", __func__);
                 retval = POWER_FAILURE;
                 goto err_exit;
         }
 
         retval = pciehp_configure_device(p_slot);
         if (retval) {
-                err("Cannot add device 0x%x:%x\n", p_slot->bus,
-                    p_slot->device);
+                ctrl_err(ctrl, "Cannot add device 0x%x:%x\n",
+                         p_slot->bus, p_slot->device);
                 goto err_exit;
         }
 
@@ -272,14 +278,14 @@ static int remove_board(struct slot *p_slot)
         if (retval)
                 return retval;
 
-        dbg("In %s, hp_slot = %d\n", __func__, p_slot->hp_slot);
+        ctrl_dbg(ctrl, "In %s, hp_slot = %d\n", __func__, p_slot->hp_slot);
 
         if (POWER_CTRL(ctrl)) {
                 /* power off slot */
                 retval = p_slot->hpc_ops->power_off_slot(p_slot);
                 if (retval) {
-                        err("%s: Issue of Slot Disable command failed\n",
-                            __func__);
+                        ctrl_err(ctrl, "%s: Issue of Slot Disable command "
+                                 "failed\n", __func__);
                         return retval;
                 }
         }
@@ -320,8 +326,8 @@ static void pciehp_power_thread(struct work_struct *work)
         switch (p_slot->state) {
         case POWEROFF_STATE:
                 mutex_unlock(&p_slot->lock);
-                dbg("%s: disabling bus:device(%x:%x)\n",
-                    __func__, p_slot->bus, p_slot->device);
+                ctrl_dbg(p_slot->ctrl, "%s: disabling bus:device(%x:%x)\n",
+                         __func__, p_slot->bus, p_slot->device);
                 pciehp_disable_slot(p_slot);
                 mutex_lock(&p_slot->lock);
                 p_slot->state = STATIC_STATE;
@@ -349,7 +355,8 @@ void pciehp_queue_pushbutton_work(struct work_struct *work)
 
         info = kmalloc(sizeof(*info), GFP_KERNEL);
         if (!info) {
-                err("%s: Cannot allocate memory\n", __func__);
+                ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
+                         __func__);
                 return;
         }
         info->p_slot = p_slot;
@@ -403,12 +410,14 @@ static void handle_button_press_event(struct slot *p_slot)
                 p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
                 if (getstatus) {
                         p_slot->state = BLINKINGOFF_STATE;
-                        info("PCI slot #%s - powering off due to button "
-                             "press.\n", p_slot->name);
+                        ctrl_info(ctrl,
+                                  "PCI slot #%s - powering off due to button "
+                                  "press.\n", p_slot->name);
                 } else {
                         p_slot->state = BLINKINGON_STATE;
-                        info("PCI slot #%s - powering on due to button "
-                             "press.\n", p_slot->name);
+                        ctrl_info(ctrl,
+                                  "PCI slot #%s - powering on due to button "
+                                  "press.\n", p_slot->name);
                 }
                 /* blink green LED and turn off amber */
                 if (PWR_LED(ctrl))
@@ -425,8 +434,8 @@ static void handle_button_press_event(struct slot *p_slot)
                  * press the attention again before the 5 sec. limit
                  * expires to cancel hot-add or hot-remove
                  */
-                info("Button cancel on Slot(%s)\n", p_slot->name);
-                dbg("%s: button cancel\n", __func__);
+                ctrl_info(ctrl, "Button cancel on Slot(%s)\n", p_slot->name);
+                ctrl_dbg(ctrl, "%s: button cancel\n", __func__);
                 cancel_delayed_work(&p_slot->work);
                 if (p_slot->state == BLINKINGOFF_STATE) {
                         if (PWR_LED(ctrl))
@@ -437,8 +446,8 @@ static void handle_button_press_event(struct slot *p_slot)
                 }
                 if (ATTN_LED(ctrl))
                         p_slot->hpc_ops->set_attention_status(p_slot, 0);
-                info("PCI slot #%s - action canceled due to button press\n",
-                     p_slot->name);
+                ctrl_info(ctrl, "PCI slot #%s - action canceled "
+                          "due to button press\n", p_slot->name);
                 p_slot->state = STATIC_STATE;
                 break;
         case POWEROFF_STATE:
@@ -448,11 +457,11 @@ static void handle_button_press_event(struct slot *p_slot)
                  * this means that the previous attention button action
                  * to hot-add or hot-remove is undergoing
                  */
-                info("Button ignore on Slot(%s)\n", p_slot->name);
+                ctrl_info(ctrl, "Button ignore on Slot(%s)\n", p_slot->name);
                 update_slot_info(p_slot);
                 break;
         default:
-                warn("Not a valid state\n");
+                ctrl_warn(ctrl, "Not a valid state\n");
                 break;
         }
 }
@@ -467,7 +476,8 @@ static void handle_surprise_event(struct slot *p_slot)
 
         info = kmalloc(sizeof(*info), GFP_KERNEL);
         if (!info) {
-                err("%s: Cannot allocate memory\n", __func__);
+                ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
+                         __func__);
                 return;
         }
         info->p_slot = p_slot;
@@ -505,7 +515,7 @@ static void interrupt_event_handler(struct work_struct *work)
         case INT_PRESENCE_OFF:
                 if (!HP_SUPR_RM(ctrl))
                         break;
-                dbg("Surprise Removal\n");
+                ctrl_dbg(ctrl, "Surprise Removal\n");
                 update_slot_info(p_slot);
                 handle_surprise_event(p_slot);
                 break;
@@ -522,22 +532,23 @@ int pciehp_enable_slot(struct slot *p_slot)
 {
         u8 getstatus = 0;
         int rc;
+        struct controller *ctrl = p_slot->ctrl;
 
         /* Check to see if (latch closed, card present, power off) */
         mutex_lock(&p_slot->ctrl->crit_sect);
 
         rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
         if (rc || !getstatus) {
-                info("%s: no adapter on slot(%s)\n", __func__,
-                     p_slot->name);
+                ctrl_info(ctrl, "%s: no adapter on slot(%s)\n",
+                          __func__, p_slot->name);
                 mutex_unlock(&p_slot->ctrl->crit_sect);
                 return -ENODEV;
         }
         if (MRL_SENS(p_slot->ctrl)) {
                 rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
                 if (rc || getstatus) {
-                        info("%s: latch open on slot(%s)\n", __func__,
-                             p_slot->name);
+                        ctrl_info(ctrl, "%s: latch open on slot(%s)\n",
+                                  __func__, p_slot->name);
                         mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -ENODEV;
                 }
@@ -546,8 +557,8 @@ int pciehp_enable_slot(struct slot *p_slot)
         if (POWER_CTRL(p_slot->ctrl)) {
                 rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
                 if (rc || getstatus) {
-                        info("%s: already enabled on slot(%s)\n", __func__,
-                             p_slot->name);
+                        ctrl_info(ctrl, "%s: already enabled on slot(%s)\n",
+                                  __func__, p_slot->name);
                         mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -EINVAL;
                 }
@@ -571,6 +582,7 @@ int pciehp_disable_slot(struct slot *p_slot)
 {
         u8 getstatus = 0;
         int ret = 0;
+        struct controller *ctrl = p_slot->ctrl;
 
         if (!p_slot->ctrl)
                 return 1;
@@ -581,8 +593,8 @@ int pciehp_disable_slot(struct slot *p_slot)
         if (!HP_SUPR_RM(p_slot->ctrl)) {
                 ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
-                        info("%s: no adapter on slot(%s)\n", __func__,
-                             p_slot->name);
+                        ctrl_info(ctrl, "%s: no adapter on slot(%s)\n",
+                                  __func__, p_slot->name);
                         mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -ENODEV;
                 }
@@ -591,8 +603,8 @@ int pciehp_disable_slot(struct slot *p_slot)
         if (MRL_SENS(p_slot->ctrl)) {
                 ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
                 if (ret || getstatus) {
-                        info("%s: latch open on slot(%s)\n", __func__,
-                             p_slot->name);
+                        ctrl_info(ctrl, "%s: latch open on slot(%s)\n",
+                                  __func__, p_slot->name);
                         mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -ENODEV;
                 }
@@ -601,8 +613,8 @@ int pciehp_disable_slot(struct slot *p_slot)
         if (POWER_CTRL(p_slot->ctrl)) {
                 ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
-                        info("%s: already disabled slot(%s)\n", __func__,
-                             p_slot->name);
+                        ctrl_info(ctrl, "%s: already disabled slot(%s)\n",
+                                  __func__, p_slot->name);
                         mutex_unlock(&p_slot->ctrl->crit_sect);
                         return -EINVAL;
                 }
@@ -618,6 +630,7 @@ int pciehp_disable_slot(struct slot *p_slot)
 int pciehp_sysfs_enable_slot(struct slot *p_slot)
 {
         int retval = -ENODEV;
+        struct controller *ctrl = p_slot->ctrl;
 
         mutex_lock(&p_slot->lock);
         switch (p_slot->state) {
@@ -631,15 +644,15 @@ int pciehp_sysfs_enable_slot(struct slot *p_slot)
                 p_slot->state = STATIC_STATE;
                 break;
         case POWERON_STATE:
-                info("Slot %s is already in powering on state\n",
-                     p_slot->name);
+                ctrl_info(ctrl, "Slot %s is already in powering on state\n",
+                          p_slot->name);
                 break;
         case BLINKINGOFF_STATE:
         case POWEROFF_STATE:
-                info("Already enabled on slot %s\n", p_slot->name);
+                ctrl_info(ctrl, "Already enabled on slot %s\n", p_slot->name);
                 break;
         default:
-                err("Not a valid state on slot %s\n", p_slot->name);
+                ctrl_err(ctrl, "Not a valid state on slot %s\n", p_slot->name);
                 break;
         }
         mutex_unlock(&p_slot->lock);
@@ -650,6 +663,7 @@ int pciehp_sysfs_enable_slot(struct slot *p_slot)
 int pciehp_sysfs_disable_slot(struct slot *p_slot)
 {
         int retval = -ENODEV;
+        struct controller *ctrl = p_slot->ctrl;
 
         mutex_lock(&p_slot->lock);
         switch (p_slot->state) {
@@ -663,15 +677,15 @@ int pciehp_sysfs_disable_slot(struct slot *p_slot)
                 p_slot->state = STATIC_STATE;
                 break;
         case POWEROFF_STATE:
-                info("Slot %s is already in powering off state\n",
-                     p_slot->name);
+                ctrl_info(ctrl, "Slot %s is already in powering off state\n",
+                          p_slot->name);
                 break;
         case BLINKINGON_STATE:
         case POWERON_STATE:
-                info("Already disabled on slot %s\n", p_slot->name);
+                ctrl_info(ctrl, "Already disabled on slot %s\n", p_slot->name);
                 break;
         default:
-                err("Not a valid state on slot %s\n", p_slot->name);
+                ctrl_err(ctrl, "Not a valid state on slot %s\n", p_slot->name);
                 break;
         }
         mutex_unlock(&p_slot->lock);
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 9d934ddee956..8e9530c4c36d 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -223,7 +223,7 @@ static void start_int_poll_timer(struct controller *ctrl, int sec)
 
 static inline int pciehp_request_irq(struct controller *ctrl)
 {
-        int retval, irq = ctrl->pci_dev->irq;
+        int retval, irq = ctrl->pcie->irq;
 
         /* Install interrupt polling timer. Start with 10 sec delay */
         if (pciehp_poll_mode) {
@@ -235,7 +235,8 @@ static inline int pciehp_request_irq(struct controller *ctrl)
         /* Installs the interrupt handler */
         retval = request_irq(irq, pcie_isr, IRQF_SHARED, MY_NAME, ctrl);
         if (retval)
-                err("Cannot get irq %d for the hotplug controller\n", irq);
+                ctrl_err(ctrl, "Cannot get irq %d for the hotplug controller\n",
+                         irq);
         return retval;
 }
 
@@ -244,7 +245,7 @@ static inline void pciehp_free_irq(struct controller *ctrl)
         if (pciehp_poll_mode)
                 del_timer_sync(&ctrl->poll_timer);
         else
-                free_irq(ctrl->pci_dev->irq, ctrl);
+                free_irq(ctrl->pcie->irq, ctrl);
 }
 
 static int pcie_poll_cmd(struct controller *ctrl)
@@ -282,7 +283,7 @@ static void pcie_wait_cmd(struct controller *ctrl, int poll)
         else
                 rc = wait_event_timeout(ctrl->queue, !ctrl->cmd_busy, timeout);
         if (!rc)
-                dbg("Command not completed in 1000 msec\n");
+                ctrl_dbg(ctrl, "Command not completed in 1000 msec\n");
 }
 
 /**
@@ -301,7 +302,8 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
 
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
-                err("%s: Cannot read SLOTSTATUS register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
+                         __func__);
                 goto out;
         }
 
@@ -312,26 +314,28 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
                          * proceed forward to issue the next command according
                          * to spec. Just print out the error message.
                          */
-                        dbg("%s: CMD_COMPLETED not clear after 1 sec.\n",
-                            __func__);
+                        ctrl_dbg(ctrl,
+                                 "%s: CMD_COMPLETED not clear after 1 sec.\n",
+                                 __func__);
                 } else if (!NO_CMD_CMPL(ctrl)) {
                         /*
                          * This controller semms to notify of command completed
                          * event even though it supports none of power
                          * controller, attention led, power led and EMI.
                          */
-                        dbg("%s: Unexpected CMD_COMPLETED. Need to wait for "
-                            "command completed event.\n", __func__);
+                        ctrl_dbg(ctrl, "%s: Unexpected CMD_COMPLETED. Need to "
+                                 "wait for command completed event.\n",
+                                 __func__);
                         ctrl->no_cmd_complete = 0;
                 } else {
-                        dbg("%s: Unexpected CMD_COMPLETED. Maybe the "
-                            "controller is broken.\n", __func__);
+                        ctrl_dbg(ctrl, "%s: Unexpected CMD_COMPLETED. Maybe "
+                                 "the controller is broken.\n", __func__);
                 }
         }
 
         retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
         if (retval) {
-                err("%s: Cannot read SLOTCTRL register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
                 goto out;
         }
 
@@ -341,7 +345,8 @@ static int pcie_write_cmd(struct controller *ctrl, u16 cmd, u16 mask)
         smp_mb();
         retval = pciehp_writew(ctrl, SLOTCTRL, slot_ctrl);
         if (retval)
-                err("%s: Cannot write to SLOTCTRL register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot write to SLOTCTRL register\n",
+                         __func__);
 
         /*
          * Wait for command completion.
@@ -370,14 +375,15 @@ static int hpc_check_lnk_status(struct controller *ctrl)
 
         retval = pciehp_readw(ctrl, LNKSTATUS, &lnk_status);
         if (retval) {
-                err("%s: Cannot read LNKSTATUS register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read LNKSTATUS register\n",
+                         __func__);
                 return retval;
         }
 
-        dbg("%s: lnk_status = %x\n", __func__, lnk_status);
+        ctrl_dbg(ctrl, "%s: lnk_status = %x\n", __func__, lnk_status);
         if ( (lnk_status & LNK_TRN) || (lnk_status & LNK_TRN_ERR) ||
                 !(lnk_status & NEG_LINK_WD)) {
-                err("%s : Link Training Error occurs \n", __func__);
+                ctrl_err(ctrl, "%s : Link Training Error occurs \n", __func__);
                 retval = -1;
                 return retval;
         }
@@ -394,12 +400,12 @@ static int hpc_get_attention_status(struct slot *slot, u8 *status)
 
         retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
         if (retval) {
-                err("%s: Cannot read SLOTCTRL register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
                 return retval;
         }
 
-        dbg("%s: SLOTCTRL %x, value read %x\n",
-            __func__, ctrl->cap_base + SLOTCTRL, slot_ctrl);
+        ctrl_dbg(ctrl, "%s: SLOTCTRL %x, value read %x\n",
+                 __func__, ctrl->cap_base + SLOTCTRL, slot_ctrl);
 
         atten_led_state = (slot_ctrl & ATTN_LED_CTRL) >> 6;
 
@@ -433,11 +439,11 @@ static int hpc_get_power_status(struct slot *slot, u8 *status)
 
         retval = pciehp_readw(ctrl, SLOTCTRL, &slot_ctrl);
         if (retval) {
-                err("%s: Cannot read SLOTCTRL register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read SLOTCTRL register\n", __func__);
                 return retval;
         }
-        dbg("%s: SLOTCTRL %x value read %x\n",
-            __func__, ctrl->cap_base + SLOTCTRL, slot_ctrl);
+        ctrl_dbg(ctrl, "%s: SLOTCTRL %x value read %x\n",
+                 __func__, ctrl->cap_base + SLOTCTRL, slot_ctrl);
 
         pwr_state = (slot_ctrl & PWR_CTRL) >> 10;
 
@@ -464,7 +470,8 @@ static int hpc_get_latch_status(struct slot *slot, u8 *status)
 
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
-                err("%s: Cannot read SLOTSTATUS register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
+                         __func__);
                 return retval;
         }
 
@@ -482,7 +489,8 @@ static int hpc_get_adapter_status(struct slot *slot, u8 *status)
 
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
-                err("%s: Cannot read SLOTSTATUS register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
+                         __func__);
                 return retval;
         }
         card_state = (u8)((slot_status & PRSN_STATE) >> 6);
@@ -500,7 +508,7 @@ static int hpc_query_power_fault(struct slot *slot)
 
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
-                err("%s: Cannot check for power fault\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot check for power fault\n", __func__);
                 return retval;
         }
         pwr_fault = (u8)((slot_status & PWR_FAULT_DETECTED) >> 1);
@@ -516,7 +524,7 @@ static int hpc_get_emi_status(struct slot *slot, u8 *status)
 
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
-                err("%s : Cannot check EMI status\n", __func__);
+                ctrl_err(ctrl, "%s : Cannot check EMI status\n", __func__);
                 return retval;
         }
         *status = (slot_status & EMI_STATE) >> EMI_STATUS_BIT;
@@ -560,8 +568,8 @@ static int hpc_set_attention_status(struct slot *slot, u8 value)
                         return -1;
         }
         rc = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
-        dbg("%s: SLOTCTRL %x write cmd %x\n",
-            __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+        ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
+                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
 
         return rc;
 }
@@ -575,8 +583,8 @@ static void hpc_set_green_led_on(struct slot *slot)
         slot_cmd = 0x0100;
         cmd_mask = PWR_LED_CTRL;
         pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
-        dbg("%s: SLOTCTRL %x write cmd %x\n",
-            __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+        ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
+                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
 }
 
 static void hpc_set_green_led_off(struct slot *slot)
@@ -588,8 +596,8 @@ static void hpc_set_green_led_off(struct slot *slot)
         slot_cmd = 0x0300;
         cmd_mask = PWR_LED_CTRL;
         pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
-        dbg("%s: SLOTCTRL %x write cmd %x\n",
-            __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+        ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
+                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
 }
 
 static void hpc_set_green_led_blink(struct slot *slot)
@@ -601,8 +609,8 @@ static void hpc_set_green_led_blink(struct slot *slot)
         slot_cmd = 0x0200;
         cmd_mask = PWR_LED_CTRL;
         pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
-        dbg("%s: SLOTCTRL %x write cmd %x\n",
-            __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+        ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
+                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
 }
 
 static int hpc_power_on_slot(struct slot * slot)
@@ -613,20 +621,22 @@ static int hpc_power_on_slot(struct slot * slot)
         u16 slot_status;
         int retval = 0;
 
-        dbg("%s: slot->hp_slot %x\n", __func__, slot->hp_slot);
+        ctrl_dbg(ctrl, "%s: slot->hp_slot %x\n", __func__, slot->hp_slot);
 
         /* Clear sticky power-fault bit from previous power failures */
         retval = pciehp_readw(ctrl, SLOTSTATUS, &slot_status);
         if (retval) {
-                err("%s: Cannot read SLOTSTATUS register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS register\n",
+                         __func__);
                 return retval;
         }
         slot_status &= PWR_FAULT_DETECTED;
         if (slot_status) {
                 retval = pciehp_writew(ctrl, SLOTSTATUS, slot_status);
                 if (retval) {
-                        err("%s: Cannot write to SLOTSTATUS register\n",
-                            __func__);
+                        ctrl_err(ctrl,
+                                 "%s: Cannot write to SLOTSTATUS register\n",
+                                 __func__);
                         return retval;
                 }
         }
@@ -644,11 +654,12 @@ static int hpc_power_on_slot(struct slot * slot)
         retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
 
         if (retval) {
-                err("%s: Write %x command failed!\n", __func__, slot_cmd);
+                ctrl_err(ctrl, "%s: Write %x command failed!\n",
+                         __func__, slot_cmd);
                 return -1;
         }
-        dbg("%s: SLOTCTRL %x write cmd %x\n",
-            __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+        ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
+                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
 
         return retval;
 }
@@ -694,7 +705,7 @@ static int hpc_power_off_slot(struct slot * slot)
         int retval = 0;
         int changed;
 
-        dbg("%s: slot->hp_slot %x\n", __func__, slot->hp_slot);
+        ctrl_dbg(ctrl, "%s: slot->hp_slot %x\n", __func__, slot->hp_slot);
 
         /*
          * Set Bad DLLP Mask bit in Correctable Error Mask
@@ -722,12 +733,12 @@ static int hpc_power_off_slot(struct slot * slot)
 
         retval = pcie_write_cmd(ctrl, slot_cmd, cmd_mask);
         if (retval) {
-                err("%s: Write command failed!\n", __func__);
+                ctrl_err(ctrl, "%s: Write command failed!\n", __func__);
                 retval = -1;
                 goto out;
         }
-        dbg("%s: SLOTCTRL %x write cmd %x\n",
-            __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
+        ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n",
+                 __func__, ctrl->cap_base + SLOTCTRL, slot_cmd);
  out:
         if (changed)
                 pcie_unmask_bad_dllp(ctrl);
@@ -749,7 +760,8 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
         intr_loc = 0;
         do {
                 if (pciehp_readw(ctrl, SLOTSTATUS, &detected)) {
-                        err("%s: Cannot read SLOTSTATUS\n", __func__);
+                        ctrl_err(ctrl, "%s: Cannot read SLOTSTATUS\n",
+                                 __func__);
                         return IRQ_NONE;
                 }
 
@@ -760,12 +772,13 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
                 if (!intr_loc)
                         return IRQ_NONE;
                 if (detected && pciehp_writew(ctrl, SLOTSTATUS, detected)) {
-                        err("%s: Cannot write to SLOTSTATUS\n", __func__);
+                        ctrl_err(ctrl, "%s: Cannot write to SLOTSTATUS\n",
+                                 __func__);
                         return IRQ_NONE;
                 }
         } while (detected);
 
-        dbg("%s: intr_loc %x\n", __FUNCTION__, intr_loc);
+        ctrl_dbg(ctrl, "%s: intr_loc %x\n", __func__, intr_loc);
 
         /* Check Command Complete Interrupt Pending */
         if (intr_loc & CMD_COMPLETED) {
@@ -807,7 +820,7 @@ static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
 
         retval = pciehp_readl(ctrl, LNKCAP, &lnk_cap);
         if (retval) {
-                err("%s: Cannot read LNKCAP register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read LNKCAP register\n", __func__);
                 return retval;
         }
 
@@ -821,7 +834,7 @@ static int hpc_get_max_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
         }
 
         *value = lnk_speed;
-        dbg("Max link speed = %d\n", lnk_speed);
+        ctrl_dbg(ctrl, "Max link speed = %d\n", lnk_speed);
 
         return retval;
 }
@@ -836,7 +849,7 @@ static int hpc_get_max_lnk_width(struct slot *slot,
 
         retval = pciehp_readl(ctrl, LNKCAP, &lnk_cap);
         if (retval) {
-                err("%s: Cannot read LNKCAP register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read LNKCAP register\n", __func__);
                 return retval;
         }
 
@@ -871,7 +884,7 @@ static int hpc_get_max_lnk_width(struct slot *slot,
         }
 
         *value = lnk_wdth;
-        dbg("Max link width = %d\n", lnk_wdth);
+        ctrl_dbg(ctrl, "Max link width = %d\n", lnk_wdth);
 
         return retval;
 }
@@ -885,7 +898,8 @@ static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
 
         retval = pciehp_readw(ctrl, LNKSTATUS, &lnk_status);
         if (retval) {
-                err("%s: Cannot read LNKSTATUS register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read LNKSTATUS register\n",
+                         __func__);
                 return retval;
         }
 
@@ -899,7 +913,7 @@ static int hpc_get_cur_lnk_speed(struct slot *slot, enum pci_bus_speed *value)
         }
 
         *value = lnk_speed;
-        dbg("Current link speed = %d\n", lnk_speed);
+        ctrl_dbg(ctrl, "Current link speed = %d\n", lnk_speed);
 
         return retval;
 }
@@ -914,7 +928,8 @@ static int hpc_get_cur_lnk_width(struct slot *slot,
 
         retval = pciehp_readw(ctrl, LNKSTATUS, &lnk_status);
         if (retval) {
-                err("%s: Cannot read LNKSTATUS register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read LNKSTATUS register\n",
+                         __func__);
                 return retval;
         }
 
@@ -949,7 +964,7 @@ static int hpc_get_cur_lnk_width(struct slot *slot,
         }
 
         *value = lnk_wdth;
-        dbg("Current link width = %d\n", lnk_wdth);
+        ctrl_dbg(ctrl, "Current link width = %d\n", lnk_wdth);
 
         return retval;
 }
@@ -998,7 +1013,8 @@ int pcie_enable_notification(struct controller *ctrl)
                PWR_FAULT_DETECT_ENABLE | HP_INTR_ENABLE | CMD_CMPL_INTR_ENABLE;
 
         if (pcie_write_cmd(ctrl, cmd, mask)) {
-                err("%s: Cannot enable software notification\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot enable software notification\n",
+                         __func__);
                 return -1;
         }
         return 0;
@@ -1010,7 +1026,8 @@ static void pcie_disable_notification(struct controller *ctrl)
         mask = PRSN_DETECT_ENABLE | ATTN_BUTTN_ENABLE | MRL_DETECT_ENABLE |
                PWR_FAULT_DETECT_ENABLE | HP_INTR_ENABLE | CMD_CMPL_INTR_ENABLE;
         if (pcie_write_cmd(ctrl, 0, mask))
-                warn("%s: Cannot disable software notification\n", __func__);
+                ctrl_warn(ctrl, "%s: Cannot disable software notification\n",
+                          __func__);
 }
 
 static int pcie_init_notification(struct controller *ctrl)
@@ -1071,34 +1088,45 @@ static inline void dbg_ctrl(struct controller *ctrl)
         if (!pciehp_debug)
                 return;
 
-        dbg("Hotplug Controller:\n");
-        dbg("  Seg/Bus/Dev/Func/IRQ : %s IRQ %d\n", pci_name(pdev), pdev->irq);
-        dbg("  Vendor ID            : 0x%04x\n", pdev->vendor);
-        dbg("  Device ID            : 0x%04x\n", pdev->device);
-        dbg("  Subsystem ID         : 0x%04x\n", pdev->subsystem_device);
-        dbg("  Subsystem Vendor ID  : 0x%04x\n", pdev->subsystem_vendor);
-        dbg("  PCIe Cap offset      : 0x%02x\n", ctrl->cap_base);
+        ctrl_info(ctrl, "Hotplug Controller:\n");
+        ctrl_info(ctrl, "  Seg/Bus/Dev/Func/IRQ : %s IRQ %d\n",
+                  pci_name(pdev), pdev->irq);
+        ctrl_info(ctrl, "  Vendor ID            : 0x%04x\n", pdev->vendor);
+        ctrl_info(ctrl, "  Device ID            : 0x%04x\n", pdev->device);
+        ctrl_info(ctrl, "  Subsystem ID         : 0x%04x\n",
+                  pdev->subsystem_device);
+        ctrl_info(ctrl, "  Subsystem Vendor ID  : 0x%04x\n",
+                  pdev->subsystem_vendor);
+        ctrl_info(ctrl, "  PCIe Cap offset      : 0x%02x\n", ctrl->cap_base);
         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
                 if (!pci_resource_len(pdev, i))
                         continue;
-                dbg("  PCI resource [%d]     : 0x%llx@0x%llx\n", i,
-                    (unsigned long long)pci_resource_len(pdev, i),
-                    (unsigned long long)pci_resource_start(pdev, i));
+                ctrl_info(ctrl, "  PCI resource [%d]     : 0x%llx@0x%llx\n",
+                          i, (unsigned long long)pci_resource_len(pdev, i),
+                          (unsigned long long)pci_resource_start(pdev, i));
         }
-        dbg("Slot Capabilities      : 0x%08x\n", ctrl->slot_cap);
-        dbg("  Physical Slot Number : %d\n", ctrl->first_slot);
-        dbg("  Attention Button     : %3s\n", ATTN_BUTTN(ctrl) ? "yes" : "no");
-        dbg("  Power Controller     : %3s\n", POWER_CTRL(ctrl) ? "yes" : "no");
-        dbg("  MRL Sensor           : %3s\n", MRL_SENS(ctrl)   ? "yes" : "no");
-        dbg("  Attention Indicator  : %3s\n", ATTN_LED(ctrl)   ? "yes" : "no");
-        dbg("  Power Indicator      : %3s\n", PWR_LED(ctrl)    ? "yes" : "no");
-        dbg("  Hot-Plug Surprise    : %3s\n", HP_SUPR_RM(ctrl) ? "yes" : "no");
-        dbg("  EMI Present          : %3s\n", EMI(ctrl)        ? "yes" : "no");
-        dbg("  Command Completed    : %3s\n", NO_CMD_CMPL(ctrl)? "no" : "yes");
+        ctrl_info(ctrl, "Slot Capabilities      : 0x%08x\n", ctrl->slot_cap);
+        ctrl_info(ctrl, "  Physical Slot Number : %d\n", ctrl->first_slot);
+        ctrl_info(ctrl, "  Attention Button     : %3s\n",
+                  ATTN_BUTTN(ctrl) ? "yes" : "no");
+        ctrl_info(ctrl, "  Power Controller     : %3s\n",
+                  POWER_CTRL(ctrl) ? "yes" : "no");
+        ctrl_info(ctrl, "  MRL Sensor           : %3s\n",
+                  MRL_SENS(ctrl)   ? "yes" : "no");
+        ctrl_info(ctrl, "  Attention Indicator  : %3s\n",
+                  ATTN_LED(ctrl)   ? "yes" : "no");
+        ctrl_info(ctrl, "  Power Indicator      : %3s\n",
+                  PWR_LED(ctrl)    ? "yes" : "no");
+        ctrl_info(ctrl, "  Hot-Plug Surprise    : %3s\n",
+                  HP_SUPR_RM(ctrl) ? "yes" : "no");
+        ctrl_info(ctrl, "  EMI Present          : %3s\n",
+                  EMI(ctrl)        ? "yes" : "no");
+        ctrl_info(ctrl, "  Command Completed    : %3s\n",
+                  NO_CMD_CMPL(ctrl) ? "no" : "yes");
         pciehp_readw(ctrl, SLOTSTATUS, &reg16);
-        dbg("Slot Status            : 0x%04x\n", reg16);
+        ctrl_info(ctrl, "Slot Status            : 0x%04x\n", reg16);
         pciehp_readw(ctrl, SLOTCTRL, &reg16);
-        dbg("Slot Control           : 0x%04x\n", reg16);
+        ctrl_info(ctrl, "Slot Control           : 0x%04x\n", reg16);
 }
 
 struct controller *pcie_init(struct pcie_device *dev)
@@ -1109,19 +1137,21 @@ struct controller *pcie_init(struct pcie_device *dev)
 
         ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
         if (!ctrl) {
-                err("%s : out of memory\n", __func__);
+                dev_err(&dev->device, "%s : out of memory\n", __func__);
                 goto abort;
         }
         INIT_LIST_HEAD(&ctrl->slot_list);
 
+        ctrl->pcie = dev;
         ctrl->pci_dev = pdev;
         ctrl->cap_base = pci_find_capability(pdev, PCI_CAP_ID_EXP);
         if (!ctrl->cap_base) {
-                err("%s: Cannot find PCI Express capability\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot find PCI Express capability\n",
+                         __func__);
                 goto abort;
         }
         if (pciehp_readl(ctrl, SLOTCAP, &slot_cap)) {
-                err("%s: Cannot read SLOTCAP register\n", __func__);
+                ctrl_err(ctrl, "%s: Cannot read SLOTCAP register\n", __func__);
                 goto abort;
         }
 
@@ -1161,9 +1191,9 @@ struct controller *pcie_init(struct pcie_device *dev)
                         goto abort_ctrl;
         }
 
-        info("HPC vendor_id %x device_id %x ss_vid %x ss_did %x\n",
-             pdev->vendor, pdev->device,
-             pdev->subsystem_vendor, pdev->subsystem_device);
+        ctrl_info(ctrl, "HPC vendor_id %x device_id %x ss_vid %x ss_did %x\n",
+                  pdev->vendor, pdev->device, pdev->subsystem_vendor,
+                  pdev->subsystem_device);
 
         if (pcie_init_slot(ctrl))
                 goto abort_ctrl;
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index 6040dcceb256..ffd11148fbe2 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -198,18 +198,20 @@ int pciehp_configure_device(struct slot *p_slot)
         struct pci_dev *dev;
         struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
         int num, fn;
+        struct controller *ctrl = p_slot->ctrl;
 
         dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, 0));
         if (dev) {
-                err("Device %s already exists at %x:%x, cannot hot-add\n",
-                                pci_name(dev), p_slot->bus, p_slot->device);
+                ctrl_err(ctrl,
+                         "Device %s already exists at %x:%x, cannot hot-add\n",
+                         pci_name(dev), p_slot->bus, p_slot->device);
                 pci_dev_put(dev);
                 return -EINVAL;
         }
 
         num = pci_scan_slot(parent, PCI_DEVFN(p_slot->device, 0));
         if (num == 0) {
-                err("No new device found\n");
+                ctrl_err(ctrl, "No new device found\n");
                 return -ENODEV;
         }
 
@@ -218,8 +220,8 @@ int pciehp_configure_device(struct slot *p_slot)
                 if (!dev)
                         continue;
                 if ((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
-                        err("Cannot hot-add display device %s\n",
-                                        pci_name(dev));
+                        ctrl_err(ctrl, "Cannot hot-add display device %s\n",
+                                 pci_name(dev));
                         pci_dev_put(dev);
                         continue;
                 }
@@ -244,9 +246,10 @@ int pciehp_unconfigure_device(struct slot *p_slot)
         u8 presence = 0;
         struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
         u16 command;
+        struct controller *ctrl = p_slot->ctrl;
 
-        dbg("%s: bus/dev = %x/%x\n", __func__, p_slot->bus,
-                                p_slot->device);
+        ctrl_dbg(ctrl, "%s: bus/dev = %x/%x\n", __func__,
+                 p_slot->bus, p_slot->device);
         ret = p_slot->hpc_ops->get_adapter_status(p_slot, &presence);
         if (ret)
                 presence = 0;
@@ -257,16 +260,17 @@ int pciehp_unconfigure_device(struct slot *p_slot)
                 if (!temp)
                         continue;
                 if ((temp->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
-                        err("Cannot remove display device %s\n",
-                                        pci_name(temp));
+                        ctrl_err(ctrl, "Cannot remove display device %s\n",
+                                 pci_name(temp));
                         pci_dev_put(temp);
                         continue;
                 }
                 if (temp->hdr_type == PCI_HEADER_TYPE_BRIDGE && presence) {
                         pci_read_config_byte(temp, PCI_BRIDGE_CONTROL, &bctl);
                         if (bctl & PCI_BRIDGE_CTL_VGA) {
-                                err("Cannot remove display device %s\n",
-                                    pci_name(temp));
+                                ctrl_err(ctrl,
+                                         "Cannot remove display device %s\n",
+                                         pci_name(temp));
                                 pci_dev_put(temp);
                                 continue;
                         }
diff --git a/drivers/pci/hotplug/rpaphp.h b/drivers/pci/hotplug/rpaphp.h
index 7d5921b1ee78..419919a87b0f 100644
--- a/drivers/pci/hotplug/rpaphp.h
+++ b/drivers/pci/hotplug/rpaphp.h
@@ -46,10 +46,10 @@
 #define PRESENT         1       /* Card in slot */
 
 #define MY_NAME "rpaphp"
-extern int debug;
+extern int rpaphp_debug;
 #define dbg(format, arg...)                                     \
         do {                                                    \
-                if (debug)                                      \
+                if (rpaphp_debug)                                       \
                         printk(KERN_DEBUG "%s: " format,        \
                                 MY_NAME , ## arg);              \
         } while (0)
diff --git a/drivers/pci/hotplug/rpaphp_core.c b/drivers/pci/hotplug/rpaphp_core.c
index 1f84f402acdb..95d02a08fdc7 100644
--- a/drivers/pci/hotplug/rpaphp_core.c
+++ b/drivers/pci/hotplug/rpaphp_core.c
@@ -37,7 +37,7 @@
                                 /* and pci_do_scan_bus */
 #include "rpaphp.h"
 
-int debug;
+int rpaphp_debug;
 LIST_HEAD(rpaphp_slot_head);
 
 #define DRIVER_VERSION  "0.1"
@@ -50,7 +50,7 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
-module_param(debug, bool, 0644);
+module_param_named(debug, rpaphp_debug, bool, 0644);
 
 /**
  * set_attention_status - set attention LED
diff --git a/drivers/pci/hotplug/rpaphp_pci.c b/drivers/pci/hotplug/rpaphp_pci.c
index 5acfd4f3d4cb..513e1e282391 100644
--- a/drivers/pci/hotplug/rpaphp_pci.c
+++ b/drivers/pci/hotplug/rpaphp_pci.c
@@ -123,7 +123,7 @@ int rpaphp_enable_slot(struct slot *slot)
                         slot->state = CONFIGURED;
                 }
 
-                if (debug) {
+                if (rpaphp_debug) {
                         struct pci_dev *dev;
                         dbg("%s: pci_devs of slot[%s]\n", __func__, slot->dn->full_name);
                         list_for_each_entry (dev, &bus->devices, bus_list)
diff --git a/drivers/pci/htirq.c b/drivers/pci/htirq.c
index 279c940a0039..bf7d6ce9bbb3 100644
--- a/drivers/pci/htirq.c
+++ b/drivers/pci/htirq.c
@@ -126,7 +126,8 @@ int __ht_create_irq(struct pci_dev *dev, int idx, ht_irq_update_t *update)
         cfg->msg.address_hi = 0xffffffff;
 
         irq = create_irq();
-        if (irq < 0) {
+
+        if (irq <= 0) {
                 kfree(cfg);
                 return -EBUSY;
         }
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index fc5f2dbf5323..8b51e10b7783 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -563,7 +563,7 @@ static int __iommu_flush_context(struct intel_iommu *iommu,
 
         spin_unlock_irqrestore(&iommu->register_lock, flag);
 
-        /* flush context entry will implictly flush write buffer */
+        /* flush context entry will implicitly flush write buffer */
         return 0;
 }
 
@@ -656,7 +656,7 @@ static int __iommu_flush_iotlb(struct intel_iommu *iommu, u16 did,
         if (DMA_TLB_IAIG(val) != DMA_TLB_IIRG(type))
                 pr_debug("IOMMU: tlb flush request %Lx, actual %Lx\n",
                         DMA_TLB_IIRG(type), DMA_TLB_IAIG(val));
-        /* flush context entry will implictly flush write buffer */
+        /* flush iotlb entry will implicitly flush write buffer */
         return 0;
 }
 
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index 738d4c89581c..2de5a3238c94 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -1,3 +1,4 @@
+#include <linux/interrupt.h>
 #include <linux/dmar.h>
 #include <linux/spinlock.h>
 #include <linux/jiffies.h>
@@ -11,41 +12,64 @@ static struct ioapic_scope ir_ioapic[MAX_IO_APICS];
 static int ir_ioapic_num;
 int intr_remapping_enabled;
 
-static struct {
+struct irq_2_iommu {
         struct intel_iommu *iommu;
         u16 irte_index;
         u16 sub_handle;
         u8  irte_mask;
-} irq_2_iommu[NR_IRQS];
+};
+
+static struct irq_2_iommu irq_2_iommuX[NR_IRQS];
+
+static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
+{
+        return (irq < nr_irqs) ? irq_2_iommuX + irq : NULL;
+}
+
+static struct irq_2_iommu *irq_2_iommu_alloc(unsigned int irq)
+{
+        return irq_2_iommu(irq);
+}
 
 static DEFINE_SPINLOCK(irq_2_ir_lock);
 
-int irq_remapped(int irq)
+static struct irq_2_iommu *valid_irq_2_iommu(unsigned int irq)
 {
-        if (irq > NR_IRQS)
-                return 0;
+        struct irq_2_iommu *irq_iommu;
+
+        irq_iommu = irq_2_iommu(irq);
+
+        if (!irq_iommu)
+                return NULL;
+
+        if (!irq_iommu->iommu)
+                return NULL;
 
-        if (!irq_2_iommu[irq].iommu)
-                return 0;
+        return irq_iommu;
+}
 
-        return 1;
+int irq_remapped(int irq)
+{
+        return valid_irq_2_iommu(irq) != NULL;
 }
 
 int get_irte(int irq, struct irte *entry)
 {
         int index;
+        struct irq_2_iommu *irq_iommu;
 
-        if (!entry || irq > NR_IRQS)
+        if (!entry)
                 return -1;
 
         spin_lock(&irq_2_ir_lock);
-        if (!irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        index = irq_2_iommu[irq].irte_index + irq_2_iommu[irq].sub_handle;
-        *entry = *(irq_2_iommu[irq].iommu->ir_table->base + index);
+        index = irq_iommu->irte_index + irq_iommu->sub_handle;
+        *entry = *(irq_iommu->iommu->ir_table->base + index);
 
         spin_unlock(&irq_2_ir_lock);
         return 0;
@@ -54,6 +78,7 @@ int get_irte(int irq, struct irte *entry)
 int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
 {
         struct ir_table *table = iommu->ir_table;
+        struct irq_2_iommu *irq_iommu;
         u16 index, start_index;
         unsigned int mask = 0;
         int i;
@@ -61,6 +86,10 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
         if (!count)
                 return -1;
 
+        /* protect irq_2_iommu_alloc later */
+        if (irq >= nr_irqs)
+                return -1;
+
         /*
          * start the IRTE search from index 0.
          */
@@ -100,10 +129,11 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
         for (i = index; i < index + count; i++)
                 table->base[i].present = 1;
 
-        irq_2_iommu[irq].iommu = iommu;
-        irq_2_iommu[irq].irte_index =  index;
-        irq_2_iommu[irq].sub_handle = 0;
-        irq_2_iommu[irq].irte_mask = mask;
+        irq_iommu = irq_2_iommu_alloc(irq);
+        irq_iommu->iommu = iommu;
+        irq_iommu->irte_index =  index;
+        irq_iommu->sub_handle = 0;
+        irq_iommu->irte_mask = mask;
 
         spin_unlock(&irq_2_ir_lock);
 
@@ -124,31 +154,33 @@ static void qi_flush_iec(struct intel_iommu *iommu, int index, int mask)
 int map_irq_to_irte_handle(int irq, u16 *sub_handle)
 {
         int index;
+        struct irq_2_iommu *irq_iommu;
 
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        *sub_handle = irq_2_iommu[irq].sub_handle;
-        index = irq_2_iommu[irq].irte_index;
+        *sub_handle = irq_iommu->sub_handle;
+        index = irq_iommu->irte_index;
         spin_unlock(&irq_2_ir_lock);
         return index;
 }
 
 int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle)
 {
+        struct irq_2_iommu *irq_iommu;
+
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || irq_2_iommu[irq].iommu) {
-                spin_unlock(&irq_2_ir_lock);
-                return -1;
-        }
 
-        irq_2_iommu[irq].iommu = iommu;
-        irq_2_iommu[irq].irte_index = index;
-        irq_2_iommu[irq].sub_handle = subhandle;
-        irq_2_iommu[irq].irte_mask = 0;
+        irq_iommu = irq_2_iommu_alloc(irq);
+
+        irq_iommu->iommu = iommu;
+        irq_iommu->irte_index = index;
+        irq_iommu->sub_handle = subhandle;
+        irq_iommu->irte_mask = 0;
 
         spin_unlock(&irq_2_ir_lock);
 
@@ -157,16 +189,19 @@ int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle)
 
 int clear_irte_irq(int irq, struct intel_iommu *iommu, u16 index)
 {
+        struct irq_2_iommu *irq_iommu;
+
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        irq_2_iommu[irq].iommu = NULL;
-        irq_2_iommu[irq].irte_index = 0;
-        irq_2_iommu[irq].sub_handle = 0;
-        irq_2_iommu[irq].irte_mask = 0;
+        irq_iommu->iommu = NULL;
+        irq_iommu->irte_index = 0;
+        irq_iommu->sub_handle = 0;
+        irq_2_iommu(irq)->irte_mask = 0;
 
         spin_unlock(&irq_2_ir_lock);
 
@@ -178,16 +213,18 @@ int modify_irte(int irq, struct irte *irte_modified)
         int index;
         struct irte *irte;
         struct intel_iommu *iommu;
+        struct irq_2_iommu *irq_iommu;
 
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        iommu = irq_2_iommu[irq].iommu;
+        iommu = irq_iommu->iommu;
 
-        index = irq_2_iommu[irq].irte_index + irq_2_iommu[irq].sub_handle;
+        index = irq_iommu->irte_index + irq_iommu->sub_handle;
         irte = &iommu->ir_table->base[index];
 
         set_64bit((unsigned long *)irte, irte_modified->low | (1 << 1));
@@ -203,18 +240,20 @@ int flush_irte(int irq)
 {
         int index;
         struct intel_iommu *iommu;
+        struct irq_2_iommu *irq_iommu;
 
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        iommu = irq_2_iommu[irq].iommu;
+        iommu = irq_iommu->iommu;
 
-        index = irq_2_iommu[irq].irte_index + irq_2_iommu[irq].sub_handle;
+        index = irq_iommu->irte_index + irq_iommu->sub_handle;
 
-        qi_flush_iec(iommu, index, irq_2_iommu[irq].irte_mask);
+        qi_flush_iec(iommu, index, irq_iommu->irte_mask);
         spin_unlock(&irq_2_ir_lock);
 
         return 0;
@@ -246,28 +285,30 @@ int free_irte(int irq)
         int index, i;
         struct irte *irte;
         struct intel_iommu *iommu;
+        struct irq_2_iommu *irq_iommu;
 
         spin_lock(&irq_2_ir_lock);
-        if (irq >= NR_IRQS || !irq_2_iommu[irq].iommu) {
+        irq_iommu = valid_irq_2_iommu(irq);
+        if (!irq_iommu) {
                 spin_unlock(&irq_2_ir_lock);
                 return -1;
         }
 
-        iommu = irq_2_iommu[irq].iommu;
+        iommu = irq_iommu->iommu;
 
-        index = irq_2_iommu[irq].irte_index + irq_2_iommu[irq].sub_handle;
+        index = irq_iommu->irte_index + irq_iommu->sub_handle;
         irte = &iommu->ir_table->base[index];
 
-        if (!irq_2_iommu[irq].sub_handle) {
-                for (i = 0; i < (1 << irq_2_iommu[irq].irte_mask); i++)
+        if (!irq_iommu->sub_handle) {
+                for (i = 0; i < (1 << irq_iommu->irte_mask); i++)
                         set_64bit((unsigned long *)irte, 0);
-                qi_flush_iec(iommu, index, irq_2_iommu[irq].irte_mask);
+                qi_flush_iec(iommu, index, irq_iommu->irte_mask);
         }
 
-        irq_2_iommu[irq].iommu = NULL;
-        irq_2_iommu[irq].irte_index = 0;
-        irq_2_iommu[irq].sub_handle = 0;
-        irq_2_iommu[irq].irte_mask = 0;
+        irq_iommu->iommu = NULL;
+        irq_iommu->irte_index = 0;
+        irq_iommu->sub_handle = 0;
+        irq_iommu->irte_mask = 0;
 
         spin_unlock(&irq_2_ir_lock);
 
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 4a10b5624f72..d2812013fd22 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -378,23 +378,21 @@ static int msi_capability_init(struct pci_dev *dev)
         entry->msi_attrib.masked = 1;
         entry->msi_attrib.default_irq = dev->irq;       /* Save IOAPIC IRQ */
         entry->msi_attrib.pos = pos;
-        if (is_mask_bit_support(control)) {
+        if (entry->msi_attrib.maskbit) {
                 entry->mask_base = (void __iomem *)(long)msi_mask_bits_reg(pos,
-                                is_64bit_address(control));
+                                entry->msi_attrib.is_64);
         }
         entry->dev = dev;
         if (entry->msi_attrib.maskbit) {
                 unsigned int maskbits, temp;
                 /* All MSIs are unmasked by default, Mask them all */
                 pci_read_config_dword(dev,
-                        msi_mask_bits_reg(pos, is_64bit_address(control)),
+                        msi_mask_bits_reg(pos, entry->msi_attrib.is_64),
                         &maskbits);
                 temp = (1 << multi_msi_capable(control));
                 temp = ((temp - 1) & ~temp);
                 maskbits |= temp;
-                pci_write_config_dword(dev,
-                        msi_mask_bits_reg(pos, is_64bit_address(control)),
-                        maskbits);
+                pci_write_config_dword(dev, entry->msi_attrib.is_64, maskbits);
                 entry->msi_attrib.maskbits_mask = temp;
         }
         list_add_tail(&entry->list, &dev->msi_list);
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index a13f53486114..b4cdd690ae71 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -43,18 +43,32 @@ store_new_id(struct device_driver *driver, const char *buf, size_t count)
 {
         struct pci_dynid *dynid;
         struct pci_driver *pdrv = to_pci_driver(driver);
+        const struct pci_device_id *ids = pdrv->id_table;
         __u32 vendor, device, subvendor=PCI_ANY_ID,
                 subdevice=PCI_ANY_ID, class=0, class_mask=0;
         unsigned long driver_data=0;
         int fields=0;
-        int retval = 0;
+        int retval;
 
-        fields = sscanf(buf, "%x %x %x %x %x %x %lux",
+        fields = sscanf(buf, "%x %x %x %x %x %x %lx",
                         &vendor, &device, &subvendor, &subdevice,
                         &class, &class_mask, &driver_data);
         if (fields < 2)
                 return -EINVAL;
 
+        /* Only accept driver_data values that match an existing id_table
+           entry */
+        retval = -EINVAL;
+        while (ids->vendor || ids->subvendor || ids->class_mask) {
+                if (driver_data == ids->driver_data) {
+                        retval = 0;
+                        break;
+                }
+                ids++;
+        }
+        if (retval)     /* No match */
+                return retval;
+
         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
         if (!dynid)
                 return -ENOMEM;
@@ -65,8 +79,7 @@ store_new_id(struct device_driver *driver, const char *buf, size_t count)
         dynid->id.subdevice = subdevice;
         dynid->id.class = class;
         dynid->id.class_mask = class_mask;
-        dynid->id.driver_data = pdrv->dynids.use_driver_data ?
-                driver_data : 0UL;
+        dynid->id.driver_data = driver_data;
 
         spin_lock(&pdrv->dynids.lock);
         list_add_tail(&dynid->node, &pdrv->dynids.list);
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 77baff022f71..110022d78689 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -423,7 +423,7 @@ pci_write_vpd(struct kobject *kobj, struct bin_attribute *bin_attr,
  * Reads 1, 2, or 4 bytes from legacy I/O port space using an arch specific
  * callback routine (pci_legacy_read).
  */
-ssize_t
+static ssize_t
 pci_read_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
                    char *buf, loff_t off, size_t count)
 {
@@ -448,7 +448,7 @@ pci_read_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
  * Writes 1, 2, or 4 bytes from legacy I/O port space using an arch specific
  * callback routine (pci_legacy_write).
  */
-ssize_t
+static ssize_t
 pci_write_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
                     char *buf, loff_t off, size_t count)
 {
@@ -468,11 +468,11 @@ pci_write_legacy_io(struct kobject *kobj, struct bin_attribute *bin_attr,
  * @attr: struct bin_attribute for this file
  * @vma: struct vm_area_struct passed to mmap
  *
- * Uses an arch specific callback, pci_mmap_legacy_page_range, to mmap
+ * Uses an arch specific callback, pci_mmap_legacy_mem_page_range, to mmap
  * legacy memory space (first meg of bus space) into application virtual
  * memory space.
  */
-int
+static int
 pci_mmap_legacy_mem(struct kobject *kobj, struct bin_attribute *attr,
                     struct vm_area_struct *vma)
 {
@@ -480,7 +480,90 @@ pci_mmap_legacy_mem(struct kobject *kobj, struct bin_attribute *attr,
                                                       struct device,
                                                       kobj));
 
-        return pci_mmap_legacy_page_range(bus, vma);
+        return pci_mmap_legacy_page_range(bus, vma, pci_mmap_mem);
+}
+
+/**
+ * pci_mmap_legacy_io - map legacy PCI IO into user memory space
+ * @kobj: kobject corresponding to device to be mapped
+ * @attr: struct bin_attribute for this file
+ * @vma: struct vm_area_struct passed to mmap
+ *
+ * Uses an arch specific callback, pci_mmap_legacy_io_page_range, to mmap
+ * legacy IO space (first meg of bus space) into application virtual
+ * memory space. Returns -ENOSYS if the operation isn't supported
+ */
+static int
+pci_mmap_legacy_io(struct kobject *kobj, struct bin_attribute *attr,
+                   struct vm_area_struct *vma)
+{
+        struct pci_bus *bus = to_pci_bus(container_of(kobj,
+                                                      struct device,
+                                                      kobj));
+
+        return pci_mmap_legacy_page_range(bus, vma, pci_mmap_io);
+}
+
+/**
+ * pci_create_legacy_files - create legacy I/O port and memory files
+ * @b: bus to create files under
+ *
+ * Some platforms allow access to legacy I/O port and ISA memory space on
+ * a per-bus basis.  This routine creates the files and ties them into
+ * their associated read, write and mmap files from pci-sysfs.c
+ *
+ * On error unwind, but don't propogate the error to the caller
+ * as it is ok to set up the PCI bus without these files.
+ */
+void pci_create_legacy_files(struct pci_bus *b)
+{
+        int error;
+
+        b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
+                               GFP_ATOMIC);
+        if (!b->legacy_io)
+                goto kzalloc_err;
+
+        b->legacy_io->attr.name = "legacy_io";
+        b->legacy_io->size = 0xffff;
+        b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
+        b->legacy_io->read = pci_read_legacy_io;
+        b->legacy_io->write = pci_write_legacy_io;
+        b->legacy_io->mmap = pci_mmap_legacy_io;
+        error = device_create_bin_file(&b->dev, b->legacy_io);
+        if (error)
+                goto legacy_io_err;
+
+        /* Allocated above after the legacy_io struct */
+        b->legacy_mem = b->legacy_io + 1;
+        b->legacy_mem->attr.name = "legacy_mem";
+        b->legacy_mem->size = 1024*1024;
+        b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
+        b->legacy_mem->mmap = pci_mmap_legacy_mem;
+        error = device_create_bin_file(&b->dev, b->legacy_mem);
+        if (error)
+                goto legacy_mem_err;
+
+        return;
+
+legacy_mem_err:
+        device_remove_bin_file(&b->dev, b->legacy_io);
+legacy_io_err:
+        kfree(b->legacy_io);
+        b->legacy_io = NULL;
+kzalloc_err:
+        printk(KERN_WARNING "pci: warning: could not create legacy I/O port "
+               "and ISA memory resources to sysfs\n");
+        return;
+}
+
+void pci_remove_legacy_files(struct pci_bus *b)
+{
+        if (b->legacy_io) {
+                device_remove_bin_file(&b->dev, b->legacy_io);
+                device_remove_bin_file(&b->dev, b->legacy_mem);
+                kfree(b->legacy_io); /* both are allocated here */
+        }
 }
 #endif /* HAVE_PCI_LEGACY */
 
@@ -715,7 +798,7 @@ static struct bin_attribute pci_config_attr = {
                 .name = "config",
                 .mode = S_IRUGO | S_IWUSR,
         },
-        .size = 256,
+        .size = PCI_CFG_SPACE_SIZE,
         .read = pci_read_config,
         .write = pci_write_config,
 };
@@ -725,7 +808,7 @@ static struct bin_attribute pcie_config_attr = {
                 .name = "config",
                 .mode = S_IRUGO | S_IWUSR,
         },
-        .size = 4096,
+        .size = PCI_CFG_SPACE_EXP_SIZE,
         .read = pci_read_config,
         .write = pci_write_config,
 };
@@ -735,86 +818,103 @@ int __attribute__ ((weak)) pcibios_add_platform_entries(struct pci_dev *dev)
         return 0;
 }
 
+static int pci_create_capabilities_sysfs(struct pci_dev *dev)
+{
+        int retval;
+        struct bin_attribute *attr;
+
+        /* If the device has VPD, try to expose it in sysfs. */
+        if (dev->vpd) {
+                attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
+                if (!attr)
+                        return -ENOMEM;
+
+                attr->size = dev->vpd->len;
+                attr->attr.name = "vpd";
+                attr->attr.mode = S_IRUSR | S_IWUSR;
+                attr->read = pci_read_vpd;
+                attr->write = pci_write_vpd;
+                retval = sysfs_create_bin_file(&dev->dev.kobj, attr);
+                if (retval) {
+                        kfree(dev->vpd->attr);
+                        return retval;
+                }
+                dev->vpd->attr = attr;
+        }
+
+        /* Active State Power Management */
+        pcie_aspm_create_sysfs_dev_files(dev);
+
+        return 0;
+}
+
 int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
 {
-        struct bin_attribute *attr = NULL;
         int retval;
+        int rom_size = 0;
+        struct bin_attribute *attr;
 
         if (!sysfs_initialized)
                 return -EACCES;
 
-        if (pdev->cfg_size < 4096)
+        if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
                 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pci_config_attr);
         else
                 retval = sysfs_create_bin_file(&pdev->dev.kobj, &pcie_config_attr);
         if (retval)
                 goto err;
 
-        /* If the device has VPD, try to expose it in sysfs. */
-        if (pdev->vpd) {
-                attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
-                if (attr) {
-                        pdev->vpd->attr = attr;
-                        attr->size = pdev->vpd->len;
-                        attr->attr.name = "vpd";
-                        attr->attr.mode = S_IRUSR | S_IWUSR;
-                        attr->read = pci_read_vpd;
-                        attr->write = pci_write_vpd;
-                        retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
-                        if (retval)
-                                goto err_vpd;
-                } else {
-                        retval = -ENOMEM;
-                        goto err_config_file;
-                }
-        }
-
         retval = pci_create_resource_files(pdev);
         if (retval)
-                goto err_vpd_file;
+                goto err_config_file;
+
+        if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
+                rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
+        else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
+                rom_size = 0x20000;
 
         /* If the device has a ROM, try to expose it in sysfs. */
-        if (pci_resource_len(pdev, PCI_ROM_RESOURCE) ||
-            (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)) {
+        if (rom_size) {
                 attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
-                if (attr) {
-                        pdev->rom_attr = attr;
-                        attr->size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
-                        attr->attr.name = "rom";
-                        attr->attr.mode = S_IRUSR;
-                        attr->read = pci_read_rom;
-                        attr->write = pci_write_rom;
-                        retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
-                        if (retval)
-                                goto err_rom;
-                } else {
+                if (!attr) {
                         retval = -ENOMEM;
                         goto err_resource_files;
                 }
+                attr->size = rom_size;
+                attr->attr.name = "rom";
+                attr->attr.mode = S_IRUSR;
+                attr->read = pci_read_rom;
+                attr->write = pci_write_rom;
+                retval = sysfs_create_bin_file(&pdev->dev.kobj, attr);
+                if (retval) {
+                        kfree(attr);
+                        goto err_resource_files;
+                }
+                pdev->rom_attr = attr;
         }
+
         /* add platform-specific attributes */
-        if (pcibios_add_platform_entries(pdev))
+        retval = pcibios_add_platform_entries(pdev);
+        if (retval)
                 goto err_rom_file;
 
-        pcie_aspm_create_sysfs_dev_files(pdev);
+        /* add sysfs entries for various capabilities */
+        retval = pci_create_capabilities_sysfs(pdev);
+        if (retval)
+                goto err_rom_file;
 
         return 0;
 
 err_rom_file:
-        if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
+        if (rom_size) {
                 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
-err_rom:
-        kfree(pdev->rom_attr);
+                kfree(pdev->rom_attr);
+                pdev->rom_attr = NULL;
+        }
 err_resource_files:
         pci_remove_resource_files(pdev);
-err_vpd_file:
-        if (pdev->vpd) {
-                sysfs_remove_bin_file(&pdev->dev.kobj, pdev->vpd->attr);
-err_vpd:
-                kfree(pdev->vpd->attr);
-        }
 err_config_file:
-        if (pdev->cfg_size < 4096)
+        if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
                 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
         else
                 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
@@ -822,6 +922,16 @@ err:
         return retval;
 }
 
+static void pci_remove_capabilities_sysfs(struct pci_dev *dev)
+{
+        if (dev->vpd && dev->vpd->attr) {
+                sysfs_remove_bin_file(&dev->dev.kobj, dev->vpd->attr);
+                kfree(dev->vpd->attr);
+        }
+
+        pcie_aspm_remove_sysfs_dev_files(dev);
+}
+
 /**
  * pci_remove_sysfs_dev_files - cleanup PCI specific sysfs files
  * @pdev: device whose entries we should free
@@ -830,27 +940,28 @@ err:
  */
 void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
 {
+        int rom_size = 0;
+
         if (!sysfs_initialized)
                 return;
 
-        pcie_aspm_remove_sysfs_dev_files(pdev);
+        pci_remove_capabilities_sysfs(pdev);
 
-        if (pdev->vpd) {
-                sysfs_remove_bin_file(&pdev->dev.kobj, pdev->vpd->attr);
-                kfree(pdev->vpd->attr);
-        }
-        if (pdev->cfg_size < 4096)
+        if (pdev->cfg_size < PCI_CFG_SPACE_EXP_SIZE)
                 sysfs_remove_bin_file(&pdev->dev.kobj, &pci_config_attr);
         else
                 sysfs_remove_bin_file(&pdev->dev.kobj, &pcie_config_attr);
 
         pci_remove_resource_files(pdev);
 
-        if (pci_resource_len(pdev, PCI_ROM_RESOURCE)) {
-                if (pdev->rom_attr) {
-                        sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
-                        kfree(pdev->rom_attr);
-                }
+        if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
+                rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
+        else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
+                rom_size = 0x20000;
+
+        if (rom_size && pdev->rom_attr) {
+                sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
+                kfree(pdev->rom_attr);
         }
 }
 
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index c9884bba22de..4db261e13e69 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -213,10 +213,13 @@ int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap)
 int pci_find_ext_capability(struct pci_dev *dev, int cap)
 {
         u32 header;
-        int ttl = 480; /* 3840 bytes, minimum 8 bytes per capability */
-        int pos = 0x100;
+        int ttl;
+        int pos = PCI_CFG_SPACE_SIZE;
 
-        if (dev->cfg_size <= 256)
+        /* minimum 8 bytes per capability */
+        ttl = (PCI_CFG_SPACE_EXP_SIZE - PCI_CFG_SPACE_SIZE) / 8;
+
+        if (dev->cfg_size <= PCI_CFG_SPACE_SIZE)
                 return 0;
 
         if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
@@ -234,7 +237,7 @@ int pci_find_ext_capability(struct pci_dev *dev, int cap)
                         return pos;
 
                 pos = PCI_EXT_CAP_NEXT(header);
-                if (pos < 0x100)
+                if (pos < PCI_CFG_SPACE_SIZE)
                         break;
 
                 if (pci_read_config_dword(dev, pos, &header) != PCIBIOS_SUCCESSFUL)
@@ -1127,6 +1130,27 @@ int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable)
 }
 
 /**
+ * pci_wake_from_d3 - enable/disable device to wake up from D3_hot or D3_cold
+ * @dev: PCI device to prepare
+ * @enable: True to enable wake-up event generation; false to disable
+ *
+ * Many drivers want the device to wake up the system from D3_hot or D3_cold
+ * and this function allows them to set that up cleanly - pci_enable_wake()
+ * should not be called twice in a row to enable wake-up due to PCI PM vs ACPI
+ * ordering constraints.
+ *
+ * This function only returns error code if the device is not capable of
+ * generating PME# from both D3_hot and D3_cold, and the platform is unable to
+ * enable wake-up power for it.
+ */
+int pci_wake_from_d3(struct pci_dev *dev, bool enable)
+{
+        return pci_pme_capable(dev, PCI_D3cold) ?
+                        pci_enable_wake(dev, PCI_D3cold, enable) :
+                        pci_enable_wake(dev, PCI_D3hot, enable);
+}
+
+/**
  * pci_target_state - find an appropriate low power state for a given PCI dev
  * @dev: PCI device
  *
@@ -1242,25 +1266,25 @@ void pci_pm_init(struct pci_dev *dev)
         dev->d1_support = false;
         dev->d2_support = false;
         if (!pci_no_d1d2(dev)) {
-                if (pmc & PCI_PM_CAP_D1) {
-                        dev_printk(KERN_DEBUG, &dev->dev, "supports D1\n");
+                if (pmc & PCI_PM_CAP_D1)
                         dev->d1_support = true;
-                }
-                if (pmc & PCI_PM_CAP_D2) {
-                        dev_printk(KERN_DEBUG, &dev->dev, "supports D2\n");
+                if (pmc & PCI_PM_CAP_D2)
                         dev->d2_support = true;
-                }
+
+                if (dev->d1_support || dev->d2_support)
+                        dev_printk(KERN_DEBUG, &dev->dev, "supports%s%s\n",
+                                   dev->d1_support ? " D1" : "",
+                                   dev->d2_support ? " D2" : "");
         }
 
         pmc &= PCI_PM_CAP_PME_MASK;
         if (pmc) {
-                dev_printk(KERN_INFO, &dev->dev,
-                        "PME# supported from%s%s%s%s%s\n",
-                        (pmc & PCI_PM_CAP_PME_D0) ? " D0" : "",
-                        (pmc & PCI_PM_CAP_PME_D1) ? " D1" : "",
-                        (pmc & PCI_PM_CAP_PME_D2) ? " D2" : "",
-                        (pmc & PCI_PM_CAP_PME_D3) ? " D3hot" : "",
-                        (pmc & PCI_PM_CAP_PME_D3cold) ? " D3cold" : "");
+                dev_info(&dev->dev, "PME# supported from%s%s%s%s%s\n",
+                         (pmc & PCI_PM_CAP_PME_D0) ? " D0" : "",
+                         (pmc & PCI_PM_CAP_PME_D1) ? " D1" : "",
+                         (pmc & PCI_PM_CAP_PME_D2) ? " D2" : "",
+                         (pmc & PCI_PM_CAP_PME_D3) ? " D3hot" : "",
+                         (pmc & PCI_PM_CAP_PME_D3cold) ? " D3cold" : "");
                 dev->pme_support = pmc >> PCI_PM_CAP_PME_SHIFT;
                 /*
                  * Make device's PM flags reflect the wake-up capability, but
@@ -1275,6 +1299,38 @@ void pci_pm_init(struct pci_dev *dev)
         }
 }
 
+/**
+ * pci_enable_ari - enable ARI forwarding if hardware support it
+ * @dev: the PCI device
+ */
+void pci_enable_ari(struct pci_dev *dev)
+{
+        int pos;
+        u32 cap;
+        u16 ctrl;
+
+        if (!dev->is_pcie)
+                return;
+
+        if (dev->pcie_type != PCI_EXP_TYPE_ROOT_PORT &&
+            dev->pcie_type != PCI_EXP_TYPE_DOWNSTREAM)
+                return;
+
+        pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
+        if (!pos)
+                return;
+
+        pci_read_config_dword(dev, pos + PCI_EXP_DEVCAP2, &cap);
+        if (!(cap & PCI_EXP_DEVCAP2_ARI))
+                return;
+
+        pci_read_config_word(dev, pos + PCI_EXP_DEVCTL2, &ctrl);
+        ctrl |= PCI_EXP_DEVCTL2_ARI;
+        pci_write_config_word(dev, pos + PCI_EXP_DEVCTL2, ctrl);
+
+        dev->ari_enabled = 1;
+}
+
 int
 pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge)
 {
@@ -1358,11 +1414,10 @@ int pci_request_region(struct pci_dev *pdev, int bar, const char *res_name)
         return 0;
 
 err_out:
-        dev_warn(&pdev->dev, "BAR %d: can't reserve %s region [%#llx-%#llx]\n",
+        dev_warn(&pdev->dev, "BAR %d: can't reserve %s region %pR\n",
                  bar,
                  pci_resource_flags(pdev, bar) & IORESOURCE_IO ? "I/O" : "mem",
-                 (unsigned long long)pci_resource_start(pdev, bar),
-                 (unsigned long long)pci_resource_end(pdev, bar));
+                 &pdev->resource[bar]);
         return -EBUSY;
 }
 
@@ -1943,6 +1998,7 @@ EXPORT_SYMBOL(pci_restore_state);
 EXPORT_SYMBOL(pci_pme_capable);
 EXPORT_SYMBOL(pci_pme_active);
 EXPORT_SYMBOL(pci_enable_wake);
+EXPORT_SYMBOL(pci_wake_from_d3);
 EXPORT_SYMBOL(pci_target_state);
 EXPORT_SYMBOL(pci_prepare_to_sleep);
 EXPORT_SYMBOL(pci_back_from_sleep);
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index d807cd786f20..b205ab866a1d 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -1,3 +1,9 @@
+#ifndef DRIVERS_PCI_H
+#define DRIVERS_PCI_H
+
+#define PCI_CFG_SPACE_SIZE      256
+#define PCI_CFG_SPACE_EXP_SIZE  4096
+
 /* Functions internal to the PCI core code */
 
 extern int pci_uevent(struct device *dev, struct kobj_uevent_env *env);
@@ -76,7 +82,13 @@ static inline int pci_proc_detach_bus(struct pci_bus *bus) { return 0; }
 /* Functions for PCI Hotplug drivers to use */
 extern unsigned int pci_do_scan_bus(struct pci_bus *bus);
 
+#ifdef HAVE_PCI_LEGACY
+extern void pci_create_legacy_files(struct pci_bus *bus);
 extern void pci_remove_legacy_files(struct pci_bus *bus);
+#else
+static inline void pci_create_legacy_files(struct pci_bus *bus) { return; }
+static inline void pci_remove_legacy_files(struct pci_bus *bus) { return; }
+#endif
 
 /* Lock for read/write access to pci device and bus lists */
 extern struct rw_semaphore pci_bus_sem;
@@ -109,6 +121,7 @@ static inline int pci_no_d1d2(struct pci_dev *dev)
 extern int pcie_mch_quirk;
 extern struct device_attribute pci_dev_attrs[];
 extern struct device_attribute dev_attr_cpuaffinity;
+extern struct device_attribute dev_attr_cpulistaffinity;
 
 /**
  * pci_match_one_device - Tell if a PCI device structure has a matching
@@ -144,3 +157,16 @@ struct pci_slot_attribute {
 };
 #define to_pci_slot_attr(s) container_of(s, struct pci_slot_attribute, attr)
 
+extern void pci_enable_ari(struct pci_dev *dev);
+/**
+ * pci_ari_enabled - query ARI forwarding status
+ * @dev: the PCI device
+ *
+ * Returns 1 if ARI forwarding is enabled, or 0 if not enabled;
+ */
+static inline int pci_ari_enabled(struct pci_dev *dev)
+{
+        return dev->ari_enabled;
+}
+
+#endif /* DRIVERS_PCI_H */
diff --git a/drivers/pci/pcie/aer/aerdrv.c b/drivers/pci/pcie/aer/aerdrv.c
index 77036f46acfe..e390707661dd 100644
--- a/drivers/pci/pcie/aer/aerdrv.c
+++ b/drivers/pci/pcie/aer/aerdrv.c
@@ -105,7 +105,7 @@ static irqreturn_t aer_irq(int irq, void *context)
         unsigned long flags;
         int pos;
 
-        pos = pci_find_aer_capability(pdev->port);
+        pos = pci_find_ext_capability(pdev->port, PCI_EXT_CAP_ID_ERR);
         /*
          * Must lock access to Root Error Status Reg, Root Error ID Reg,
          * and Root error producer/consumer index
@@ -252,7 +252,7 @@ static pci_ers_result_t aer_root_reset(struct pci_dev *dev)
         u32 status;
         int pos;
 
-        pos = pci_find_aer_capability(dev);
+        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
 
         /* Disable Root's interrupt in response to error messages */
         pci_write_config_dword(dev, pos + PCI_ERR_ROOT_COMMAND, 0);
@@ -316,7 +316,7 @@ static void aer_error_resume(struct pci_dev *dev)
         pci_write_config_word(dev, pos + PCI_EXP_DEVSTA, reg16);
 
         /* Clean AER Root Error Status */
-        pos = pci_find_aer_capability(dev);
+        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_STATUS, &status);
         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_SEVER, &mask);
         if (dev->error_state == pci_channel_io_normal)
diff --git a/drivers/pci/pcie/aer/aerdrv_core.c b/drivers/pci/pcie/aer/aerdrv_core.c
index ee5e7b5176d0..dfc63d01f20a 100644
--- a/drivers/pci/pcie/aer/aerdrv_core.c
+++ b/drivers/pci/pcie/aer/aerdrv_core.c
@@ -28,41 +28,15 @@
 static int forceload;
 module_param(forceload, bool, 0);
 
-#define PCI_CFG_SPACE_SIZE      (0x100)
-int pci_find_aer_capability(struct pci_dev *dev)
-{
-        int pos;
-        u32 reg32 = 0;
-
-        /* Check if it's a pci-express device */
-        pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
-        if (!pos)
-                return 0;
-
-        /* Check if it supports pci-express AER */
-        pos = PCI_CFG_SPACE_SIZE;
-        while (pos) {
-                if (pci_read_config_dword(dev, pos, &reg32))
-                        return 0;
-
-                /* some broken boards return ~0 */
-                if (reg32 == 0xffffffff)
-                        return 0;
-
-                if (PCI_EXT_CAP_ID(reg32) == PCI_EXT_CAP_ID_ERR)
-                        break;
-
-                pos = reg32 >> 20;
-        }
-
-        return pos;
-}
-
 int pci_enable_pcie_error_reporting(struct pci_dev *dev)
 {
         u16 reg16 = 0;
         int pos;
 
+        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
+        if (!pos)
+                return -EIO;
+
         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
         if (!pos)
                 return -EIO;
@@ -102,7 +76,7 @@ int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev)
         int pos;
         u32 status, mask;
 
-        pos = pci_find_aer_capability(dev);
+        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
         if (!pos)
                 return -EIO;
 
@@ -123,7 +97,7 @@ int pci_cleanup_aer_correct_error_status(struct pci_dev *dev)
         int pos;
         u32 status;
 
-        pos = pci_find_aer_capability(dev);
+        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
         if (!pos)
                 return -EIO;
 
@@ -502,7 +476,7 @@ static void handle_error_source(struct pcie_device * aerdev,
                  * Correctable error does not need software intevention.
                  * No need to go through error recovery process.
                  */
-                pos = pci_find_aer_capability(dev);
+                pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
                 if (pos)
                         pci_write_config_dword(dev, pos + PCI_ERR_COR_STATUS,
                                         info.status);
@@ -542,7 +516,7 @@ void aer_enable_rootport(struct aer_rpc *rpc)
         reg16 &= ~(SYSTEM_ERROR_INTR_ON_MESG_MASK);
         pci_write_config_word(pdev, pos + PCI_EXP_RTCTL, reg16);
 
-        aer_pos = pci_find_aer_capability(pdev);
+        aer_pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
         /* Clear error status */
         pci_read_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, &reg32);
         pci_write_config_dword(pdev, aer_pos + PCI_ERR_ROOT_STATUS, reg32);
@@ -579,7 +553,7 @@ static void disable_root_aer(struct aer_rpc *rpc)
         u32 reg32;
         int pos;
 
-        pos = pci_find_aer_capability(pdev);
+        pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
         /* Disable Root's interrupt in response to error messages */
         pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, 0);
 
@@ -618,7 +592,7 @@ static int get_device_error_info(struct pci_dev *dev, struct aer_err_info *info)
 {
         int pos;
 
-        pos = pci_find_aer_capability(dev);
+        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
 
         /* The device might not support AER */
         if (!pos)
@@ -755,7 +729,6 @@ int aer_init(struct pcie_device *dev)
         return AER_SUCCESS;
 }
 
-EXPORT_SYMBOL_GPL(pci_find_aer_capability);
 EXPORT_SYMBOL_GPL(pci_enable_pcie_error_reporting);
 EXPORT_SYMBOL_GPL(pci_disable_pcie_error_reporting);
 EXPORT_SYMBOL_GPL(pci_cleanup_aer_uncorrect_error_status);
diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c
index 851f5b83cdbc..8f63f4c6b85f 100644
--- a/drivers/pci/pcie/aspm.c
+++ b/drivers/pci/pcie/aspm.c
@@ -528,9 +528,9 @@ static int pcie_aspm_sanity_check(struct pci_dev *pdev)
                 pci_read_config_dword(child_dev, child_pos + PCI_EXP_DEVCAP,
                         &reg32);
                 if (!(reg32 & PCI_EXP_DEVCAP_RBER) && !aspm_force) {
-                        printk("Pre-1.1 PCIe device detected, "
-                                "disable ASPM for %s. It can be enabled forcedly"
-                                " with 'pcie_aspm=force'\n", pci_name(pdev));
+                        dev_printk(KERN_INFO, &child_dev->dev, "disabling ASPM"
+                                " on pre-1.1 PCIe device.  You can enable it"
+                                " with 'pcie_aspm=force'\n");
                         return -EINVAL;
                 }
         }
diff --git a/drivers/pci/pcie/portdrv.h b/drivers/pci/pcie/portdrv.h
index 3656e0349dd1..2529f3f2ea5a 100644
--- a/drivers/pci/pcie/portdrv.h
+++ b/drivers/pci/pcie/portdrv.h
@@ -25,7 +25,6 @@
 #define PCIE_CAPABILITIES_REG           0x2
 #define PCIE_SLOT_CAPABILITIES_REG      0x14
 #define PCIE_PORT_DEVICE_MAXSERVICES    4
-#define PCI_CFG_SPACE_SIZE              256
 
 #define get_descriptor_id(type, service) (((type - 4) << 4) | service)
 
diff --git a/drivers/pci/pcie/portdrv_core.c b/drivers/pci/pcie/portdrv_core.c
index 890f0d2b370a..2e091e014829 100644
--- a/drivers/pci/pcie/portdrv_core.c
+++ b/drivers/pci/pcie/portdrv_core.c
@@ -195,24 +195,11 @@ static int get_port_device_capability(struct pci_dev *dev)
         /* PME Capable - root port capability */
         if (((reg16 >> 4) & PORT_TYPE_MASK) == PCIE_RC_PORT)
                 services |= PCIE_PORT_SERVICE_PME;
-        
-        pos = PCI_CFG_SPACE_SIZE;
-        while (pos) {
-                pci_read_config_dword(dev, pos, &reg32);
-                switch (reg32 & 0xffff) {
-                case PCI_EXT_CAP_ID_ERR:
-                        services |= PCIE_PORT_SERVICE_AER;
-                        pos = reg32 >> 20;
-                        break;
-                case PCI_EXT_CAP_ID_VC:
-                        services |= PCIE_PORT_SERVICE_VC;
-                        pos = reg32 >> 20;
-                        break;
-                default:
-                        pos = 0;
-                        break;
-                }
-        }
+
+        if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR))
+                services |= PCIE_PORT_SERVICE_AER;
+        if (pci_find_ext_capability(dev, PCI_EXT_CAP_ID_VC))
+                services |= PCIE_PORT_SERVICE_VC;
 
         return services;
 }
diff --git a/drivers/pci/pcie/portdrv_pci.c b/drivers/pci/pcie/portdrv_pci.c
index 367c9c20000d..584422da8d8b 100644
--- a/drivers/pci/pcie/portdrv_pci.c
+++ b/drivers/pci/pcie/portdrv_pci.c
@@ -91,7 +91,7 @@ static int __devinit pcie_portdrv_probe (struct pci_dev *dev,
         
         pci_set_master(dev);
         if (!dev->irq && dev->pin) {
-                dev_warn(&dev->dev, "device [%04x/%04x] has invalid IRQ; "
+                dev_warn(&dev->dev, "device [%04x:%04x] has invalid IRQ; "
                          "check vendor BIOS\n", dev->vendor, dev->device);
         }
         if (pcie_port_device_register(dev)) {
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index dd9161a054e1..aaaf0a1fed22 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -14,8 +14,6 @@
 
 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
 #define CARDBUS_RESERVE_BUSNR   3
-#define PCI_CFG_SPACE_SIZE      256
-#define PCI_CFG_SPACE_EXP_SIZE  4096
 
 /* Ugh.  Need to stop exporting this to modules. */
 LIST_HEAD(pci_root_buses);
@@ -44,72 +42,6 @@ int no_pci_devices(void)
 }
 EXPORT_SYMBOL(no_pci_devices);
 
-#ifdef HAVE_PCI_LEGACY
-/**
- * pci_create_legacy_files - create legacy I/O port and memory files
- * @b: bus to create files under
- *
- * Some platforms allow access to legacy I/O port and ISA memory space on
- * a per-bus basis.  This routine creates the files and ties them into
- * their associated read, write and mmap files from pci-sysfs.c
- *
- * On error unwind, but don't propogate the error to the caller
- * as it is ok to set up the PCI bus without these files.
- */
-static void pci_create_legacy_files(struct pci_bus *b)
-{
-        int error;
-
-        b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
-                               GFP_ATOMIC);
-        if (!b->legacy_io)
-                goto kzalloc_err;
-
-        b->legacy_io->attr.name = "legacy_io";
-        b->legacy_io->size = 0xffff;
-        b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
-        b->legacy_io->read = pci_read_legacy_io;
-        b->legacy_io->write = pci_write_legacy_io;
-        error = device_create_bin_file(&b->dev, b->legacy_io);
-        if (error)
-                goto legacy_io_err;
-
-        /* Allocated above after the legacy_io struct */
-        b->legacy_mem = b->legacy_io + 1;
-        b->legacy_mem->attr.name = "legacy_mem";
-        b->legacy_mem->size = 1024*1024;
-        b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
-        b->legacy_mem->mmap = pci_mmap_legacy_mem;
-        error = device_create_bin_file(&b->dev, b->legacy_mem);
-        if (error)
-                goto legacy_mem_err;
-
-        return;
-
-legacy_mem_err:
-        device_remove_bin_file(&b->dev, b->legacy_io);
-legacy_io_err:
-        kfree(b->legacy_io);
-        b->legacy_io = NULL;
-kzalloc_err:
-        printk(KERN_WARNING "pci: warning: could not create legacy I/O port "
-               "and ISA memory resources to sysfs\n");
-        return;
-}
-
-void pci_remove_legacy_files(struct pci_bus *b)
-{
-        if (b->legacy_io) {
-                device_remove_bin_file(&b->dev, b->legacy_io);
-                device_remove_bin_file(&b->dev, b->legacy_mem);
-                kfree(b->legacy_io); /* both are allocated here */
-        }
-}
-#else /* !HAVE_PCI_LEGACY */
-static inline void pci_create_legacy_files(struct pci_bus *bus) { return; }
-void pci_remove_legacy_files(struct pci_bus *bus) { return; }
-#endif /* HAVE_PCI_LEGACY */
-
 /*
  * PCI Bus Class Devices
  */
@@ -219,7 +151,7 @@ static inline enum pci_bar_type decode_bar(struct resource *res, u32 bar)
 
         res->flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
 
-        if (res->flags == PCI_BASE_ADDRESS_MEM_TYPE_64)
+        if (res->flags & PCI_BASE_ADDRESS_MEM_TYPE_64)
                 return pci_bar_mem64;
         return pci_bar_mem32;
 }
@@ -304,9 +236,8 @@ static int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
                 } else {
                         res->start = l64;
                         res->end = l64 + sz64;
-                        printk(KERN_DEBUG "PCI: %s reg %x 64bit mmio: [%llx, %llx]\n",
-                                pci_name(dev), pos, (unsigned long long)res->start,
-                                (unsigned long long)res->end);
+                        dev_printk(KERN_DEBUG, &dev->dev,
+                                "reg %x 64bit mmio: %pR\n", pos, res);
                 }
         } else {
                 sz = pci_size(l, sz, mask);
@@ -316,9 +247,10 @@ static int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 
                 res->start = l;
                 res->end = l + sz;
-                printk(KERN_DEBUG "PCI: %s reg %x %s: [%llx, %llx]\n", pci_name(dev),
-                        pos, (res->flags & IORESOURCE_IO) ? "io port":"32bit mmio",
-                        (unsigned long long)res->start, (unsigned long long)res->end);
+
+                dev_printk(KERN_DEBUG, &dev->dev, "reg %x %s: %pR\n", pos,
+                        (res->flags & IORESOURCE_IO) ? "io port" : "32bit mmio",
+                        res);
         }
 
  out:
@@ -389,9 +321,7 @@ void __devinit pci_read_bridge_bases(struct pci_bus *child)
                         res->start = base;
                 if (!res->end)
                         res->end = limit + 0xfff;
-                printk(KERN_DEBUG "PCI: bridge %s io port: [%llx, %llx]\n",
-                        pci_name(dev), (unsigned long long) res->start,
-                        (unsigned long long) res->end);
+                dev_printk(KERN_DEBUG, &dev->dev, "bridge io port: %pR\n", res);
         }
 
         res = child->resource[1];
@@ -403,9 +333,8 @@ void __devinit pci_read_bridge_bases(struct pci_bus *child)
                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
                 res->start = base;
                 res->end = limit + 0xfffff;
-                printk(KERN_DEBUG "PCI: bridge %s 32bit mmio: [%llx, %llx]\n",
-                        pci_name(dev), (unsigned long long) res->start,
-                        (unsigned long long) res->end);
+                dev_printk(KERN_DEBUG, &dev->dev, "bridge 32bit mmio: %pR\n",
+                        res);
         }
 
         res = child->resource[2];
@@ -441,9 +370,9 @@ void __devinit pci_read_bridge_bases(struct pci_bus *child)
                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM | IORESOURCE_PREFETCH;
                 res->start = base;
                 res->end = limit + 0xfffff;
-                printk(KERN_DEBUG "PCI: bridge %s %sbit mmio pref: [%llx, %llx]\n",
-                        pci_name(dev), (res->flags & PCI_PREF_RANGE_TYPE_64) ? "64" : "32",
-                        (unsigned long long) res->start, (unsigned long long) res->end);
+                dev_printk(KERN_DEBUG, &dev->dev, "bridge %sbit mmio pref: %pR\n",
+                        (res->flags & PCI_PREF_RANGE_TYPE_64) ? "64" : "32",
+                        res);
         }
 }
 
@@ -764,7 +693,7 @@ static int pci_setup_device(struct pci_dev * dev)
         dev->class = class;
         class >>= 8;
 
-        dev_dbg(&dev->dev, "found [%04x/%04x] class %06x header type %02x\n",
+        dev_dbg(&dev->dev, "found [%04x:%04x] class %06x header type %02x\n",
                  dev->vendor, dev->device, class, dev->hdr_type);
 
         /* "Unknown power state" */
@@ -846,6 +775,11 @@ static int pci_setup_device(struct pci_dev * dev)
         return 0;
 }
 
+static void pci_release_capabilities(struct pci_dev *dev)
+{
+        pci_vpd_release(dev);
+}
+
 /**
  * pci_release_dev - free a pci device structure when all users of it are finished.
  * @dev: device that's been disconnected
@@ -858,7 +792,7 @@ static void pci_release_dev(struct device *dev)
         struct pci_dev *pci_dev;
 
         pci_dev = to_pci_dev(dev);
-        pci_vpd_release(pci_dev);
+        pci_release_capabilities(pci_dev);
         kfree(pci_dev);
 }
 
@@ -889,8 +823,9 @@ static void set_pcie_port_type(struct pci_dev *pdev)
 int pci_cfg_space_size_ext(struct pci_dev *dev)
 {
         u32 status;
+        int pos = PCI_CFG_SPACE_SIZE;
 
-        if (pci_read_config_dword(dev, 256, &status) != PCIBIOS_SUCCESSFUL)
+        if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
                 goto fail;
         if (status == 0xffffffff)
                 goto fail;
@@ -938,8 +873,6 @@ struct pci_dev *alloc_pci_dev(void)
 
         INIT_LIST_HEAD(&dev->bus_list);
 
-        pci_msi_init_pci_dev(dev);
-
         return dev;
 }
 EXPORT_SYMBOL(alloc_pci_dev);
@@ -951,6 +884,7 @@ EXPORT_SYMBOL(alloc_pci_dev);
 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
 {
         struct pci_dev *dev;
+        struct pci_slot *slot;
         u32 l;
         u8 hdr_type;
         int delay = 1;
@@ -999,6 +933,10 @@ static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
         dev->error_state = pci_channel_io_normal;
         set_pcie_port_type(dev);
 
+        list_for_each_entry(slot, &bus->slots, list)
+                if (PCI_SLOT(devfn) == slot->number)
+                        dev->slot = slot;
+
         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
            set this higher, assuming the system even supports it.  */
         dev->dma_mask = 0xffffffff;
@@ -1007,9 +945,22 @@ static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
                 return NULL;
         }
 
+        return dev;
+}
+
+static void pci_init_capabilities(struct pci_dev *dev)
+{
+        /* MSI/MSI-X list */
+        pci_msi_init_pci_dev(dev);
+
+        /* Power Management */
+        pci_pm_init(dev);
+
+        /* Vital Product Data */
         pci_vpd_pci22_init(dev);
 
-        return dev;
+        /* Alternative Routing-ID Forwarding */
+        pci_enable_ari(dev);
 }
 
 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
@@ -1028,8 +979,8 @@ void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
         /* Fix up broken headers */
         pci_fixup_device(pci_fixup_header, dev);
 
-        /* Initialize power management of the device */
-        pci_pm_init(dev);
+        /* Initialize various capabilities */
+        pci_init_capabilities(dev);
 
         /*
          * Add the device to our list of discovered devices
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index e872ac925b4b..bbf66ea8fd87 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -24,6 +24,14 @@
 #include <linux/kallsyms.h>
 #include "pci.h"
 
+int isa_dma_bridge_buggy;
+EXPORT_SYMBOL(isa_dma_bridge_buggy);
+int pci_pci_problems;
+EXPORT_SYMBOL(pci_pci_problems);
+int pcie_mch_quirk;
+EXPORT_SYMBOL(pcie_mch_quirk);
+
+#ifdef CONFIG_PCI_QUIRKS
 /* The Mellanox Tavor device gives false positive parity errors
  * Mark this device with a broken_parity_status, to allow
  * PCI scanning code to "skip" this now blacklisted device.
@@ -62,8 +70,6 @@ DECLARE_PCI_FIXUP_RESUME(PCI_VENDOR_ID_INTEL,	PCI_DEVICE_ID_INTEL_82441,	quirk_p
     
     This appears to be BIOS not version dependent. So presumably there is a 
     chipset level fix */
-int isa_dma_bridge_buggy;
-EXPORT_SYMBOL(isa_dma_bridge_buggy);
     
 static void __devinit quirk_isa_dma_hangs(struct pci_dev *dev)
 {
@@ -84,9 +90,6 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NEC,	PCI_DEVICE_ID_NEC_CBUS_1,	quirk_isa_d
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NEC,      PCI_DEVICE_ID_NEC_CBUS_2,       quirk_isa_dma_hangs);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NEC,      PCI_DEVICE_ID_NEC_CBUS_3,       quirk_isa_dma_hangs);
 
-int pci_pci_problems;
-EXPORT_SYMBOL(pci_pci_problems);
-
 /*
  *      Chipsets where PCI->PCI transfers vanish or hang
  */
@@ -1362,9 +1365,6 @@ static void __init quirk_alder_ioapic(struct pci_dev *pdev)
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_EESSC,      quirk_alder_ioapic);
 #endif
 
-int pcie_mch_quirk;
-EXPORT_SYMBOL(pcie_mch_quirk);
-
 static void __devinit quirk_pcie_mch(struct pci_dev *pdev)
 {
         pcie_mch_quirk = 1;
@@ -1555,84 +1555,6 @@ static void __devinit fixup_rev1_53c810(struct pci_dev* dev)
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NCR, PCI_DEVICE_ID_NCR_53C810, fixup_rev1_53c810);
 
-static void pci_do_fixups(struct pci_dev *dev, struct pci_fixup *f, struct pci_fixup *end)
-{
-        while (f < end) {
-                if ((f->vendor == dev->vendor || f->vendor == (u16) PCI_ANY_ID) &&
-                    (f->device == dev->device || f->device == (u16) PCI_ANY_ID)) {
-#ifdef DEBUG
-                        dev_dbg(&dev->dev, "calling %pF\n", f->hook);
-#endif
-                        f->hook(dev);
-                }
-                f++;
-        }
-}
-
-extern struct pci_fixup __start_pci_fixups_early[];
-extern struct pci_fixup __end_pci_fixups_early[];
-extern struct pci_fixup __start_pci_fixups_header[];
-extern struct pci_fixup __end_pci_fixups_header[];
-extern struct pci_fixup __start_pci_fixups_final[];
-extern struct pci_fixup __end_pci_fixups_final[];
-extern struct pci_fixup __start_pci_fixups_enable[];
-extern struct pci_fixup __end_pci_fixups_enable[];
-extern struct pci_fixup __start_pci_fixups_resume[];
-extern struct pci_fixup __end_pci_fixups_resume[];
-extern struct pci_fixup __start_pci_fixups_resume_early[];
-extern struct pci_fixup __end_pci_fixups_resume_early[];
-extern struct pci_fixup __start_pci_fixups_suspend[];
-extern struct pci_fixup __end_pci_fixups_suspend[];
-
-
-void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev)
-{
-        struct pci_fixup *start, *end;
-
-        switch(pass) {
-        case pci_fixup_early:
-                start = __start_pci_fixups_early;
-                end = __end_pci_fixups_early;
-                break;
-
-        case pci_fixup_header:
-                start = __start_pci_fixups_header;
-                end = __end_pci_fixups_header;
-                break;
-
-        case pci_fixup_final:
-                start = __start_pci_fixups_final;
-                end = __end_pci_fixups_final;
-                break;
-
-        case pci_fixup_enable:
-                start = __start_pci_fixups_enable;
-                end = __end_pci_fixups_enable;
-                break;
-
-        case pci_fixup_resume:
-                start = __start_pci_fixups_resume;
-                end = __end_pci_fixups_resume;
-                break;
-
-        case pci_fixup_resume_early:
-                start = __start_pci_fixups_resume_early;
-                end = __end_pci_fixups_resume_early;
-                break;
-
-        case pci_fixup_suspend:
-                start = __start_pci_fixups_suspend;
-                end = __end_pci_fixups_suspend;
-                break;
-
-        default:
-                /* stupid compiler warning, you would think with an enum... */
-                return;
-        }
-        pci_do_fixups(dev, start, end);
-}
-EXPORT_SYMBOL(pci_fixup_device);
-
 /* Enable 1k I/O space granularity on the Intel P64H2 */
 static void __devinit quirk_p64h2_1k_io(struct pci_dev *dev)
 {
@@ -2006,3 +1928,82 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x4375,
                         quirk_msi_intx_disable_bug);
 
 #endif /* CONFIG_PCI_MSI */
+
+static void pci_do_fixups(struct pci_dev *dev, struct pci_fixup *f, struct pci_fixup *end)
+{
+        while (f < end) {
+                if ((f->vendor == dev->vendor || f->vendor == (u16) PCI_ANY_ID) &&
+                    (f->device == dev->device || f->device == (u16) PCI_ANY_ID)) {
+                        dev_dbg(&dev->dev, "calling %pF\n", f->hook);
+                        f->hook(dev);
+                }
+                f++;
+        }
+}
+
+extern struct pci_fixup __start_pci_fixups_early[];
+extern struct pci_fixup __end_pci_fixups_early[];
+extern struct pci_fixup __start_pci_fixups_header[];
+extern struct pci_fixup __end_pci_fixups_header[];
+extern struct pci_fixup __start_pci_fixups_final[];
+extern struct pci_fixup __end_pci_fixups_final[];
+extern struct pci_fixup __start_pci_fixups_enable[];
+extern struct pci_fixup __end_pci_fixups_enable[];
+extern struct pci_fixup __start_pci_fixups_resume[];
+extern struct pci_fixup __end_pci_fixups_resume[];
+extern struct pci_fixup __start_pci_fixups_resume_early[];
+extern struct pci_fixup __end_pci_fixups_resume_early[];
+extern struct pci_fixup __start_pci_fixups_suspend[];
+extern struct pci_fixup __end_pci_fixups_suspend[];
+
+
+void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev)
+{
+        struct pci_fixup *start, *end;
+
+        switch(pass) {
+        case pci_fixup_early:
+                start = __start_pci_fixups_early;
+                end = __end_pci_fixups_early;
+                break;
+
+        case pci_fixup_header:
+                start = __start_pci_fixups_header;
+                end = __end_pci_fixups_header;
+                break;
+
+        case pci_fixup_final:
+                start = __start_pci_fixups_final;
+                end = __end_pci_fixups_final;
+                break;
+
+        case pci_fixup_enable:
+                start = __start_pci_fixups_enable;
+                end = __end_pci_fixups_enable;
+                break;
+
+        case pci_fixup_resume:
+                start = __start_pci_fixups_resume;
+                end = __end_pci_fixups_resume;
+                break;
+
+        case pci_fixup_resume_early:
+                start = __start_pci_fixups_resume_early;
+                end = __end_pci_fixups_resume_early;
+                break;
+
+        case pci_fixup_suspend:
+                start = __start_pci_fixups_suspend;
+                end = __end_pci_fixups_suspend;
+                break;
+
+        default:
+                /* stupid compiler warning, you would think with an enum... */
+                return;
+        }
+        pci_do_fixups(dev, start, end);
+}
+#else
+void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev) {}
+#endif
+EXPORT_SYMBOL(pci_fixup_device);
diff --git a/drivers/pci/remove.c b/drivers/pci/remove.c
index bdc2a44d68e1..042e08924421 100644
--- a/drivers/pci/remove.c
+++ b/drivers/pci/remove.c
@@ -73,6 +73,7 @@ void pci_remove_bus(struct pci_bus *pci_bus)
         up_write(&pci_bus_sem);
         pci_remove_legacy_files(pci_bus);
         device_remove_file(&pci_bus->dev, &dev_attr_cpuaffinity);
+        device_remove_file(&pci_bus->dev, &dev_attr_cpulistaffinity);
         device_unregister(&pci_bus->dev);
 }
 EXPORT_SYMBOL(pci_remove_bus);
@@ -114,13 +115,9 @@ void pci_remove_behind_bridge(struct pci_dev *dev)
 {
         struct list_head *l, *n;
 
-        if (dev->subordinate) {
-                list_for_each_safe(l, n, &dev->subordinate->devices) {
-                        struct pci_dev *dev = pci_dev_b(l);
-
-                        pci_remove_bus_device(dev);
-                }
-        }
+        if (dev->subordinate)
+                list_for_each_safe(l, n, &dev->subordinate->devices)
+                        pci_remove_bus_device(pci_dev_b(l));
 }
 
 static void pci_stop_bus_devices(struct pci_bus *bus)
diff --git a/drivers/pci/rom.c b/drivers/pci/rom.c
index bd5c0e031398..1f5f6143f35c 100644
--- a/drivers/pci/rom.c
+++ b/drivers/pci/rom.c
@@ -21,7 +21,7 @@
  * between the ROM and other resources, so enabling it may disable access
  * to MMIO registers or other card memory.
  */
-static int pci_enable_rom(struct pci_dev *pdev)
+int pci_enable_rom(struct pci_dev *pdev)
 {
         struct resource *res = pdev->resource + PCI_ROM_RESOURCE;
         struct pci_bus_region region;
@@ -45,7 +45,7 @@ static int pci_enable_rom(struct pci_dev *pdev)
  * Disable ROM decoding on a PCI device by turning off the last bit in the
  * ROM BAR.
  */
-static void pci_disable_rom(struct pci_dev *pdev)
+void pci_disable_rom(struct pci_dev *pdev)
 {
         u32 rom_addr;
         pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr);
@@ -260,3 +260,5 @@ void pci_cleanup_rom(struct pci_dev *pdev)
 
 EXPORT_SYMBOL(pci_map_rom);
 EXPORT_SYMBOL(pci_unmap_rom);
+EXPORT_SYMBOL_GPL(pci_enable_rom);
+EXPORT_SYMBOL_GPL(pci_disable_rom);
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index d5e2106760f8..ea979f2bc6db 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -299,7 +299,7 @@ static void pbus_size_io(struct pci_bus *bus)
 
                         if (r->parent || !(r->flags & IORESOURCE_IO))
                                 continue;
-                        r_size = r->end - r->start + 1;
+                        r_size = resource_size(r);
 
                         if (r_size < 0x400)
                                 /* Might be re-aligned for ISA */
@@ -350,16 +350,13 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask, unsigned long
 
                         if (r->parent || (r->flags & mask) != type)
                                 continue;
-                        r_size = r->end - r->start + 1;
+                        r_size = resource_size(r);
                         /* For bridges size != alignment */
                         align = resource_alignment(r);
                         order = __ffs(align) - 20;
                         if (order > 11) {
                                 dev_warn(&dev->dev, "BAR %d bad alignment %llx: "
-                                       "%#016llx-%#016llx\n", i,
-                                       (unsigned long long)align,
-                                       (unsigned long long)r->start,
-                                       (unsigned long long)r->end);
+                                         "%pR\n", i, (unsigned long long)align, r);
                                 r->flags = 0;
                                 continue;
                         }
@@ -539,11 +536,9 @@ static void pci_bus_dump_res(struct pci_bus *bus)
                 if (!res)
                         continue;
 
-                printk(KERN_INFO "bus: %02x index %x %s: [%llx, %llx]\n",
-                        bus->number, i,
-                        (res->flags & IORESOURCE_IO) ? "io port" : "mmio",
-                        (unsigned long long) res->start,
-                        (unsigned long long) res->end);
+                printk(KERN_INFO "bus: %02x index %x %s: %pR\n",
+                       bus->number, i,
+                       (res->flags & IORESOURCE_IO) ? "io port" : "mmio", res);
         }
 }
 
diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c
index 1a5fc83c71b3..2dbd96cce2d8 100644
--- a/drivers/pci/setup-res.c
+++ b/drivers/pci/setup-res.c
@@ -49,10 +49,8 @@ void pci_update_resource(struct pci_dev *dev, struct resource *res, int resno)
 
         pcibios_resource_to_bus(dev, &region, res);
 
-        dev_dbg(&dev->dev, "BAR %d: got res [%#llx-%#llx] bus [%#llx-%#llx] "
-                "flags %#lx\n", resno,
-                 (unsigned long long)res->start,
-                 (unsigned long long)res->end,
+        dev_dbg(&dev->dev, "BAR %d: got res %pR bus [%#llx-%#llx] "
+                "flags %#lx\n", resno, res,
                  (unsigned long long)region.start,
                  (unsigned long long)region.end,
                  (unsigned long)res->flags);
@@ -114,13 +112,11 @@ int pci_claim_resource(struct pci_dev *dev, int resource)
                 err = insert_resource(root, res);
 
         if (err) {
-                dev_err(&dev->dev, "BAR %d: %s of %s [%#llx-%#llx]\n",
+                dev_err(&dev->dev, "BAR %d: %s of %s %pR\n",
                         resource,
                         root ? "address space collision on" :
                                 "no parent found for",
-                        dtype,
-                        (unsigned long long)res->start,
-                        (unsigned long long)res->end);
+                        dtype, res);
         }
 
         return err;
@@ -133,15 +129,14 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
         resource_size_t size, min, align;
         int ret;
 
-        size = res->end - res->start + 1;
+        size = resource_size(res);
         min = (res->flags & IORESOURCE_IO) ? PCIBIOS_MIN_IO : PCIBIOS_MIN_MEM;
 
         align = resource_alignment(res);
         if (!align) {
                 dev_err(&dev->dev, "BAR %d: can't allocate resource (bogus "
-                        "alignment) [%#llx-%#llx] flags %#lx\n",
-                        resno, (unsigned long long)res->start,
-                        (unsigned long long)res->end, res->flags);
+                        "alignment) %pR flags %#lx\n",
+                        resno, res, res->flags);
                 return -EINVAL;
         }
 
@@ -162,11 +157,8 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
         }
 
         if (ret) {
-                dev_err(&dev->dev, "BAR %d: can't allocate %s resource "
-                        "[%#llx-%#llx]\n", resno,
-                        res->flags & IORESOURCE_IO ? "I/O" : "mem",
-                        (unsigned long long)res->start,
-                        (unsigned long long)res->end);
+                dev_err(&dev->dev, "BAR %d: can't allocate %s resource %pR\n",
+                        resno, res->flags & IORESOURCE_IO ? "I/O" : "mem", res);
         } else {
                 res->flags &= ~IORESOURCE_STARTALIGN;
                 if (resno < PCI_BRIDGE_RESOURCES)
@@ -202,11 +194,8 @@ int pci_assign_resource_fixed(struct pci_dev *dev, int resno)
         }
 
         if (ret) {
-                dev_err(&dev->dev, "BAR %d: can't allocate %s resource "
-                        "[%#llx-%#llx\n]", resno,
-                        res->flags & IORESOURCE_IO ? "I/O" : "mem",
-                        (unsigned long long)res->start,
-                        (unsigned long long)res->end);
+                dev_err(&dev->dev, "BAR %d: can't allocate %s resource %pR\n",
+                        resno, res->flags & IORESOURCE_IO ? "I/O" : "mem", res);
         } else if (resno < PCI_BRIDGE_RESOURCES) {
                 pci_update_resource(dev, res, resno);
         }
@@ -237,9 +226,8 @@ void pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
                 r_align = resource_alignment(r);
                 if (!r_align) {
                         dev_warn(&dev->dev, "BAR %d: bogus alignment "
-                                "[%#llx-%#llx] flags %#lx\n",
-                                i, (unsigned long long)r->start,
-                                (unsigned long long)r->end, r->flags);
+                                "%pR flags %#lx\n",
+                                i, r, r->flags);
                         continue;
                 }
                 for (list = head; ; list = list->next) {
@@ -287,9 +275,7 @@ int pci_enable_resources(struct pci_dev *dev, int mask)
 
                 if (!r->parent) {
                         dev_err(&dev->dev, "device not available because of "
-                                "BAR %d [%#llx-%#llx] collisions\n", i,
-                                (unsigned long long) r->start,
-                                (unsigned long long) r->end);
+                                "BAR %d %pR collisions\n", i, r);
                         return -EINVAL;
                 }
 
diff --git a/drivers/pci/slot.c b/drivers/pci/slot.c
index 7e5b85cbd948..0c6db03698ea 100644
--- a/drivers/pci/slot.c
+++ b/drivers/pci/slot.c
@@ -49,11 +49,16 @@ static ssize_t address_read_file(struct pci_slot *slot, char *buf)
 
 static void pci_slot_release(struct kobject *kobj)
 {
+        struct pci_dev *dev;
         struct pci_slot *slot = to_pci_slot(kobj);
 
         pr_debug("%s: releasing pci_slot on %x:%d\n", __func__,
                  slot->bus->number, slot->number);
 
+        list_for_each_entry(dev, &slot->bus->devices, bus_list)
+                if (PCI_SLOT(dev->devfn) == slot->number)
+                        dev->slot = NULL;
+
         list_del(&slot->list);
 
         kfree(slot);
@@ -108,6 +113,7 @@ static struct kobj_type pci_slot_ktype = {
 struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
                                  const char *name)
 {
+        struct pci_dev *dev;
         struct pci_slot *slot;
         int err;
 
@@ -150,6 +156,10 @@ placeholder:
         INIT_LIST_HEAD(&slot->list);
         list_add(&slot->list, &parent->slots);
 
+        list_for_each_entry(dev, &parent->devices, bus_list)
+                if (PCI_SLOT(dev->devfn) == slot_nr)
+                        dev->slot = slot;
+
         /* Don't care if debug printk has a -1 for slot_nr */
         pr_debug("%s: created pci_slot on %04x:%02x:%02x\n",
                  __func__, pci_domain_nr(parent), parent->number, slot_nr);
diff --git a/drivers/pcmcia/at91_cf.c b/drivers/pcmcia/at91_cf.c
index a0ffb8ebfe00..9e1140f085fd 100644
--- a/drivers/pcmcia/at91_cf.c
+++ b/drivers/pcmcia/at91_cf.c
@@ -273,7 +273,7 @@ static int __init at91_cf_probe(struct platform_device *pdev)
                         goto fail0d;
                 cf->socket.pci_irq = board->irq_pin;
         } else
-                cf->socket.pci_irq = NR_IRQS + 1;
+                cf->socket.pci_irq = nr_irqs + 1;
 
         /* pcmcia layer only remaps "real" memory not iospace */
         cf->socket.io_offset = (unsigned long)
diff --git a/drivers/pcmcia/hd64465_ss.c b/drivers/pcmcia/hd64465_ss.c
index 117dc12ab438..9ef69cdb3183 100644
--- a/drivers/pcmcia/hd64465_ss.c
+++ b/drivers/pcmcia/hd64465_ss.c
@@ -233,15 +233,18 @@ static struct hw_interrupt_type hd64465_ss_irq_type = {
  */
 static void hs_map_irq(hs_socket_t *sp, unsigned int irq)
 {
+        struct irq_desc *desc;
+
         DPRINTK("hs_map_irq(sock=%d irq=%d)\n", sp->number, irq);
         
         if (irq >= HS_NUM_MAPPED_IRQS)
             return;
 
+        desc = irq_to_desc(irq);
         hs_mapped_irq[irq].sock = sp;
         /* insert ourselves as the irq controller */
-        hs_mapped_irq[irq].old_handler = irq_desc[irq].chip;
-        irq_desc[irq].chip = &hd64465_ss_irq_type;
+        hs_mapped_irq[irq].old_handler = desc->chip;
+        desc->chip = &hd64465_ss_irq_type;
 }
 
 
@@ -250,13 +253,16 @@ static void hs_map_irq(hs_socket_t *sp, unsigned int irq)
  */
 static void hs_unmap_irq(hs_socket_t *sp, unsigned int irq)
 {
+        struct irq_desc *desc;
+
         DPRINTK("hs_unmap_irq(sock=%d irq=%d)\n", sp->number, irq);
         
         if (irq >= HS_NUM_MAPPED_IRQS)
             return;
                 
+        desc = irq_to_desc(irq);
         /* restore the original irq controller */
-        irq_desc[irq].chip = hs_mapped_irq[irq].old_handler;
+        desc->chip = hs_mapped_irq[irq].old_handler;
 }
 
 /*============================================================*/
diff --git a/drivers/pcmcia/vrc4171_card.c b/drivers/pcmcia/vrc4171_card.c
index eee2f1cb213c..b2c412419059 100644
--- a/drivers/pcmcia/vrc4171_card.c
+++ b/drivers/pcmcia/vrc4171_card.c
@@ -639,7 +639,7 @@ static int __devinit vrc4171_card_setup(char *options)
                 int irq;
                 options += 4;
                 irq = simple_strtoul(options, &options, 0);
-                if (irq >= 0 && irq < NR_IRQS)
+                if (irq >= 0 && irq < nr_irqs)
                         vrc4171_irq = irq;
 
                 if (*options != ',')
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index 63bb57910445..8e0c2b47803c 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -51,7 +51,7 @@ config BATTERY_OLPC
 
 config BATTERY_TOSA
         tristate "Sharp SL-6000 (tosa) battery"
-        depends on MACH_TOSA && MFD_TC6393XB
+        depends on MACH_TOSA && MFD_TC6393XB && TOUCHSCREEN_WM97XX
         help
           Say Y to enable support for the battery on the Sharp Zaurus
           SL-6000 (tosa) models.
@@ -62,4 +62,10 @@ config BATTERY_WM97XX
         help
           Say Y to enable support for battery measured by WM97xx aux port.
 
+config BATTERY_BQ27x00
+        tristate "BQ27200 battery driver"
+        depends on I2C
+        help
+          Say Y here to enable support for batteries with BQ27200(I2C) chip.
+
 endif # POWER_SUPPLY
diff --git a/drivers/power/Makefile b/drivers/power/Makefile
index 4e20026cc45a..e8f1ecec5d8f 100644
--- a/drivers/power/Makefile
+++ b/drivers/power/Makefile
@@ -21,4 +21,5 @@ obj-$(CONFIG_BATTERY_DS2760)	+= ds2760_battery.o
 obj-$(CONFIG_BATTERY_PMU)       += pmu_battery.o
 obj-$(CONFIG_BATTERY_OLPC)      += olpc_battery.o
 obj-$(CONFIG_BATTERY_TOSA)      += tosa_battery.o
-obj-$(CONFIG_BATTERY_WM97XX)    += wm97xx_battery.o
\ No newline at end of file
+obj-$(CONFIG_BATTERY_WM97XX)    += wm97xx_battery.o
+obj-$(CONFIG_BATTERY_BQ27x00)   += bq27x00_battery.o
diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
new file mode 100644
index 000000000000..0c056fcc01ce
--- /dev/null
+++ b/drivers/power/bq27x00_battery.c
@@ -0,0 +1,381 @@
+/*
+ * BQ27x00 battery driver
+ *
+ * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it>
+ * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it>
+ *
+ * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc.
+ *
+ * This package is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+#include <linux/module.h>
+#include <linux/param.h>
+#include <linux/jiffies.h>
+#include <linux/workqueue.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/power_supply.h>
+#include <linux/idr.h>
+#include <linux/i2c.h>
+#include <asm/unaligned.h>
+
+#define DRIVER_VERSION                  "1.0.0"
+
+#define BQ27x00_REG_TEMP                0x06
+#define BQ27x00_REG_VOLT                0x08
+#define BQ27x00_REG_RSOC                0x0B /* Relative State-of-Charge */
+#define BQ27x00_REG_AI                  0x14
+#define BQ27x00_REG_FLAGS               0x0A
+
+/* If the system has several batteries we need a different name for each
+ * of them...
+ */
+static DEFINE_IDR(battery_id);
+static DEFINE_MUTEX(battery_mutex);
+
+struct bq27x00_device_info;
+struct bq27x00_access_methods {
+        int (*read)(u8 reg, int *rt_value, int b_single,
+                struct bq27x00_device_info *di);
+};
+
+struct bq27x00_device_info {
+        struct device           *dev;
+        int                     id;
+        int                     voltage_uV;
+        int                     current_uA;
+        int                     temp_C;
+        int                     charge_rsoc;
+        struct bq27x00_access_methods   *bus;
+        struct power_supply     bat;
+
+        struct i2c_client       *client;
+};
+
+static enum power_supply_property bq27x00_battery_props[] = {
+        POWER_SUPPLY_PROP_PRESENT,
+        POWER_SUPPLY_PROP_VOLTAGE_NOW,
+        POWER_SUPPLY_PROP_CURRENT_NOW,
+        POWER_SUPPLY_PROP_CAPACITY,
+        POWER_SUPPLY_PROP_TEMP,
+};
+
+/*
+ * Common code for BQ27x00 devices
+ */
+
+static int bq27x00_read(u8 reg, int *rt_value, int b_single,
+                        struct bq27x00_device_info *di)
+{
+        int ret;
+
+        ret = di->bus->read(reg, rt_value, b_single, di);
+        *rt_value = be16_to_cpu(*rt_value);
+
+        return ret;
+}
+
+/*
+ * Return the battery temperature in Celcius degrees
+ * Or < 0 if something fails.
+ */
+static int bq27x00_battery_temperature(struct bq27x00_device_info *di)
+{
+        int ret;
+        int temp = 0;
+
+        ret = bq27x00_read(BQ27x00_REG_TEMP, &temp, 0, di);
+        if (ret) {
+                dev_err(di->dev, "error reading temperature\n");
+                return ret;
+        }
+
+        return (temp >> 2) - 273;
+}
+
+/*
+ * Return the battery Voltage in milivolts
+ * Or < 0 if something fails.
+ */
+static int bq27x00_battery_voltage(struct bq27x00_device_info *di)
+{
+        int ret;
+        int volt = 0;
+
+        ret = bq27x00_read(BQ27x00_REG_VOLT, &volt, 0, di);
+        if (ret) {
+                dev_err(di->dev, "error reading voltage\n");
+                return ret;
+        }
+
+        return volt;
+}
+
+/*
+ * Return the battery average current
+ * Note that current can be negative signed as well
+ * Or 0 if something fails.
+ */
+static int bq27x00_battery_current(struct bq27x00_device_info *di)
+{
+        int ret;
+        int curr = 0;
+        int flags = 0;
+
+        ret = bq27x00_read(BQ27x00_REG_AI, &curr, 0, di);
+        if (ret) {
+                dev_err(di->dev, "error reading current\n");
+                return 0;
+        }
+        ret = bq27x00_read(BQ27x00_REG_FLAGS, &flags, 0, di);
+        if (ret < 0) {
+                dev_err(di->dev, "error reading flags\n");
+                return 0;
+        }
+        if ((flags & (1 << 7)) != 0) {
+                dev_dbg(di->dev, "negative current!\n");
+                return -curr;
+        }
+        return curr;
+}
+
+/*
+ * Return the battery Relative State-of-Charge
+ * Or < 0 if something fails.
+ */
+static int bq27x00_battery_rsoc(struct bq27x00_device_info *di)
+{
+        int ret;
+        int rsoc = 0;
+
+        ret = bq27x00_read(BQ27x00_REG_RSOC, &rsoc, 1, di);
+        if (ret) {
+                dev_err(di->dev, "error reading relative State-of-Charge\n");
+                return ret;
+        }
+
+        return rsoc >> 8;
+}
+
+#define to_bq27x00_device_info(x) container_of((x), \
+                                struct bq27x00_device_info, bat);
+
+static int bq27x00_battery_get_property(struct power_supply *psy,
+                                        enum power_supply_property psp,
+                                        union power_supply_propval *val)
+{
+        struct bq27x00_device_info *di = to_bq27x00_device_info(psy);
+
+        switch (psp) {
+        case POWER_SUPPLY_PROP_VOLTAGE_NOW:
+        case POWER_SUPPLY_PROP_PRESENT:
+                val->intval = bq27x00_battery_voltage(di);
+                if (psp == POWER_SUPPLY_PROP_PRESENT)
+                        val->intval = val->intval <= 0 ? 0 : 1;
+                break;
+        case POWER_SUPPLY_PROP_CURRENT_NOW:
+                val->intval = bq27x00_battery_current(di);
+                break;
+        case POWER_SUPPLY_PROP_CAPACITY:
+                val->intval = bq27x00_battery_rsoc(di);
+                break;
+        case POWER_SUPPLY_PROP_TEMP:
+                val->intval = bq27x00_battery_temperature(di);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void bq27x00_powersupply_init(struct bq27x00_device_info *di)
+{
+        di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
+        di->bat.properties = bq27x00_battery_props;
+        di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props);
+        di->bat.get_property = bq27x00_battery_get_property;
+        di->bat.external_power_changed = NULL;
+}
+
+/*
+ * BQ27200 specific code
+ */
+
+static int bq27200_read(u8 reg, int *rt_value, int b_single,
+                        struct bq27x00_device_info *di)
+{
+        struct i2c_client *client = di->client;
+        struct i2c_msg msg[1];
+        unsigned char data[2];
+        int err;
+
+        if (!client->adapter)
+                return -ENODEV;
+
+        msg->addr = client->addr;
+        msg->flags = 0;
+        msg->len = 1;
+        msg->buf = data;
+
+        data[0] = reg;
+        err = i2c_transfer(client->adapter, msg, 1);
+
+        if (err >= 0) {
+                if (!b_single)
+                        msg->len = 2;
+                else
+                        msg->len = 1;
+
+                msg->flags = I2C_M_RD;
+                err = i2c_transfer(client->adapter, msg, 1);
+                if (err >= 0) {
+                        if (!b_single)
+                                *rt_value = get_unaligned_be16(data);
+                        else
+                                *rt_value = data[0];
+
+                        return 0;
+                }
+        }
+        return err;
+}
+
+static int bq27200_battery_probe(struct i2c_client *client,
+                                 const struct i2c_device_id *id)
+{
+        char *name;
+        struct bq27x00_device_info *di;
+        struct bq27x00_access_methods *bus;
+        int num;
+        int retval = 0;
+
+        /* Get new ID for the new battery device */
+        retval = idr_pre_get(&battery_id, GFP_KERNEL);
+        if (retval == 0)
+                return -ENOMEM;
+        mutex_lock(&battery_mutex);
+        retval = idr_get_new(&battery_id, client, &num);
+        mutex_unlock(&battery_mutex);
+        if (retval < 0)
+                return retval;
+
+        name = kasprintf(GFP_KERNEL, "bq27200-%d", num);
+        if (!name) {
+                dev_err(&client->dev, "failed to allocate device name\n");
+                retval = -ENOMEM;
+                goto batt_failed_1;
+        }
+
+        di = kzalloc(sizeof(*di), GFP_KERNEL);
+        if (!di) {
+                dev_err(&client->dev, "failed to allocate device info data\n");
+                retval = -ENOMEM;
+                goto batt_failed_2;
+        }
+        di->id = num;
+
+        bus = kzalloc(sizeof(*bus), GFP_KERNEL);
+        if (!bus) {
+                dev_err(&client->dev, "failed to allocate access method "
+                                        "data\n");
+                retval = -ENOMEM;
+                goto batt_failed_3;
+        }
+
+        i2c_set_clientdata(client, di);
+        di->dev = &client->dev;
+        di->bat.name = name;
+        bus->read = &bq27200_read;
+        di->bus = bus;
+        di->client = client;
+
+        bq27x00_powersupply_init(di);
+
+        retval = power_supply_register(&client->dev, &di->bat);
+        if (retval) {
+                dev_err(&client->dev, "failed to register battery\n");
+                goto batt_failed_4;
+        }
+
+        dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION);
+
+        return 0;
+
+batt_failed_4:
+        kfree(bus);
+batt_failed_3:
+        kfree(di);
+batt_failed_2:
+        kfree(name);
+batt_failed_1:
+        mutex_lock(&battery_mutex);
+        idr_remove(&battery_id, num);
+        mutex_unlock(&battery_mutex);
+
+        return retval;
+}
+
+static int bq27200_battery_remove(struct i2c_client *client)
+{
+        struct bq27x00_device_info *di = i2c_get_clientdata(client);
+
+        power_supply_unregister(&di->bat);
+
+        kfree(di->bat.name);
+
+        mutex_lock(&battery_mutex);
+        idr_remove(&battery_id, di->id);
+        mutex_unlock(&battery_mutex);
+
+        kfree(di);
+
+        return 0;
+}
+
+/*
+ * Module stuff
+ */
+
+static const struct i2c_device_id bq27200_id[] = {
+        { "bq27200", 0 },
+        {},
+};
+
+static struct i2c_driver bq27200_battery_driver = {
+        .driver = {
+                .name = "bq27200-battery",
+        },
+        .probe = bq27200_battery_probe,
+        .remove = bq27200_battery_remove,
+        .id_table = bq27200_id,
+};
+
+static int __init bq27x00_battery_init(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&bq27200_battery_driver);
+        if (ret)
+                printk(KERN_ERR "Unable to register BQ27200 driver\n");
+
+        return ret;
+}
+module_init(bq27x00_battery_init);
+
+static void __exit bq27x00_battery_exit(void)
+{
+        i2c_del_driver(&bq27200_battery_driver);
+}
+module_exit(bq27x00_battery_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("BQ27x00 battery monitor driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/power/pda_power.c b/drivers/power/pda_power.c
index 0471ec743ab9..d30bb766fcef 100644
--- a/drivers/power/pda_power.c
+++ b/drivers/power/pda_power.c
@@ -334,13 +334,16 @@ static int pda_power_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
+static int ac_wakeup_enabled;
+static int usb_wakeup_enabled;
+
 static int pda_power_suspend(struct platform_device *pdev, pm_message_t state)
 {
         if (device_may_wakeup(&pdev->dev)) {
                 if (ac_irq)
-                        enable_irq_wake(ac_irq->start);
+                        ac_wakeup_enabled = !enable_irq_wake(ac_irq->start);
                 if (usb_irq)
-                        enable_irq_wake(usb_irq->start);
+                        usb_wakeup_enabled = !enable_irq_wake(usb_irq->start);
         }
 
         return 0;
@@ -349,9 +352,9 @@ static int pda_power_suspend(struct platform_device *pdev, pm_message_t state)
 static int pda_power_resume(struct platform_device *pdev)
 {
         if (device_may_wakeup(&pdev->dev)) {
-                if (usb_irq)
+                if (usb_irq && usb_wakeup_enabled)
                         disable_irq_wake(usb_irq->start);
-                if (ac_irq)
+                if (ac_irq && ac_wakeup_enabled)
                         disable_irq_wake(ac_irq->start);
         }
 
diff --git a/drivers/power/power_supply_core.c b/drivers/power/power_supply_core.c
index 3007695f90c8..5520040449c4 100644
--- a/drivers/power/power_supply_core.c
+++ b/drivers/power/power_supply_core.c
@@ -87,6 +87,30 @@ int power_supply_am_i_supplied(struct power_supply *psy)
         return error;
 }
 
+static int __power_supply_is_system_supplied(struct device *dev, void *data)
+{
+        union power_supply_propval ret = {0,};
+        struct power_supply *psy = dev_get_drvdata(dev);
+
+        if (psy->type != POWER_SUPPLY_TYPE_BATTERY) {
+                if (psy->get_property(psy, POWER_SUPPLY_PROP_ONLINE, &ret))
+                        return 0;
+                if (ret.intval)
+                        return ret.intval;
+        }
+        return 0;
+}
+
+int power_supply_is_system_supplied(void)
+{
+        int error;
+
+        error = class_for_each_device(power_supply_class, NULL, NULL,
+                                      __power_supply_is_system_supplied);
+
+        return error;
+}
+
 int power_supply_register(struct device *parent, struct power_supply *psy)
 {
         int rc = 0;
@@ -148,6 +172,7 @@ static void __exit power_supply_class_exit(void)
 
 EXPORT_SYMBOL_GPL(power_supply_changed);
 EXPORT_SYMBOL_GPL(power_supply_am_i_supplied);
+EXPORT_SYMBOL_GPL(power_supply_is_system_supplied);
 EXPORT_SYMBOL_GPL(power_supply_register);
 EXPORT_SYMBOL_GPL(power_supply_unregister);
 
diff --git a/drivers/power/power_supply_sysfs.c b/drivers/power/power_supply_sysfs.c
index fe2aeb11939b..23ae8460f5c1 100644
--- a/drivers/power/power_supply_sysfs.c
+++ b/drivers/power/power_supply_sysfs.c
@@ -30,7 +30,7 @@
 
 #define POWER_SUPPLY_ATTR(_name)                                        \
 {                                                                       \
-        .attr = { .name = #_name, .mode = 0444, .owner = THIS_MODULE }, \
+        .attr = { .name = #_name, .mode = 0444 },       \
         .show = power_supply_show_property,                             \
         .store = NULL,                                                  \
 }
diff --git a/drivers/ps3/ps3av.c b/drivers/ps3/ps3av.c
index 6f2f90ebb020..06848b254d57 100644
--- a/drivers/ps3/ps3av.c
+++ b/drivers/ps3/ps3av.c
@@ -915,6 +915,22 @@ int ps3av_video_mute(int mute)
 
 EXPORT_SYMBOL_GPL(ps3av_video_mute);
 
+/* mute analog output only */
+int ps3av_audio_mute_analog(int mute)
+{
+        int i, res;
+
+        for (i = 0; i < ps3av->av_hw_conf.num_of_avmulti; i++) {
+                res = ps3av_cmd_av_audio_mute(1,
+                        &ps3av->av_port[i + ps3av->av_hw_conf.num_of_hdmi],
+                        mute);
+                if (res < 0)
+                        return -1;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(ps3av_audio_mute_analog);
+
 int ps3av_audio_mute(int mute)
 {
         return ps3av_set_audio_mute(mute ? PS3AV_CMD_MUTE_ON
diff --git a/drivers/ps3/ps3av_cmd.c b/drivers/ps3/ps3av_cmd.c
index 7f880c26122f..11eb50318fec 100644
--- a/drivers/ps3/ps3av_cmd.c
+++ b/drivers/ps3/ps3av_cmd.c
@@ -660,9 +660,10 @@ u32 ps3av_cmd_set_av_audio_param(void *p, u32 port,
 }
 
 /* default cs val */
-static const u8 ps3av_mode_cs_info[] = {
+u8 ps3av_mode_cs_info[] = {
         0x00, 0x09, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00
 };
+EXPORT_SYMBOL_GPL(ps3av_mode_cs_info);
 
 #define CS_44   0x00
 #define CS_48   0x02
@@ -677,7 +678,7 @@ void ps3av_cmd_set_audio_mode(struct ps3av_pkt_audio_mode *audio, u32 avport,
                               u32 ch, u32 fs, u32 word_bits, u32 format,
                               u32 source)
 {
-        int spdif_through, spdif_bitstream;
+        int spdif_through;
         int i;
 
         if (!(ch | fs | format | word_bits | source)) {
@@ -687,7 +688,6 @@ void ps3av_cmd_set_audio_mode(struct ps3av_pkt_audio_mode *audio, u32 avport,
                 format = PS3AV_CMD_AUDIO_FORMAT_PCM;
                 source = PS3AV_CMD_AUDIO_SOURCE_SERIAL;
         }
-        spdif_through = spdif_bitstream = 0;    /* XXX not supported */
 
         /* audio mode */
         memset(audio, 0, sizeof(*audio));
@@ -777,16 +777,17 @@ void ps3av_cmd_set_audio_mode(struct ps3av_pkt_audio_mode *audio, u32 avport,
                 break;
         }
 
+        /* non-audio bit */
+        spdif_through = audio->audio_cs_info[0] & 0x02;
+
         /* pass through setting */
         if (spdif_through &&
             (avport == PS3AV_CMD_AVPORT_SPDIF_0 ||
-             avport == PS3AV_CMD_AVPORT_SPDIF_1)) {
+             avport == PS3AV_CMD_AVPORT_SPDIF_1 ||
+             avport == PS3AV_CMD_AVPORT_HDMI_0 ||
+             avport == PS3AV_CMD_AVPORT_HDMI_1)) {
                 audio->audio_word_bits = PS3AV_CMD_AUDIO_WORD_BITS_16;
-                audio->audio_source = PS3AV_CMD_AUDIO_SOURCE_SPDIF;
-                if (spdif_bitstream) {
-                        audio->audio_format = PS3AV_CMD_AUDIO_FORMAT_BITSTREAM;
-                        audio->audio_cs_info[0] |= CS_BIT;
-                }
+                audio->audio_format = PS3AV_CMD_AUDIO_FORMAT_BITSTREAM;
         }
 }
 
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index f660ef3e5b29..814f49fde530 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -610,6 +610,14 @@ config RTC_DRV_RS5C313
         help
           If you say yes here you get support for the Ricoh RS5C313 RTC chips.
 
+config RTC_DRV_PARISC
+        tristate "PA-RISC firmware RTC support"
+        depends on PARISC
+        help
+          Say Y or M here to enable RTC support on PA-RISC systems using
+          firmware calls. If you do not know what you are doing, you should
+          just say Y.
+
 config RTC_DRV_PPC
        tristate "PowerPC machine dependent RTC support"
        depends on PPC
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index d05928b3ca94..d6a9ac7176ea 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -51,6 +51,7 @@ obj-$(CONFIG_RTC_DRV_PCF8563)	+= rtc-pcf8563.o
 obj-$(CONFIG_RTC_DRV_PCF8583)   += rtc-pcf8583.o
 obj-$(CONFIG_RTC_DRV_PL030)     += rtc-pl030.o
 obj-$(CONFIG_RTC_DRV_PL031)     += rtc-pl031.o
+obj-$(CONFIG_RTC_DRV_PARISC)    += rtc-parisc.o
 obj-$(CONFIG_RTC_DRV_PPC)       += rtc-ppc.o
 obj-$(CONFIG_RTC_DRV_R9701)     += rtc-r9701.o
 obj-$(CONFIG_RTC_DRV_RS5C313)   += rtc-rs5c313.o
diff --git a/drivers/rtc/rtc-at91rm9200.c b/drivers/rtc/rtc-at91rm9200.c
index 37082616482b..b5bf93706913 100644
--- a/drivers/rtc/rtc-at91rm9200.c
+++ b/drivers/rtc/rtc-at91rm9200.c
@@ -53,21 +53,21 @@ static void at91_rtc_decodetime(unsigned int timereg, unsigned int calreg,
         } while ((time != at91_sys_read(timereg)) ||
                         (date != at91_sys_read(calreg)));
 
-        tm->tm_sec  = BCD2BIN((time & AT91_RTC_SEC) >> 0);
-        tm->tm_min  = BCD2BIN((time & AT91_RTC_MIN) >> 8);
-        tm->tm_hour = BCD2BIN((time & AT91_RTC_HOUR) >> 16);
+        tm->tm_sec  = bcd2bin((time & AT91_RTC_SEC) >> 0);
+        tm->tm_min  = bcd2bin((time & AT91_RTC_MIN) >> 8);
+        tm->tm_hour = bcd2bin((time & AT91_RTC_HOUR) >> 16);
 
         /*
          * The Calendar Alarm register does not have a field for
          * the year - so these will return an invalid value.  When an
          * alarm is set, at91_alarm_year wille store the current year.
          */
-        tm->tm_year  = BCD2BIN(date & AT91_RTC_CENT) * 100;     /* century */
-        tm->tm_year += BCD2BIN((date & AT91_RTC_YEAR) >> 8);    /* year */
+        tm->tm_year  = bcd2bin(date & AT91_RTC_CENT) * 100;     /* century */
+        tm->tm_year += bcd2bin((date & AT91_RTC_YEAR) >> 8);    /* year */
 
-        tm->tm_wday = BCD2BIN((date & AT91_RTC_DAY) >> 21) - 1; /* day of the week [0-6], Sunday=0 */
-        tm->tm_mon  = BCD2BIN((date & AT91_RTC_MONTH) >> 16) - 1;
-        tm->tm_mday = BCD2BIN((date & AT91_RTC_DATE) >> 24);
+        tm->tm_wday = bcd2bin((date & AT91_RTC_DAY) >> 21) - 1; /* day of the week [0-6], Sunday=0 */
+        tm->tm_mon  = bcd2bin((date & AT91_RTC_MONTH) >> 16) - 1;
+        tm->tm_mday = bcd2bin((date & AT91_RTC_DATE) >> 24);
 }
 
 /*
@@ -106,16 +106,16 @@ static int at91_rtc_settime(struct device *dev, struct rtc_time *tm)
         at91_sys_write(AT91_RTC_IDR, AT91_RTC_ACKUPD);
 
         at91_sys_write(AT91_RTC_TIMR,
-                          BIN2BCD(tm->tm_sec) << 0
-                        | BIN2BCD(tm->tm_min) << 8
-                        | BIN2BCD(tm->tm_hour) << 16);
+                          bin2bcd(tm->tm_sec) << 0
+                        | bin2bcd(tm->tm_min) << 8
+                        | bin2bcd(tm->tm_hour) << 16);
 
         at91_sys_write(AT91_RTC_CALR,
-                          BIN2BCD((tm->tm_year + 1900) / 100)   /* century */
-                        | BIN2BCD(tm->tm_year % 100) << 8       /* year */
-                        | BIN2BCD(tm->tm_mon + 1) << 16         /* tm_mon starts at zero */
-                        | BIN2BCD(tm->tm_wday + 1) << 21        /* day of the week [0-6], Sunday=0 */
-                        | BIN2BCD(tm->tm_mday) << 24);
+                          bin2bcd((tm->tm_year + 1900) / 100)   /* century */
+                        | bin2bcd(tm->tm_year % 100) << 8       /* year */
+                        | bin2bcd(tm->tm_mon + 1) << 16         /* tm_mon starts at zero */
+                        | bin2bcd(tm->tm_wday + 1) << 21        /* day of the week [0-6], Sunday=0 */
+                        | bin2bcd(tm->tm_mday) << 24);
 
         /* Restart Time/Calendar */
         cr = at91_sys_read(AT91_RTC_CR);
@@ -162,13 +162,13 @@ static int at91_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 
         at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM);
         at91_sys_write(AT91_RTC_TIMALR,
-                  BIN2BCD(tm.tm_sec) << 0
-                | BIN2BCD(tm.tm_min) << 8
-                | BIN2BCD(tm.tm_hour) << 16
+                  bin2bcd(tm.tm_sec) << 0
+                | bin2bcd(tm.tm_min) << 8
+                | bin2bcd(tm.tm_hour) << 16
                 | AT91_RTC_HOUREN | AT91_RTC_MINEN | AT91_RTC_SECEN);
         at91_sys_write(AT91_RTC_CALALR,
-                  BIN2BCD(tm.tm_mon + 1) << 16          /* tm_mon starts at zero */
-                | BIN2BCD(tm.tm_mday) << 24
+                  bin2bcd(tm.tm_mon + 1) << 16          /* tm_mon starts at zero */
+                | bin2bcd(tm.tm_mday) << 24
                 | AT91_RTC_DATEEN | AT91_RTC_MTHEN);
 
         if (alrm->enabled) {
diff --git a/drivers/rtc/rtc-bq4802.c b/drivers/rtc/rtc-bq4802.c
index 189a018bdf34..d00a274df8fc 100644
--- a/drivers/rtc/rtc-bq4802.c
+++ b/drivers/rtc/rtc-bq4802.c
@@ -71,14 +71,14 @@ static int bq4802_read_time(struct device *dev, struct rtc_time *tm)
 
         spin_unlock_irqrestore(&p->lock, flags);
 
-        BCD_TO_BIN(tm->tm_sec);
-        BCD_TO_BIN(tm->tm_min);
-        BCD_TO_BIN(tm->tm_hour);
-        BCD_TO_BIN(tm->tm_mday);
-        BCD_TO_BIN(tm->tm_mon);
-        BCD_TO_BIN(tm->tm_year);
-        BCD_TO_BIN(tm->tm_wday);
-        BCD_TO_BIN(century);
+        tm->tm_sec = bcd2bin(tm->tm_sec);
+        tm->tm_min = bcd2bin(tm->tm_min);
+        tm->tm_hour = bcd2bin(tm->tm_hour);
+        tm->tm_mday = bcd2bin(tm->tm_mday);
+        tm->tm_mon = bcd2bin(tm->tm_mon);
+        tm->tm_year = bcd2bin(tm->tm_year);
+        tm->tm_wday = bcd2bin(tm->tm_wday);
+        century = bcd2bin(century);
 
         tm->tm_year += (century * 100);
         tm->tm_year -= 1900;
@@ -106,13 +106,13 @@ static int bq4802_set_time(struct device *dev, struct rtc_time *tm)
         min = tm->tm_min;
         sec = tm->tm_sec;
 
-        BIN_TO_BCD(sec);
-        BIN_TO_BCD(min);
-        BIN_TO_BCD(hrs);
-        BIN_TO_BCD(day);
-        BIN_TO_BCD(mon);
-        BIN_TO_BCD(yrs);
-        BIN_TO_BCD(century);
+        sec = bin2bcd(sec);
+        min = bin2bcd(min);
+        hrs = bin2bcd(hrs);
+        day = bin2bcd(day);
+        mon = bin2bcd(mon);
+        yrs = bin2bcd(yrs);
+        century = bin2bcd(century);
 
         spin_lock_irqsave(&p->lock, flags);
 
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 963ad0b6a4e9..5549231179a2 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -143,6 +143,43 @@ static inline int hpet_unregister_irq_handler(irq_handler_t handler)
 
 /*----------------------------------------------------------------*/
 
+#ifdef RTC_PORT
+
+/* Most newer x86 systems have two register banks, the first used
+ * for RTC and NVRAM and the second only for NVRAM.  Caller must
+ * own rtc_lock ... and we won't worry about access during NMI.
+ */
+#define can_bank2       true
+
+static inline unsigned char cmos_read_bank2(unsigned char addr)
+{
+        outb(addr, RTC_PORT(2));
+        return inb(RTC_PORT(3));
+}
+
+static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
+{
+        outb(addr, RTC_PORT(2));
+        outb(val, RTC_PORT(2));
+}
+
+#else
+
+#define can_bank2       false
+
+static inline unsigned char cmos_read_bank2(unsigned char addr)
+{
+        return 0;
+}
+
+static inline void cmos_write_bank2(unsigned char val, unsigned char addr)
+{
+}
+
+#endif
+
+/*----------------------------------------------------------------*/
+
 static int cmos_read_time(struct device *dev, struct rtc_time *t)
 {
         /* REVISIT:  if the clock has a "century" register, use
@@ -203,26 +240,26 @@ static int cmos_read_alarm(struct device *dev, struct rtc_wkalrm *t)
         /* REVISIT this assumes PC style usage:  always BCD */
 
         if (((unsigned)t->time.tm_sec) < 0x60)
-                t->time.tm_sec = BCD2BIN(t->time.tm_sec);
+                t->time.tm_sec = bcd2bin(t->time.tm_sec);
         else
                 t->time.tm_sec = -1;
         if (((unsigned)t->time.tm_min) < 0x60)
-                t->time.tm_min = BCD2BIN(t->time.tm_min);
+                t->time.tm_min = bcd2bin(t->time.tm_min);
         else
                 t->time.tm_min = -1;
         if (((unsigned)t->time.tm_hour) < 0x24)
-                t->time.tm_hour = BCD2BIN(t->time.tm_hour);
+                t->time.tm_hour = bcd2bin(t->time.tm_hour);
         else
                 t->time.tm_hour = -1;
 
         if (cmos->day_alrm) {
                 if (((unsigned)t->time.tm_mday) <= 0x31)
-                        t->time.tm_mday = BCD2BIN(t->time.tm_mday);
+                        t->time.tm_mday = bcd2bin(t->time.tm_mday);
                 else
                         t->time.tm_mday = -1;
                 if (cmos->mon_alrm) {
                         if (((unsigned)t->time.tm_mon) <= 0x12)
-                                t->time.tm_mon = BCD2BIN(t->time.tm_mon) - 1;
+                                t->time.tm_mon = bcd2bin(t->time.tm_mon) - 1;
                         else
                                 t->time.tm_mon = -1;
                 }
@@ -294,19 +331,19 @@ static int cmos_set_alarm(struct device *dev, struct rtc_wkalrm *t)
         /* Writing 0xff means "don't care" or "match all".  */
 
         mon = t->time.tm_mon + 1;
-        mon = (mon <= 12) ? BIN2BCD(mon) : 0xff;
+        mon = (mon <= 12) ? bin2bcd(mon) : 0xff;
 
         mday = t->time.tm_mday;
-        mday = (mday >= 1 && mday <= 31) ? BIN2BCD(mday) : 0xff;
+        mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
 
         hrs = t->time.tm_hour;
-        hrs = (hrs < 24) ? BIN2BCD(hrs) : 0xff;
+        hrs = (hrs < 24) ? bin2bcd(hrs) : 0xff;
 
         min = t->time.tm_min;
-        min = (min < 60) ? BIN2BCD(min) : 0xff;
+        min = (min < 60) ? bin2bcd(min) : 0xff;
 
         sec = t->time.tm_sec;
-        sec = (sec < 60) ? BIN2BCD(sec) : 0xff;
+        sec = (sec < 60) ? bin2bcd(sec) : 0xff;
 
         spin_lock_irq(&rtc_lock);
 
@@ -491,12 +528,21 @@ cmos_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
 
         if (unlikely(off >= attr->size))
                 return 0;
+        if (unlikely(off < 0))
+                return -EINVAL;
         if ((off + count) > attr->size)
                 count = attr->size - off;
 
+        off += NVRAM_OFFSET;
         spin_lock_irq(&rtc_lock);
-        for (retval = 0, off += NVRAM_OFFSET; count--; retval++, off++)
-                *buf++ = CMOS_READ(off);
+        for (retval = 0; count; count--, off++, retval++) {
+                if (off < 128)
+                        *buf++ = CMOS_READ(off);
+                else if (can_bank2)
+                        *buf++ = cmos_read_bank2(off);
+                else
+                        break;
+        }
         spin_unlock_irq(&rtc_lock);
 
         return retval;
@@ -512,6 +558,8 @@ cmos_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
         cmos = dev_get_drvdata(container_of(kobj, struct device, kobj));
         if (unlikely(off >= attr->size))
                 return -EFBIG;
+        if (unlikely(off < 0))
+                return -EINVAL;
         if ((off + count) > attr->size)
                 count = attr->size - off;
 
@@ -520,15 +568,20 @@ cmos_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
          * here.  If userspace is smart enough to know what fields of
          * NVRAM to update, updating checksums is also part of its job.
          */
+        off += NVRAM_OFFSET;
         spin_lock_irq(&rtc_lock);
-        for (retval = 0, off += NVRAM_OFFSET; count--; retval++, off++) {
+        for (retval = 0; count; count--, off++, retval++) {
                 /* don't trash RTC registers */
                 if (off == cmos->day_alrm
                                 || off == cmos->mon_alrm
                                 || off == cmos->century)
                         buf++;
-                else
+                else if (off < 128)
                         CMOS_WRITE(*buf++, off);
+                else if (can_bank2)
+                        cmos_write_bank2(*buf++, off);
+                else
+                        break;
         }
         spin_unlock_irq(&rtc_lock);
 
@@ -539,7 +592,6 @@ static struct bin_attribute nvram = {
         .attr = {
                 .name   = "nvram",
                 .mode   = S_IRUGO | S_IWUSR,
-                .owner  = THIS_MODULE,
         },
 
         .read   = cmos_nvram_read,
@@ -631,8 +683,8 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
 
         /* Heuristic to deduce NVRAM size ... do what the legacy NVRAM
          * driver did, but don't reject unknown configs.   Old hardware
-         * won't address 128 bytes, and for now we ignore the way newer
-         * chips can address 256 bytes (using two more i/o ports).
+         * won't address 128 bytes.  Newer chips have multiple banks,
+         * though they may not be listed in one I/O resource.
          */
 #if     defined(CONFIG_ATARI)
         address_space = 64;
@@ -642,6 +694,8 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
 #warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes.
         address_space = 128;
 #endif
+        if (can_bank2 && ports->end > (ports->start + 1))
+                address_space = 256;
 
         /* For ACPI systems extension info comes from the FADT.  On others,
          * board specific setup provides it as appropriate.  Systems where
@@ -740,7 +794,7 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
                 goto cleanup2;
         }
 
-        pr_info("%s: alarms up to one %s%s%s\n",
+        pr_info("%s: alarms up to one %s%s, %zd bytes nvram, %s irqs\n",
                         cmos_rtc.rtc->dev.bus_id,
                         is_valid_irq(rtc_irq)
                                 ?  (cmos_rtc.mon_alrm
@@ -749,6 +803,7 @@ cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq)
                                                 ? "month" : "day"))
                                 : "no",
                         cmos_rtc.century ? ", y3k" : "",
+                        nvram.size,
                         is_hpet_enabled() ? ", hpet irqs" : "");
 
         return 0;
diff --git a/drivers/rtc/rtc-ds1216.c b/drivers/rtc/rtc-ds1216.c
index 0b17770b032b..9a234a4ec06d 100644
--- a/drivers/rtc/rtc-ds1216.c
+++ b/drivers/rtc/rtc-ds1216.c
@@ -86,19 +86,19 @@ static int ds1216_rtc_read_time(struct device *dev, struct rtc_time *tm)
         ds1216_switch_ds_to_clock(priv->ioaddr);
         ds1216_read(priv->ioaddr, (u8 *)&regs);
 
-        tm->tm_sec = BCD2BIN(regs.sec);
-        tm->tm_min = BCD2BIN(regs.min);
+        tm->tm_sec = bcd2bin(regs.sec);
+        tm->tm_min = bcd2bin(regs.min);
         if (regs.hour & DS1216_HOUR_1224) {
                 /* AM/PM mode */
-                tm->tm_hour = BCD2BIN(regs.hour & 0x1f);
+                tm->tm_hour = bcd2bin(regs.hour & 0x1f);
                 if (regs.hour & DS1216_HOUR_AMPM)
                         tm->tm_hour += 12;
         } else
-                tm->tm_hour = BCD2BIN(regs.hour & 0x3f);
+                tm->tm_hour = bcd2bin(regs.hour & 0x3f);
         tm->tm_wday = (regs.wday & 7) - 1;
-        tm->tm_mday = BCD2BIN(regs.mday & 0x3f);
-        tm->tm_mon = BCD2BIN(regs.month & 0x1f);
-        tm->tm_year = BCD2BIN(regs.year);
+        tm->tm_mday = bcd2bin(regs.mday & 0x3f);
+        tm->tm_mon = bcd2bin(regs.month & 0x1f);
+        tm->tm_year = bcd2bin(regs.year);
         if (tm->tm_year < 70)
                 tm->tm_year += 100;
         return 0;
@@ -114,19 +114,19 @@ static int ds1216_rtc_set_time(struct device *dev, struct rtc_time *tm)
         ds1216_read(priv->ioaddr, (u8 *)&regs);
 
         regs.tsec = 0; /* clear 0.1 and 0.01 seconds */
-        regs.sec = BIN2BCD(tm->tm_sec);
-        regs.min = BIN2BCD(tm->tm_min);
+        regs.sec = bin2bcd(tm->tm_sec);
+        regs.min = bin2bcd(tm->tm_min);
         regs.hour &= DS1216_HOUR_1224;
         if (regs.hour && tm->tm_hour > 12) {
                 regs.hour |= DS1216_HOUR_AMPM;
                 tm->tm_hour -= 12;
         }
-        regs.hour |= BIN2BCD(tm->tm_hour);
+        regs.hour |= bin2bcd(tm->tm_hour);
         regs.wday &= ~7;
         regs.wday |= tm->tm_wday;
-        regs.mday = BIN2BCD(tm->tm_mday);
-        regs.month = BIN2BCD(tm->tm_mon);
-        regs.year = BIN2BCD(tm->tm_year % 100);
+        regs.mday = bin2bcd(tm->tm_mday);
+        regs.month = bin2bcd(tm->tm_mon);
+        regs.year = bin2bcd(tm->tm_year % 100);
 
         ds1216_switch_ds_to_clock(priv->ioaddr);
         ds1216_write(priv->ioaddr, (u8 *)&regs);
diff --git a/drivers/rtc/rtc-ds1302.c b/drivers/rtc/rtc-ds1302.c
index b9397818f73a..184556620778 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -40,7 +40,7 @@
 #define RTC_SCLK        0x0400
 
 #ifdef CONFIG_SH_SECUREEDGE5410
-#include <asm/snapgear.h>
+#include <mach/snapgear.h>
 #define set_dp(x)       SECUREEDGE_WRITE_IOPORT(x, 0x1c00)
 #define get_dp()        SECUREEDGE_READ_IOPORT()
 #else
@@ -107,13 +107,13 @@ static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
 
         spin_lock_irq(&rtc->lock);
 
-        tm->tm_sec      = BCD2BIN(ds1302_readbyte(RTC_ADDR_SEC));
-        tm->tm_min      = BCD2BIN(ds1302_readbyte(RTC_ADDR_MIN));
-        tm->tm_hour     = BCD2BIN(ds1302_readbyte(RTC_ADDR_HOUR));
-        tm->tm_wday     = BCD2BIN(ds1302_readbyte(RTC_ADDR_DAY));
-        tm->tm_mday     = BCD2BIN(ds1302_readbyte(RTC_ADDR_DATE));
-        tm->tm_mon      = BCD2BIN(ds1302_readbyte(RTC_ADDR_MON)) - 1;
-        tm->tm_year     = BCD2BIN(ds1302_readbyte(RTC_ADDR_YEAR));
+        tm->tm_sec      = bcd2bin(ds1302_readbyte(RTC_ADDR_SEC));
+        tm->tm_min      = bcd2bin(ds1302_readbyte(RTC_ADDR_MIN));
+        tm->tm_hour     = bcd2bin(ds1302_readbyte(RTC_ADDR_HOUR));
+        tm->tm_wday     = bcd2bin(ds1302_readbyte(RTC_ADDR_DAY));
+        tm->tm_mday     = bcd2bin(ds1302_readbyte(RTC_ADDR_DATE));
+        tm->tm_mon      = bcd2bin(ds1302_readbyte(RTC_ADDR_MON)) - 1;
+        tm->tm_year     = bcd2bin(ds1302_readbyte(RTC_ADDR_YEAR));
 
         if (tm->tm_year < 70)
                 tm->tm_year += 100;
@@ -141,13 +141,13 @@ static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *tm)
         /* Stop RTC */
         ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) | 0x80);
 
-        ds1302_writebyte(RTC_ADDR_SEC, BIN2BCD(tm->tm_sec));
-        ds1302_writebyte(RTC_ADDR_MIN, BIN2BCD(tm->tm_min));
-        ds1302_writebyte(RTC_ADDR_HOUR, BIN2BCD(tm->tm_hour));
-        ds1302_writebyte(RTC_ADDR_DAY, BIN2BCD(tm->tm_wday));
-        ds1302_writebyte(RTC_ADDR_DATE, BIN2BCD(tm->tm_mday));
-        ds1302_writebyte(RTC_ADDR_MON, BIN2BCD(tm->tm_mon + 1));
-        ds1302_writebyte(RTC_ADDR_YEAR, BIN2BCD(tm->tm_year % 100));
+        ds1302_writebyte(RTC_ADDR_SEC, bin2bcd(tm->tm_sec));
+        ds1302_writebyte(RTC_ADDR_MIN, bin2bcd(tm->tm_min));
+        ds1302_writebyte(RTC_ADDR_HOUR, bin2bcd(tm->tm_hour));
+        ds1302_writebyte(RTC_ADDR_DAY, bin2bcd(tm->tm_wday));
+        ds1302_writebyte(RTC_ADDR_DATE, bin2bcd(tm->tm_mday));
+        ds1302_writebyte(RTC_ADDR_MON, bin2bcd(tm->tm_mon + 1));
+        ds1302_writebyte(RTC_ADDR_YEAR, bin2bcd(tm->tm_year % 100));
 
         /* Start RTC */
         ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) & ~0x80);
diff --git a/drivers/rtc/rtc-ds1305.c b/drivers/rtc/rtc-ds1305.c
index b91d02a3ace9..fc372df6534b 100644
--- a/drivers/rtc/rtc-ds1305.c
+++ b/drivers/rtc/rtc-ds1305.c
@@ -114,10 +114,10 @@ static unsigned bcd2hour(u8 bcd)
                         hour = 12;
                         bcd &= ~DS1305_HR_PM;
                 }
-                hour += BCD2BIN(bcd);
+                hour += bcd2bin(bcd);
                 return hour - 1;
         }
-        return BCD2BIN(bcd);
+        return bcd2bin(bcd);
 }
 
 static u8 hour2bcd(bool hr12, int hour)
@@ -125,11 +125,11 @@ static u8 hour2bcd(bool hr12, int hour)
         if (hr12) {
                 hour++;
                 if (hour <= 12)
-                        return DS1305_HR_12 | BIN2BCD(hour);
+                        return DS1305_HR_12 | bin2bcd(hour);
                 hour -= 12;
-                return DS1305_HR_12 | DS1305_HR_PM | BIN2BCD(hour);
+                return DS1305_HR_12 | DS1305_HR_PM | bin2bcd(hour);
         }
-        return BIN2BCD(hour);
+        return bin2bcd(hour);
 }
 
 /*----------------------------------------------------------------------*/
@@ -206,13 +206,13 @@ static int ds1305_get_time(struct device *dev, struct rtc_time *time)
                 buf[4], buf[5], buf[6]);
 
         /* Decode the registers */
-        time->tm_sec = BCD2BIN(buf[DS1305_SEC]);
-        time->tm_min = BCD2BIN(buf[DS1305_MIN]);
+        time->tm_sec = bcd2bin(buf[DS1305_SEC]);
+        time->tm_min = bcd2bin(buf[DS1305_MIN]);
         time->tm_hour = bcd2hour(buf[DS1305_HOUR]);
         time->tm_wday = buf[DS1305_WDAY] - 1;
-        time->tm_mday = BCD2BIN(buf[DS1305_MDAY]);
-        time->tm_mon = BCD2BIN(buf[DS1305_MON]) - 1;
-        time->tm_year = BCD2BIN(buf[DS1305_YEAR]) + 100;
+        time->tm_mday = bcd2bin(buf[DS1305_MDAY]);
+        time->tm_mon = bcd2bin(buf[DS1305_MON]) - 1;
+        time->tm_year = bcd2bin(buf[DS1305_YEAR]) + 100;
 
         dev_vdbg(dev, "%s secs=%d, mins=%d, "
                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
@@ -239,13 +239,13 @@ static int ds1305_set_time(struct device *dev, struct rtc_time *time)
         /* Write registers starting at the first time/date address. */
         *bp++ = DS1305_WRITE | DS1305_SEC;
 
-        *bp++ = BIN2BCD(time->tm_sec);
-        *bp++ = BIN2BCD(time->tm_min);
+        *bp++ = bin2bcd(time->tm_sec);
+        *bp++ = bin2bcd(time->tm_min);
         *bp++ = hour2bcd(ds1305->hr12, time->tm_hour);
         *bp++ = (time->tm_wday < 7) ? (time->tm_wday + 1) : 1;
-        *bp++ = BIN2BCD(time->tm_mday);
-        *bp++ = BIN2BCD(time->tm_mon + 1);
-        *bp++ = BIN2BCD(time->tm_year - 100);
+        *bp++ = bin2bcd(time->tm_mday);
+        *bp++ = bin2bcd(time->tm_mon + 1);
+        *bp++ = bin2bcd(time->tm_year - 100);
 
         dev_dbg(dev, "%s: %02x %02x %02x, %02x %02x %02x %02x\n",
                 "write", buf[1], buf[2], buf[3],
@@ -329,8 +329,8 @@ static int ds1305_get_alarm(struct device *dev, struct rtc_wkalrm *alm)
          * fill in the rest ... and also handle rollover to tomorrow when
          * that's needed.
          */
-        alm->time.tm_sec = BCD2BIN(buf[DS1305_SEC]);
-        alm->time.tm_min = BCD2BIN(buf[DS1305_MIN]);
+        alm->time.tm_sec = bcd2bin(buf[DS1305_SEC]);
+        alm->time.tm_min = bcd2bin(buf[DS1305_MIN]);
         alm->time.tm_hour = bcd2hour(buf[DS1305_HOUR]);
         alm->time.tm_mday = -1;
         alm->time.tm_mon = -1;
@@ -387,8 +387,8 @@ static int ds1305_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 
         /* write alarm */
         buf[0] = DS1305_WRITE | DS1305_ALM0(DS1305_SEC);
-        buf[1 + DS1305_SEC] = BIN2BCD(alm->time.tm_sec);
-        buf[1 + DS1305_MIN] = BIN2BCD(alm->time.tm_min);
+        buf[1 + DS1305_SEC] = bin2bcd(alm->time.tm_sec);
+        buf[1 + DS1305_MIN] = bin2bcd(alm->time.tm_min);
         buf[1 + DS1305_HOUR] = hour2bcd(ds1305->hr12, alm->time.tm_hour);
         buf[1 + DS1305_WDAY] = DS1305_ALM_DISABLE;
 
@@ -606,7 +606,6 @@ ds1305_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
 static struct bin_attribute nvram = {
         .attr.name      = "nvram",
         .attr.mode      = S_IRUGO | S_IWUSR,
-        .attr.owner     = THIS_MODULE,
         .read           = ds1305_nvram_read,
         .write          = ds1305_nvram_write,
         .size           = DS1305_NVRAM_LEN,
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index 4fcf0734a6ef..162330b9d1dc 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -222,17 +222,17 @@ static int ds1307_get_time(struct device *dev, struct rtc_time *t)
                         ds1307->regs[4], ds1307->regs[5],
                         ds1307->regs[6]);
 
-        t->tm_sec = BCD2BIN(ds1307->regs[DS1307_REG_SECS] & 0x7f);
-        t->tm_min = BCD2BIN(ds1307->regs[DS1307_REG_MIN] & 0x7f);
+        t->tm_sec = bcd2bin(ds1307->regs[DS1307_REG_SECS] & 0x7f);
+        t->tm_min = bcd2bin(ds1307->regs[DS1307_REG_MIN] & 0x7f);
         tmp = ds1307->regs[DS1307_REG_HOUR] & 0x3f;
-        t->tm_hour = BCD2BIN(tmp);
-        t->tm_wday = BCD2BIN(ds1307->regs[DS1307_REG_WDAY] & 0x07) - 1;
-        t->tm_mday = BCD2BIN(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
+        t->tm_hour = bcd2bin(tmp);
+        t->tm_wday = bcd2bin(ds1307->regs[DS1307_REG_WDAY] & 0x07) - 1;
+        t->tm_mday = bcd2bin(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
         tmp = ds1307->regs[DS1307_REG_MONTH] & 0x1f;
-        t->tm_mon = BCD2BIN(tmp) - 1;
+        t->tm_mon = bcd2bin(tmp) - 1;
 
         /* assume 20YY not 19YY, and ignore DS1337_BIT_CENTURY */
-        t->tm_year = BCD2BIN(ds1307->regs[DS1307_REG_YEAR]) + 100;
+        t->tm_year = bcd2bin(ds1307->regs[DS1307_REG_YEAR]) + 100;
 
         dev_dbg(dev, "%s secs=%d, mins=%d, "
                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
@@ -258,16 +258,16 @@ static int ds1307_set_time(struct device *dev, struct rtc_time *t)
                 t->tm_mon, t->tm_year, t->tm_wday);
 
         *buf++ = 0;             /* first register addr */
-        buf[DS1307_REG_SECS] = BIN2BCD(t->tm_sec);
-        buf[DS1307_REG_MIN] = BIN2BCD(t->tm_min);
-        buf[DS1307_REG_HOUR] = BIN2BCD(t->tm_hour);
-        buf[DS1307_REG_WDAY] = BIN2BCD(t->tm_wday + 1);
-        buf[DS1307_REG_MDAY] = BIN2BCD(t->tm_mday);
-        buf[DS1307_REG_MONTH] = BIN2BCD(t->tm_mon + 1);
+        buf[DS1307_REG_SECS] = bin2bcd(t->tm_sec);
+        buf[DS1307_REG_MIN] = bin2bcd(t->tm_min);
+        buf[DS1307_REG_HOUR] = bin2bcd(t->tm_hour);
+        buf[DS1307_REG_WDAY] = bin2bcd(t->tm_wday + 1);
+        buf[DS1307_REG_MDAY] = bin2bcd(t->tm_mday);
+        buf[DS1307_REG_MONTH] = bin2bcd(t->tm_mon + 1);
 
         /* assume 20YY not 19YY */
         tmp = t->tm_year - 100;
-        buf[DS1307_REG_YEAR] = BIN2BCD(tmp);
+        buf[DS1307_REG_YEAR] = bin2bcd(tmp);
 
         switch (ds1307->type) {
         case ds_1337:
@@ -551,7 +551,6 @@ static struct bin_attribute nvram = {
         .attr = {
                 .name   = "nvram",
                 .mode   = S_IRUGO | S_IWUSR,
-                .owner  = THIS_MODULE,
         },
 
         .read   = ds1307_nvram_read,
@@ -709,18 +708,18 @@ read_rtc:
         }
 
         tmp = ds1307->regs[DS1307_REG_SECS];
-        tmp = BCD2BIN(tmp & 0x7f);
+        tmp = bcd2bin(tmp & 0x7f);
         if (tmp > 60)
                 goto exit_bad;
-        tmp = BCD2BIN(ds1307->regs[DS1307_REG_MIN] & 0x7f);
+        tmp = bcd2bin(ds1307->regs[DS1307_REG_MIN] & 0x7f);
         if (tmp > 60)
                 goto exit_bad;
 
-        tmp = BCD2BIN(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
+        tmp = bcd2bin(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
         if (tmp == 0 || tmp > 31)
                 goto exit_bad;
 
-        tmp = BCD2BIN(ds1307->regs[DS1307_REG_MONTH] & 0x1f);
+        tmp = bcd2bin(ds1307->regs[DS1307_REG_MONTH] & 0x1f);
         if (tmp == 0 || tmp > 12)
                 goto exit_bad;
 
@@ -739,14 +738,14 @@ read_rtc:
                 /* Be sure we're in 24 hour mode.  Multi-master systems
                  * take note...
                  */
-                tmp = BCD2BIN(tmp & 0x1f);
+                tmp = bcd2bin(tmp & 0x1f);
                 if (tmp == 12)
                         tmp = 0;
                 if (ds1307->regs[DS1307_REG_HOUR] & DS1307_BIT_PM)
                         tmp += 12;
                 i2c_smbus_write_byte_data(client,
                                 DS1307_REG_HOUR,
-                                BIN2BCD(tmp));
+                                bin2bcd(tmp));
         }
 
         ds1307->rtc = rtc_device_register(client->name, &client->dev,
diff --git a/drivers/rtc/rtc-ds1511.c b/drivers/rtc/rtc-ds1511.c
index 86981d34fbb6..25caada78398 100644
--- a/drivers/rtc/rtc-ds1511.c
+++ b/drivers/rtc/rtc-ds1511.c
@@ -153,8 +153,8 @@ ds1511_wdog_set(unsigned long deciseconds)
         /*
          * set the wdog values in the wdog registers
          */
-        rtc_write(BIN2BCD(deciseconds % 100), DS1511_WD_MSEC);
-        rtc_write(BIN2BCD(deciseconds / 100), DS1511_WD_SEC);
+        rtc_write(bin2bcd(deciseconds % 100), DS1511_WD_MSEC);
+        rtc_write(bin2bcd(deciseconds / 100), DS1511_WD_SEC);
         /*
          * set wdog enable and wdog 'steering' bit to issue a reset
          */
@@ -220,13 +220,13 @@ static int ds1511_rtc_set_time(struct device *dev, struct rtc_time *rtc_tm)
         /*
          * each register is a different number of valid bits
          */
-        sec = BIN2BCD(sec) & 0x7f;
-        min = BIN2BCD(min) & 0x7f;
-        hrs = BIN2BCD(hrs) & 0x3f;
-        day = BIN2BCD(day) & 0x3f;
-        mon = BIN2BCD(mon) & 0x1f;
-        yrs = BIN2BCD(yrs) & 0xff;
-        cen = BIN2BCD(cen) & 0xff;
+        sec = bin2bcd(sec) & 0x7f;
+        min = bin2bcd(min) & 0x7f;
+        hrs = bin2bcd(hrs) & 0x3f;
+        day = bin2bcd(day) & 0x3f;
+        mon = bin2bcd(mon) & 0x1f;
+        yrs = bin2bcd(yrs) & 0xff;
+        cen = bin2bcd(cen) & 0xff;
 
         spin_lock_irqsave(&ds1511_lock, flags);
         rtc_disable_update();
@@ -264,14 +264,14 @@ static int ds1511_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm)
         rtc_enable_update();
         spin_unlock_irqrestore(&ds1511_lock, flags);
 
-        rtc_tm->tm_sec = BCD2BIN(rtc_tm->tm_sec);
-        rtc_tm->tm_min = BCD2BIN(rtc_tm->tm_min);
-        rtc_tm->tm_hour = BCD2BIN(rtc_tm->tm_hour);
-        rtc_tm->tm_mday = BCD2BIN(rtc_tm->tm_mday);
-        rtc_tm->tm_wday = BCD2BIN(rtc_tm->tm_wday);
-        rtc_tm->tm_mon = BCD2BIN(rtc_tm->tm_mon);
-        rtc_tm->tm_year = BCD2BIN(rtc_tm->tm_year);
-        century = BCD2BIN(century) * 100;
+        rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
+        rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
+        rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
+        rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
+        rtc_tm->tm_wday = bcd2bin(rtc_tm->tm_wday);
+        rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
+        rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
+        century = bcd2bin(century) * 100;
 
         /*
          * Account for differences between how the RTC uses the values
@@ -304,16 +304,16 @@ ds1511_rtc_update_alarm(struct rtc_plat_data *pdata)
 
         spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
         rtc_write(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_mday) & 0x3f,
+               0x80 : bin2bcd(pdata->alrm_mday) & 0x3f,
                RTC_ALARM_DATE);
         rtc_write(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_hour) & 0x3f,
+               0x80 : bin2bcd(pdata->alrm_hour) & 0x3f,
                RTC_ALARM_HOUR);
         rtc_write(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_min) & 0x7f,
+               0x80 : bin2bcd(pdata->alrm_min) & 0x7f,
                RTC_ALARM_MIN);
         rtc_write(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_sec) & 0x7f,
+               0x80 : bin2bcd(pdata->alrm_sec) & 0x7f,
                RTC_ALARM_SEC);
         rtc_write(rtc_read(RTC_CMD) | (pdata->irqen ? RTC_TIE : 0), RTC_CMD);
         rtc_read(RTC_CMD1);     /* clear interrupts */
@@ -481,7 +481,6 @@ static struct bin_attribute ds1511_nvram_attr = {
         .attr = {
                 .name = "nvram",
                 .mode = S_IRUGO | S_IWUGO,
-                .owner = THIS_MODULE,
         },
         .size = DS1511_RAM_MAX,
         .read = ds1511_nvram_read,
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index 4ef59285b489..b9475cd20210 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -78,17 +78,17 @@ static int ds1553_rtc_set_time(struct device *dev, struct rtc_time *tm)
         void __iomem *ioaddr = pdata->ioaddr;
         u8 century;
 
-        century = BIN2BCD((tm->tm_year + 1900) / 100);
+        century = bin2bcd((tm->tm_year + 1900) / 100);
 
         writeb(RTC_WRITE, pdata->ioaddr + RTC_CONTROL);
 
-        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
-        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
-        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
-        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
-        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
-        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
-        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+        writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
 
         /* RTC_CENTURY and RTC_CONTROL share same register */
         writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY);
@@ -118,14 +118,14 @@ static int ds1553_rtc_read_time(struct device *dev, struct rtc_time *tm)
         year = readb(ioaddr + RTC_YEAR);
         century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
         writeb(0, ioaddr + RTC_CONTROL);
-        tm->tm_sec = BCD2BIN(second);
-        tm->tm_min = BCD2BIN(minute);
-        tm->tm_hour = BCD2BIN(hour);
-        tm->tm_mday = BCD2BIN(day);
-        tm->tm_wday = BCD2BIN(week);
-        tm->tm_mon = BCD2BIN(month) - 1;
+        tm->tm_sec = bcd2bin(second);
+        tm->tm_min = bcd2bin(minute);
+        tm->tm_hour = bcd2bin(hour);
+        tm->tm_mday = bcd2bin(day);
+        tm->tm_wday = bcd2bin(week);
+        tm->tm_mon = bcd2bin(month) - 1;
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+        tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;
 
         if (rtc_valid_tm(tm) < 0) {
                 dev_err(dev, "retrieved date/time is not valid.\n");
@@ -141,16 +141,16 @@ static void ds1553_rtc_update_alarm(struct rtc_plat_data *pdata)
 
         spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
         writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_mday),
+               0x80 : bin2bcd(pdata->alrm_mday),
                ioaddr + RTC_DATE_ALARM);
         writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_hour),
+               0x80 : bin2bcd(pdata->alrm_hour),
                ioaddr + RTC_HOURS_ALARM);
         writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_min),
+               0x80 : bin2bcd(pdata->alrm_min),
                ioaddr + RTC_MINUTES_ALARM);
         writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_sec),
+               0x80 : bin2bcd(pdata->alrm_sec),
                ioaddr + RTC_SECONDS_ALARM);
         writeb(pdata->irqen ? RTC_INTS_AE : 0, ioaddr + RTC_INTERRUPTS);
         readb(ioaddr + RTC_FLAGS);      /* clear interrupts */
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index 24d35ede2dbf..8bc8501bffc8 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -66,17 +66,17 @@ static int ds1742_rtc_set_time(struct device *dev, struct rtc_time *tm)
         void __iomem *ioaddr = pdata->ioaddr_rtc;
         u8 century;
 
-        century = BIN2BCD((tm->tm_year + 1900) / 100);
+        century = bin2bcd((tm->tm_year + 1900) / 100);
 
         writeb(RTC_WRITE, ioaddr + RTC_CONTROL);
 
-        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
-        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
-        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
-        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
-        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
-        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
-        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+        writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
 
         /* RTC_CENTURY and RTC_CONTROL share same register */
         writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY);
@@ -106,14 +106,14 @@ static int ds1742_rtc_read_time(struct device *dev, struct rtc_time *tm)
         year = readb(ioaddr + RTC_YEAR);
         century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
         writeb(0, ioaddr + RTC_CONTROL);
-        tm->tm_sec = BCD2BIN(second);
-        tm->tm_min = BCD2BIN(minute);
-        tm->tm_hour = BCD2BIN(hour);
-        tm->tm_mday = BCD2BIN(day);
-        tm->tm_wday = BCD2BIN(week);
-        tm->tm_mon = BCD2BIN(month) - 1;
+        tm->tm_sec = bcd2bin(second);
+        tm->tm_min = bcd2bin(minute);
+        tm->tm_hour = bcd2bin(hour);
+        tm->tm_mday = bcd2bin(day);
+        tm->tm_wday = bcd2bin(week);
+        tm->tm_mon = bcd2bin(month) - 1;
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+        tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;
 
         if (rtc_valid_tm(tm) < 0) {
                 dev_err(dev, "retrieved date/time is not valid.\n");
diff --git a/drivers/rtc/rtc-fm3130.c b/drivers/rtc/rtc-fm3130.c
index abfdfcbaa059..3a7be11cc6b9 100644
--- a/drivers/rtc/rtc-fm3130.c
+++ b/drivers/rtc/rtc-fm3130.c
@@ -131,17 +131,17 @@ static int fm3130_get_time(struct device *dev, struct rtc_time *t)
                         fm3130->regs[0xc], fm3130->regs[0xd],
                         fm3130->regs[0xe]);
 
-        t->tm_sec = BCD2BIN(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
-        t->tm_min = BCD2BIN(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
+        t->tm_sec = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
+        t->tm_min = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
         tmp = fm3130->regs[FM3130_RTC_HOURS] & 0x3f;
-        t->tm_hour = BCD2BIN(tmp);
-        t->tm_wday = BCD2BIN(fm3130->regs[FM3130_RTC_DAY] & 0x07) - 1;
-        t->tm_mday = BCD2BIN(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
+        t->tm_hour = bcd2bin(tmp);
+        t->tm_wday = bcd2bin(fm3130->regs[FM3130_RTC_DAY] & 0x07) - 1;
+        t->tm_mday = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
         tmp = fm3130->regs[FM3130_RTC_MONTHS] & 0x1f;
-        t->tm_mon = BCD2BIN(tmp) - 1;
+        t->tm_mon = bcd2bin(tmp) - 1;
 
         /* assume 20YY not 19YY, and ignore CF bit */
-        t->tm_year = BCD2BIN(fm3130->regs[FM3130_RTC_YEARS]) + 100;
+        t->tm_year = bcd2bin(fm3130->regs[FM3130_RTC_YEARS]) + 100;
 
         dev_dbg(dev, "%s secs=%d, mins=%d, "
                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
@@ -167,16 +167,16 @@ static int fm3130_set_time(struct device *dev, struct rtc_time *t)
                 t->tm_mon, t->tm_year, t->tm_wday);
 
         /* first register addr */
-        buf[FM3130_RTC_SECONDS] = BIN2BCD(t->tm_sec);
-        buf[FM3130_RTC_MINUTES] = BIN2BCD(t->tm_min);
-        buf[FM3130_RTC_HOURS] = BIN2BCD(t->tm_hour);
-        buf[FM3130_RTC_DAY] = BIN2BCD(t->tm_wday + 1);
-        buf[FM3130_RTC_DATE] = BIN2BCD(t->tm_mday);
-        buf[FM3130_RTC_MONTHS] = BIN2BCD(t->tm_mon + 1);
+        buf[FM3130_RTC_SECONDS] = bin2bcd(t->tm_sec);
+        buf[FM3130_RTC_MINUTES] = bin2bcd(t->tm_min);
+        buf[FM3130_RTC_HOURS] = bin2bcd(t->tm_hour);
+        buf[FM3130_RTC_DAY] = bin2bcd(t->tm_wday + 1);
+        buf[FM3130_RTC_DATE] = bin2bcd(t->tm_mday);
+        buf[FM3130_RTC_MONTHS] = bin2bcd(t->tm_mon + 1);
 
         /* assume 20YY not 19YY */
         tmp = t->tm_year - 100;
-        buf[FM3130_RTC_YEARS] = BIN2BCD(tmp);
+        buf[FM3130_RTC_YEARS] = bin2bcd(tmp);
 
         dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x"
                 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
@@ -222,11 +222,11 @@ static int fm3130_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
                         fm3130->regs[FM3130_ALARM_MONTHS]);
 
 
-        tm->tm_sec      = BCD2BIN(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
-        tm->tm_min      = BCD2BIN(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
-        tm->tm_hour     = BCD2BIN(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
-        tm->tm_mday     = BCD2BIN(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
-        tm->tm_mon      = BCD2BIN(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
+        tm->tm_sec      = bcd2bin(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
+        tm->tm_min      = bcd2bin(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
+        tm->tm_hour     = bcd2bin(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
+        tm->tm_mday     = bcd2bin(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
+        tm->tm_mon      = bcd2bin(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
         if (tm->tm_mon > 0)
                 tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
         dev_dbg(dev, "%s secs=%d, mins=%d, "
@@ -252,23 +252,23 @@ static int fm3130_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 
         if (tm->tm_sec != -1)
                 fm3130->regs[FM3130_ALARM_SECONDS] =
-                        BIN2BCD(tm->tm_sec) | 0x80;
+                        bin2bcd(tm->tm_sec) | 0x80;
 
         if (tm->tm_min != -1)
                 fm3130->regs[FM3130_ALARM_MINUTES] =
-                        BIN2BCD(tm->tm_min) | 0x80;
+                        bin2bcd(tm->tm_min) | 0x80;
 
         if (tm->tm_hour != -1)
                 fm3130->regs[FM3130_ALARM_HOURS] =
-                        BIN2BCD(tm->tm_hour) | 0x80;
+                        bin2bcd(tm->tm_hour) | 0x80;
 
         if (tm->tm_mday != -1)
                 fm3130->regs[FM3130_ALARM_DATE] =
-                        BIN2BCD(tm->tm_mday) | 0x80;
+                        bin2bcd(tm->tm_mday) | 0x80;
 
         if (tm->tm_mon != -1)
                 fm3130->regs[FM3130_ALARM_MONTHS] =
-                        BIN2BCD(tm->tm_mon + 1) | 0x80;
+                        bin2bcd(tm->tm_mon + 1) | 0x80;
 
         dev_dbg(dev, "alarm write %02x %02x %02x %02x %02x\n",
                         fm3130->regs[FM3130_ALARM_SECONDS],
@@ -414,18 +414,18 @@ static int __devinit fm3130_probe(struct i2c_client *client,
         /* TODO */
         /* TODO need to sanity check alarm */
         tmp = fm3130->regs[FM3130_RTC_SECONDS];
-        tmp = BCD2BIN(tmp & 0x7f);
+        tmp = bcd2bin(tmp & 0x7f);
         if (tmp > 60)
                 goto exit_bad;
-        tmp = BCD2BIN(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
         if (tmp > 60)
                 goto exit_bad;
 
-        tmp = BCD2BIN(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
         if (tmp == 0 || tmp > 31)
                 goto exit_bad;
 
-        tmp = BCD2BIN(fm3130->regs[FM3130_RTC_MONTHS] & 0x1f);
+        tmp = bcd2bin(fm3130->regs[FM3130_RTC_MONTHS] & 0x1f);
         if (tmp == 0 || tmp > 12)
                 goto exit_bad;
 
diff --git a/drivers/rtc/rtc-isl1208.c b/drivers/rtc/rtc-isl1208.c
index a81adab6e515..2cd77ab8fc66 100644
--- a/drivers/rtc/rtc-isl1208.c
+++ b/drivers/rtc/rtc-isl1208.c
@@ -259,26 +259,26 @@ isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
                 return sr;
         }
 
-        tm->tm_sec = BCD2BIN(regs[ISL1208_REG_SC]);
-        tm->tm_min = BCD2BIN(regs[ISL1208_REG_MN]);
+        tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]);
+        tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]);
 
         /* HR field has a more complex interpretation */
         {
                 const u8 _hr = regs[ISL1208_REG_HR];
                 if (_hr & ISL1208_REG_HR_MIL)   /* 24h format */
-                        tm->tm_hour = BCD2BIN(_hr & 0x3f);
+                        tm->tm_hour = bcd2bin(_hr & 0x3f);
                 else {
                         /* 12h format */
-                        tm->tm_hour = BCD2BIN(_hr & 0x1f);
+                        tm->tm_hour = bcd2bin(_hr & 0x1f);
                         if (_hr & ISL1208_REG_HR_PM)    /* PM flag set */
                                 tm->tm_hour += 12;
                 }
         }
 
-        tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DT]);
-        tm->tm_mon = BCD2BIN(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */
-        tm->tm_year = BCD2BIN(regs[ISL1208_REG_YR]) + 100;
-        tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DW]);
+        tm->tm_mday = bcd2bin(regs[ISL1208_REG_DT]);
+        tm->tm_mon = bcd2bin(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */
+        tm->tm_year = bcd2bin(regs[ISL1208_REG_YR]) + 100;
+        tm->tm_wday = bcd2bin(regs[ISL1208_REG_DW]);
 
         return 0;
 }
@@ -305,13 +305,13 @@ isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
         }
 
         /* MSB of each alarm register is an enable bit */
-        tm->tm_sec = BCD2BIN(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
-        tm->tm_min = BCD2BIN(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
-        tm->tm_hour = BCD2BIN(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
-        tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
+        tm->tm_sec = bcd2bin(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
+        tm->tm_min = bcd2bin(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
+        tm->tm_hour = bcd2bin(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
+        tm->tm_mday = bcd2bin(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
         tm->tm_mon =
-                BCD2BIN(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
-        tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
+                bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
+        tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
 
         return 0;
 }
@@ -328,15 +328,15 @@ isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
         int sr;
         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 
-        regs[ISL1208_REG_SC] = BIN2BCD(tm->tm_sec);
-        regs[ISL1208_REG_MN] = BIN2BCD(tm->tm_min);
-        regs[ISL1208_REG_HR] = BIN2BCD(tm->tm_hour) | ISL1208_REG_HR_MIL;
+        regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec);
+        regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min);
+        regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL;
 
-        regs[ISL1208_REG_DT] = BIN2BCD(tm->tm_mday);
-        regs[ISL1208_REG_MO] = BIN2BCD(tm->tm_mon + 1);
-        regs[ISL1208_REG_YR] = BIN2BCD(tm->tm_year - 100);
+        regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday);
+        regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1);
+        regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100);
 
-        regs[ISL1208_REG_DW] = BIN2BCD(tm->tm_wday & 7);
+        regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7);
 
         sr = isl1208_i2c_get_sr(client);
         if (sr < 0) {
diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
index 470fb2d29545..893f7dece239 100644
--- a/drivers/rtc/rtc-m41t80.c
+++ b/drivers/rtc/rtc-m41t80.c
@@ -110,15 +110,15 @@ static int m41t80_get_datetime(struct i2c_client *client,
                 return -EIO;
         }
 
-        tm->tm_sec = BCD2BIN(buf[M41T80_REG_SEC] & 0x7f);
-        tm->tm_min = BCD2BIN(buf[M41T80_REG_MIN] & 0x7f);
-        tm->tm_hour = BCD2BIN(buf[M41T80_REG_HOUR] & 0x3f);
-        tm->tm_mday = BCD2BIN(buf[M41T80_REG_DAY] & 0x3f);
+        tm->tm_sec = bcd2bin(buf[M41T80_REG_SEC] & 0x7f);
+        tm->tm_min = bcd2bin(buf[M41T80_REG_MIN] & 0x7f);
+        tm->tm_hour = bcd2bin(buf[M41T80_REG_HOUR] & 0x3f);
+        tm->tm_mday = bcd2bin(buf[M41T80_REG_DAY] & 0x3f);
         tm->tm_wday = buf[M41T80_REG_WDAY] & 0x07;
-        tm->tm_mon = BCD2BIN(buf[M41T80_REG_MON] & 0x1f) - 1;
+        tm->tm_mon = bcd2bin(buf[M41T80_REG_MON] & 0x1f) - 1;
 
         /* assume 20YY not 19YY, and ignore the Century Bit */
-        tm->tm_year = BCD2BIN(buf[M41T80_REG_YEAR]) + 100;
+        tm->tm_year = bcd2bin(buf[M41T80_REG_YEAR]) + 100;
         return 0;
 }
 
@@ -161,19 +161,19 @@ static int m41t80_set_datetime(struct i2c_client *client, struct rtc_time *tm)
         /* Merge time-data and register flags into buf[0..7] */
         buf[M41T80_REG_SSEC] = 0;
         buf[M41T80_REG_SEC] =
-                BIN2BCD(tm->tm_sec) | (buf[M41T80_REG_SEC] & ~0x7f);
+                bin2bcd(tm->tm_sec) | (buf[M41T80_REG_SEC] & ~0x7f);
         buf[M41T80_REG_MIN] =
-                BIN2BCD(tm->tm_min) | (buf[M41T80_REG_MIN] & ~0x7f);
+                bin2bcd(tm->tm_min) | (buf[M41T80_REG_MIN] & ~0x7f);
         buf[M41T80_REG_HOUR] =
-                BIN2BCD(tm->tm_hour) | (buf[M41T80_REG_HOUR] & ~0x3f) ;
+                bin2bcd(tm->tm_hour) | (buf[M41T80_REG_HOUR] & ~0x3f) ;
         buf[M41T80_REG_WDAY] =
                 (tm->tm_wday & 0x07) | (buf[M41T80_REG_WDAY] & ~0x07);
         buf[M41T80_REG_DAY] =
-                BIN2BCD(tm->tm_mday) | (buf[M41T80_REG_DAY] & ~0x3f);
+                bin2bcd(tm->tm_mday) | (buf[M41T80_REG_DAY] & ~0x3f);
         buf[M41T80_REG_MON] =
-                BIN2BCD(tm->tm_mon + 1) | (buf[M41T80_REG_MON] & ~0x1f);
+                bin2bcd(tm->tm_mon + 1) | (buf[M41T80_REG_MON] & ~0x1f);
         /* assume 20YY not 19YY */
-        buf[M41T80_REG_YEAR] = BIN2BCD(tm->tm_year % 100);
+        buf[M41T80_REG_YEAR] = bin2bcd(tm->tm_year % 100);
 
         if (i2c_transfer(client->adapter, msgs, 1) != 1) {
                 dev_err(&client->dev, "write error\n");
@@ -288,15 +288,15 @@ static int m41t80_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 
         wbuf[0] = M41T80_REG_ALARM_MON; /* offset into rtc's regs */
         reg[M41T80_REG_ALARM_SEC] |= t->time.tm_sec >= 0 ?
-                BIN2BCD(t->time.tm_sec) : 0x80;
+                bin2bcd(t->time.tm_sec) : 0x80;
         reg[M41T80_REG_ALARM_MIN] |= t->time.tm_min >= 0 ?
-                BIN2BCD(t->time.tm_min) : 0x80;
+                bin2bcd(t->time.tm_min) : 0x80;
         reg[M41T80_REG_ALARM_HOUR] |= t->time.tm_hour >= 0 ?
-                BIN2BCD(t->time.tm_hour) : 0x80;
+                bin2bcd(t->time.tm_hour) : 0x80;
         reg[M41T80_REG_ALARM_DAY] |= t->time.tm_mday >= 0 ?
-                BIN2BCD(t->time.tm_mday) : 0x80;
+                bin2bcd(t->time.tm_mday) : 0x80;
         if (t->time.tm_mon >= 0)
-                reg[M41T80_REG_ALARM_MON] |= BIN2BCD(t->time.tm_mon + 1);
+                reg[M41T80_REG_ALARM_MON] |= bin2bcd(t->time.tm_mon + 1);
         else
                 reg[M41T80_REG_ALARM_DAY] |= 0x40;
 
@@ -347,15 +347,15 @@ static int m41t80_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *t)
         t->time.tm_mday = -1;
         t->time.tm_mon = -1;
         if (!(reg[M41T80_REG_ALARM_SEC] & 0x80))
-                t->time.tm_sec = BCD2BIN(reg[M41T80_REG_ALARM_SEC] & 0x7f);
+                t->time.tm_sec = bcd2bin(reg[M41T80_REG_ALARM_SEC] & 0x7f);
         if (!(reg[M41T80_REG_ALARM_MIN] & 0x80))
-                t->time.tm_min = BCD2BIN(reg[M41T80_REG_ALARM_MIN] & 0x7f);
+                t->time.tm_min = bcd2bin(reg[M41T80_REG_ALARM_MIN] & 0x7f);
         if (!(reg[M41T80_REG_ALARM_HOUR] & 0x80))
-                t->time.tm_hour = BCD2BIN(reg[M41T80_REG_ALARM_HOUR] & 0x3f);
+                t->time.tm_hour = bcd2bin(reg[M41T80_REG_ALARM_HOUR] & 0x3f);
         if (!(reg[M41T80_REG_ALARM_DAY] & 0x80))
-                t->time.tm_mday = BCD2BIN(reg[M41T80_REG_ALARM_DAY] & 0x3f);
+                t->time.tm_mday = bcd2bin(reg[M41T80_REG_ALARM_DAY] & 0x3f);
         if (!(reg[M41T80_REG_ALARM_DAY] & 0x40))
-                t->time.tm_mon = BCD2BIN(reg[M41T80_REG_ALARM_MON] & 0x1f) - 1;
+                t->time.tm_mon = bcd2bin(reg[M41T80_REG_ALARM_MON] & 0x1f) - 1;
         t->time.tm_year = -1;
         t->time.tm_wday = -1;
         t->time.tm_yday = -1;
diff --git a/drivers/rtc/rtc-m41t94.c b/drivers/rtc/rtc-m41t94.c
index 9b19499c829e..c3a18c58daf6 100644
--- a/drivers/rtc/rtc-m41t94.c
+++ b/drivers/rtc/rtc-m41t94.c
@@ -41,17 +41,17 @@ static int m41t94_set_time(struct device *dev, struct rtc_time *tm)
                 tm->tm_mon, tm->tm_year, tm->tm_wday);
 
         buf[0] = 0x80 | M41T94_REG_SECONDS; /* write time + date */
-        buf[M41T94_REG_SECONDS] = BIN2BCD(tm->tm_sec);
-        buf[M41T94_REG_MINUTES] = BIN2BCD(tm->tm_min);
-        buf[M41T94_REG_HOURS]   = BIN2BCD(tm->tm_hour);
-        buf[M41T94_REG_WDAY]    = BIN2BCD(tm->tm_wday + 1);
-        buf[M41T94_REG_DAY]     = BIN2BCD(tm->tm_mday);
-        buf[M41T94_REG_MONTH]   = BIN2BCD(tm->tm_mon + 1);
+        buf[M41T94_REG_SECONDS] = bin2bcd(tm->tm_sec);
+        buf[M41T94_REG_MINUTES] = bin2bcd(tm->tm_min);
+        buf[M41T94_REG_HOURS]   = bin2bcd(tm->tm_hour);
+        buf[M41T94_REG_WDAY]    = bin2bcd(tm->tm_wday + 1);
+        buf[M41T94_REG_DAY]     = bin2bcd(tm->tm_mday);
+        buf[M41T94_REG_MONTH]   = bin2bcd(tm->tm_mon + 1);
 
         buf[M41T94_REG_HOURS] |= M41T94_BIT_CEB;
         if (tm->tm_year >= 100)
                 buf[M41T94_REG_HOURS] |= M41T94_BIT_CB;
-        buf[M41T94_REG_YEAR] = BIN2BCD(tm->tm_year % 100);
+        buf[M41T94_REG_YEAR] = bin2bcd(tm->tm_year % 100);
 
         return spi_write(spi, buf, 8);
 }
@@ -82,14 +82,14 @@ static int m41t94_read_time(struct device *dev, struct rtc_time *tm)
                 spi_write(spi, buf, 2);
         }
 
-        tm->tm_sec  = BCD2BIN(spi_w8r8(spi, M41T94_REG_SECONDS));
-        tm->tm_min  = BCD2BIN(spi_w8r8(spi, M41T94_REG_MINUTES));
+        tm->tm_sec  = bcd2bin(spi_w8r8(spi, M41T94_REG_SECONDS));
+        tm->tm_min  = bcd2bin(spi_w8r8(spi, M41T94_REG_MINUTES));
         hour = spi_w8r8(spi, M41T94_REG_HOURS);
-        tm->tm_hour = BCD2BIN(hour & 0x3f);
-        tm->tm_wday = BCD2BIN(spi_w8r8(spi, M41T94_REG_WDAY)) - 1;
-        tm->tm_mday = BCD2BIN(spi_w8r8(spi, M41T94_REG_DAY));
-        tm->tm_mon  = BCD2BIN(spi_w8r8(spi, M41T94_REG_MONTH)) - 1;
-        tm->tm_year = BCD2BIN(spi_w8r8(spi, M41T94_REG_YEAR));
+        tm->tm_hour = bcd2bin(hour & 0x3f);
+        tm->tm_wday = bcd2bin(spi_w8r8(spi, M41T94_REG_WDAY)) - 1;
+        tm->tm_mday = bcd2bin(spi_w8r8(spi, M41T94_REG_DAY));
+        tm->tm_mon  = bcd2bin(spi_w8r8(spi, M41T94_REG_MONTH)) - 1;
+        tm->tm_year = bcd2bin(spi_w8r8(spi, M41T94_REG_YEAR));
         if ((hour & M41T94_BIT_CB) || !(hour & M41T94_BIT_CEB))
                 tm->tm_year += 100;
 
diff --git a/drivers/rtc/rtc-m48t59.c b/drivers/rtc/rtc-m48t59.c
index ce4eff6a8d51..04b63dab6932 100644
--- a/drivers/rtc/rtc-m48t59.c
+++ b/drivers/rtc/rtc-m48t59.c
@@ -76,10 +76,10 @@ static int m48t59_rtc_read_time(struct device *dev, struct rtc_time *tm)
         /* Issue the READ command */
         M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);
 
-        tm->tm_year     = BCD2BIN(M48T59_READ(M48T59_YEAR));
+        tm->tm_year     = bcd2bin(M48T59_READ(M48T59_YEAR));
         /* tm_mon is 0-11 */
-        tm->tm_mon      = BCD2BIN(M48T59_READ(M48T59_MONTH)) - 1;
-        tm->tm_mday     = BCD2BIN(M48T59_READ(M48T59_MDAY));
+        tm->tm_mon      = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;
+        tm->tm_mday     = bcd2bin(M48T59_READ(M48T59_MDAY));
 
         val = M48T59_READ(M48T59_WDAY);
         if ((pdata->type == M48T59RTC_TYPE_M48T59) &&
@@ -88,10 +88,10 @@ static int m48t59_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 tm->tm_year += 100;     /* one century */
         }
 
-        tm->tm_wday     = BCD2BIN(val & 0x07);
-        tm->tm_hour     = BCD2BIN(M48T59_READ(M48T59_HOUR) & 0x3F);
-        tm->tm_min      = BCD2BIN(M48T59_READ(M48T59_MIN) & 0x7F);
-        tm->tm_sec      = BCD2BIN(M48T59_READ(M48T59_SEC) & 0x7F);
+        tm->tm_wday     = bcd2bin(val & 0x07);
+        tm->tm_hour     = bcd2bin(M48T59_READ(M48T59_HOUR) & 0x3F);
+        tm->tm_min      = bcd2bin(M48T59_READ(M48T59_MIN) & 0x7F);
+        tm->tm_sec      = bcd2bin(M48T59_READ(M48T59_SEC) & 0x7F);
 
         /* Clear the READ bit */
         M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
@@ -119,17 +119,17 @@ static int m48t59_rtc_set_time(struct device *dev, struct rtc_time *tm)
         /* Issue the WRITE command */
         M48T59_SET_BITS(M48T59_CNTL_WRITE, M48T59_CNTL);
 
-        M48T59_WRITE((BIN2BCD(tm->tm_sec) & 0x7F), M48T59_SEC);
-        M48T59_WRITE((BIN2BCD(tm->tm_min) & 0x7F), M48T59_MIN);
-        M48T59_WRITE((BIN2BCD(tm->tm_hour) & 0x3F), M48T59_HOUR);
-        M48T59_WRITE((BIN2BCD(tm->tm_mday) & 0x3F), M48T59_MDAY);
+        M48T59_WRITE((bin2bcd(tm->tm_sec) & 0x7F), M48T59_SEC);
+        M48T59_WRITE((bin2bcd(tm->tm_min) & 0x7F), M48T59_MIN);
+        M48T59_WRITE((bin2bcd(tm->tm_hour) & 0x3F), M48T59_HOUR);
+        M48T59_WRITE((bin2bcd(tm->tm_mday) & 0x3F), M48T59_MDAY);
         /* tm_mon is 0-11 */
-        M48T59_WRITE((BIN2BCD(tm->tm_mon + 1) & 0x1F), M48T59_MONTH);
-        M48T59_WRITE(BIN2BCD(tm->tm_year % 100), M48T59_YEAR);
+        M48T59_WRITE((bin2bcd(tm->tm_mon + 1) & 0x1F), M48T59_MONTH);
+        M48T59_WRITE(bin2bcd(tm->tm_year % 100), M48T59_YEAR);
 
         if (pdata->type == M48T59RTC_TYPE_M48T59 && (tm->tm_year / 100))
                 val = (M48T59_WDAY_CEB | M48T59_WDAY_CB);
-        val |= (BIN2BCD(tm->tm_wday) & 0x07);
+        val |= (bin2bcd(tm->tm_wday) & 0x07);
         M48T59_WRITE(val, M48T59_WDAY);
 
         /* Clear the WRITE bit */
@@ -158,18 +158,18 @@ static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
         /* Issue the READ command */
         M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL);
 
-        tm->tm_year = BCD2BIN(M48T59_READ(M48T59_YEAR));
+        tm->tm_year = bcd2bin(M48T59_READ(M48T59_YEAR));
         /* tm_mon is 0-11 */
-        tm->tm_mon = BCD2BIN(M48T59_READ(M48T59_MONTH)) - 1;
+        tm->tm_mon = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1;
 
         val = M48T59_READ(M48T59_WDAY);
         if ((val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB))
                 tm->tm_year += 100;     /* one century */
 
-        tm->tm_mday = BCD2BIN(M48T59_READ(M48T59_ALARM_DATE));
-        tm->tm_hour = BCD2BIN(M48T59_READ(M48T59_ALARM_HOUR));
-        tm->tm_min = BCD2BIN(M48T59_READ(M48T59_ALARM_MIN));
-        tm->tm_sec = BCD2BIN(M48T59_READ(M48T59_ALARM_SEC));
+        tm->tm_mday = bcd2bin(M48T59_READ(M48T59_ALARM_DATE));
+        tm->tm_hour = bcd2bin(M48T59_READ(M48T59_ALARM_HOUR));
+        tm->tm_min = bcd2bin(M48T59_READ(M48T59_ALARM_MIN));
+        tm->tm_sec = bcd2bin(M48T59_READ(M48T59_ALARM_SEC));
 
         /* Clear the READ bit */
         M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL);
@@ -201,18 +201,18 @@ static int m48t59_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
          * 0xff means "always match"
          */
         mday = tm->tm_mday;
-        mday = (mday >= 1 && mday <= 31) ? BIN2BCD(mday) : 0xff;
+        mday = (mday >= 1 && mday <= 31) ? bin2bcd(mday) : 0xff;
         if (mday == 0xff)
                 mday = M48T59_READ(M48T59_MDAY);
 
         hour = tm->tm_hour;
-        hour = (hour < 24) ? BIN2BCD(hour) : 0x00;
+        hour = (hour < 24) ? bin2bcd(hour) : 0x00;
 
         min = tm->tm_min;
-        min = (min < 60) ? BIN2BCD(min) : 0x00;
+        min = (min < 60) ? bin2bcd(min) : 0x00;
 
         sec = tm->tm_sec;
-        sec = (sec < 60) ? BIN2BCD(sec) : 0x00;
+        sec = (sec < 60) ? bin2bcd(sec) : 0x00;
 
         spin_lock_irqsave(&m48t59->lock, flags);
         /* Issue the WRITE command */
@@ -360,7 +360,6 @@ static struct bin_attribute m48t59_nvram_attr = {
         .attr = {
                 .name = "nvram",
                 .mode = S_IRUGO | S_IWUSR,
-                .owner = THIS_MODULE,
         },
         .read = m48t59_nvram_read,
         .write = m48t59_nvram_write,
diff --git a/drivers/rtc/rtc-m48t86.c b/drivers/rtc/rtc-m48t86.c
index 3f7f99a5d96a..7c045cffa9ff 100644
--- a/drivers/rtc/rtc-m48t86.c
+++ b/drivers/rtc/rtc-m48t86.c
@@ -62,14 +62,14 @@ static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 tm->tm_wday     = ops->readbyte(M48T86_REG_DOW);
         } else {
                 /* bcd mode */
-                tm->tm_sec      = BCD2BIN(ops->readbyte(M48T86_REG_SEC));
-                tm->tm_min      = BCD2BIN(ops->readbyte(M48T86_REG_MIN));
-                tm->tm_hour     = BCD2BIN(ops->readbyte(M48T86_REG_HOUR) & 0x3F);
-                tm->tm_mday     = BCD2BIN(ops->readbyte(M48T86_REG_DOM));
+                tm->tm_sec      = bcd2bin(ops->readbyte(M48T86_REG_SEC));
+                tm->tm_min      = bcd2bin(ops->readbyte(M48T86_REG_MIN));
+                tm->tm_hour     = bcd2bin(ops->readbyte(M48T86_REG_HOUR) & 0x3F);
+                tm->tm_mday     = bcd2bin(ops->readbyte(M48T86_REG_DOM));
                 /* tm_mon is 0-11 */
-                tm->tm_mon      = BCD2BIN(ops->readbyte(M48T86_REG_MONTH)) - 1;
-                tm->tm_year     = BCD2BIN(ops->readbyte(M48T86_REG_YEAR)) + 100;
-                tm->tm_wday     = BCD2BIN(ops->readbyte(M48T86_REG_DOW));
+                tm->tm_mon      = bcd2bin(ops->readbyte(M48T86_REG_MONTH)) - 1;
+                tm->tm_year     = bcd2bin(ops->readbyte(M48T86_REG_YEAR)) + 100;
+                tm->tm_wday     = bcd2bin(ops->readbyte(M48T86_REG_DOW));
         }
 
         /* correct the hour if the clock is in 12h mode */
@@ -103,13 +103,13 @@ static int m48t86_rtc_set_time(struct device *dev, struct rtc_time *tm)
                 ops->writebyte(tm->tm_wday, M48T86_REG_DOW);
         } else {
                 /* bcd mode */
-                ops->writebyte(BIN2BCD(tm->tm_sec), M48T86_REG_SEC);
-                ops->writebyte(BIN2BCD(tm->tm_min), M48T86_REG_MIN);
-                ops->writebyte(BIN2BCD(tm->tm_hour), M48T86_REG_HOUR);
-                ops->writebyte(BIN2BCD(tm->tm_mday), M48T86_REG_DOM);
-                ops->writebyte(BIN2BCD(tm->tm_mon + 1), M48T86_REG_MONTH);
-                ops->writebyte(BIN2BCD(tm->tm_year % 100), M48T86_REG_YEAR);
-                ops->writebyte(BIN2BCD(tm->tm_wday), M48T86_REG_DOW);
+                ops->writebyte(bin2bcd(tm->tm_sec), M48T86_REG_SEC);
+                ops->writebyte(bin2bcd(tm->tm_min), M48T86_REG_MIN);
+                ops->writebyte(bin2bcd(tm->tm_hour), M48T86_REG_HOUR);
+                ops->writebyte(bin2bcd(tm->tm_mday), M48T86_REG_DOM);
+                ops->writebyte(bin2bcd(tm->tm_mon + 1), M48T86_REG_MONTH);
+                ops->writebyte(bin2bcd(tm->tm_year % 100), M48T86_REG_YEAR);
+                ops->writebyte(bin2bcd(tm->tm_wday), M48T86_REG_DOW);
         }
 
         /* update ended */
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
index 12c9cd25cad8..80782798763f 100644
--- a/drivers/rtc/rtc-max6900.c
+++ b/drivers/rtc/rtc-max6900.c
@@ -150,14 +150,14 @@ static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
         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]) +
-            BCD2BIN(regs[MAX6900_REG_CENTURY]) * 100 - 1900;
-        tm->tm_wday = BCD2BIN(regs[MAX6900_REG_DW]);
+        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]) +
+                      bcd2bin(regs[MAX6900_REG_CENTURY]) * 100 - 1900;
+        tm->tm_wday = bcd2bin(regs[MAX6900_REG_DW]);
 
         return 0;
 }
@@ -184,14 +184,14 @@ max6900_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
         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_DW] = BIN2BCD(tm->tm_wday);
-        regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year % 100);
-        regs[MAX6900_REG_CENTURY] = BIN2BCD((tm->tm_year + 1900) / 100);
+        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_DW] = bin2bcd(tm->tm_wday);
+        regs[MAX6900_REG_YR] = bin2bcd(tm->tm_year % 100);
+        regs[MAX6900_REG_CENTURY] = bin2bcd((tm->tm_year + 1900) / 100);
         /* set write protect */
         regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;
 
diff --git a/drivers/rtc/rtc-max6902.c b/drivers/rtc/rtc-max6902.c
index 78b2551fb19d..2f6507df7b49 100644
--- a/drivers/rtc/rtc-max6902.c
+++ b/drivers/rtc/rtc-max6902.c
@@ -124,15 +124,15 @@ static int max6902_get_datetime(struct device *dev, struct rtc_time *dt)
 
         /* The chip sends data in this order:
          * Seconds, Minutes, Hours, Date, Month, Day, Year */
-        dt->tm_sec      = BCD2BIN(chip->buf[1]);
-        dt->tm_min      = BCD2BIN(chip->buf[2]);
-        dt->tm_hour     = BCD2BIN(chip->buf[3]);
-        dt->tm_mday     = BCD2BIN(chip->buf[4]);
-        dt->tm_mon      = BCD2BIN(chip->buf[5]) - 1;
-        dt->tm_wday     = BCD2BIN(chip->buf[6]);
-        dt->tm_year = BCD2BIN(chip->buf[7]);
+        dt->tm_sec      = bcd2bin(chip->buf[1]);
+        dt->tm_min      = bcd2bin(chip->buf[2]);
+        dt->tm_hour     = bcd2bin(chip->buf[3]);
+        dt->tm_mday     = bcd2bin(chip->buf[4]);
+        dt->tm_mon      = bcd2bin(chip->buf[5]) - 1;
+        dt->tm_wday     = bcd2bin(chip->buf[6]);
+        dt->tm_year = bcd2bin(chip->buf[7]);
 
-        century = BCD2BIN(tmp) * 100;
+        century = bcd2bin(tmp) * 100;
 
         dt->tm_year += century;
         dt->tm_year -= 1900;
@@ -168,15 +168,15 @@ static int max6902_set_datetime(struct device *dev, struct rtc_time *dt)
         /* Remove write protection */
         max6902_set_reg(dev, 0xF, 0);
 
-        max6902_set_reg(dev, 0x01, BIN2BCD(dt->tm_sec));
-        max6902_set_reg(dev, 0x03, BIN2BCD(dt->tm_min));
-        max6902_set_reg(dev, 0x05, BIN2BCD(dt->tm_hour));
+        max6902_set_reg(dev, 0x01, bin2bcd(dt->tm_sec));
+        max6902_set_reg(dev, 0x03, bin2bcd(dt->tm_min));
+        max6902_set_reg(dev, 0x05, bin2bcd(dt->tm_hour));
 
-        max6902_set_reg(dev, 0x07, BIN2BCD(dt->tm_mday));
-        max6902_set_reg(dev, 0x09, BIN2BCD(dt->tm_mon+1));
-        max6902_set_reg(dev, 0x0B, BIN2BCD(dt->tm_wday));
-        max6902_set_reg(dev, 0x0D, BIN2BCD(dt->tm_year%100));
-        max6902_set_reg(dev, 0x13, BIN2BCD(dt->tm_year/100));
+        max6902_set_reg(dev, 0x07, bin2bcd(dt->tm_mday));
+        max6902_set_reg(dev, 0x09, bin2bcd(dt->tm_mon+1));
+        max6902_set_reg(dev, 0x0B, bin2bcd(dt->tm_wday));
+        max6902_set_reg(dev, 0x0D, bin2bcd(dt->tm_year%100));
+        max6902_set_reg(dev, 0x13, bin2bcd(dt->tm_year/100));
 
         /* Compulab used a delay here. However, the datasheet
          * does not mention a delay being required anywhere... */
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 8876605d4d4b..2cbeb0794f14 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -186,30 +186,30 @@ static int tm2bcd(struct rtc_time *tm)
         if (rtc_valid_tm(tm) != 0)
                 return -EINVAL;
 
-        tm->tm_sec = BIN2BCD(tm->tm_sec);
-        tm->tm_min = BIN2BCD(tm->tm_min);
-        tm->tm_hour = BIN2BCD(tm->tm_hour);
-        tm->tm_mday = BIN2BCD(tm->tm_mday);
+        tm->tm_sec = bin2bcd(tm->tm_sec);
+        tm->tm_min = bin2bcd(tm->tm_min);
+        tm->tm_hour = bin2bcd(tm->tm_hour);
+        tm->tm_mday = bin2bcd(tm->tm_mday);
 
-        tm->tm_mon = BIN2BCD(tm->tm_mon + 1);
+        tm->tm_mon = bin2bcd(tm->tm_mon + 1);
 
         /* epoch == 1900 */
         if (tm->tm_year < 100 || tm->tm_year > 199)
                 return -EINVAL;
-        tm->tm_year = BIN2BCD(tm->tm_year - 100);
+        tm->tm_year = bin2bcd(tm->tm_year - 100);
 
         return 0;
 }
 
 static void bcd2tm(struct rtc_time *tm)
 {
-        tm->tm_sec = BCD2BIN(tm->tm_sec);
-        tm->tm_min = BCD2BIN(tm->tm_min);
-        tm->tm_hour = BCD2BIN(tm->tm_hour);
-        tm->tm_mday = BCD2BIN(tm->tm_mday);
-        tm->tm_mon = BCD2BIN(tm->tm_mon) - 1;
+        tm->tm_sec = bcd2bin(tm->tm_sec);
+        tm->tm_min = bcd2bin(tm->tm_min);
+        tm->tm_hour = bcd2bin(tm->tm_hour);
+        tm->tm_mday = bcd2bin(tm->tm_mday);
+        tm->tm_mon = bcd2bin(tm->tm_mon) - 1;
         /* epoch == 1900 */
-        tm->tm_year = BCD2BIN(tm->tm_year) + 100;
+        tm->tm_year = bcd2bin(tm->tm_year) + 100;
 }
 
 
diff --git a/drivers/rtc/rtc-parisc.c b/drivers/rtc/rtc-parisc.c
new file mode 100644
index 000000000000..346d633655e7
--- /dev/null
+++ b/drivers/rtc/rtc-parisc.c
@@ -0,0 +1,111 @@
+/* rtc-parisc: RTC for HP PA-RISC firmware
+ *
+ * Copyright (C) 2008 Kyle McMartin <kyle@mcmartin.ca>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/time.h>
+#include <linux/platform_device.h>
+
+#include <asm/rtc.h>
+
+/* as simple as can be, and no simpler. */
+struct parisc_rtc {
+        struct rtc_device *rtc;
+        spinlock_t lock;
+};
+
+static int parisc_get_time(struct device *dev, struct rtc_time *tm)
+{
+        struct parisc_rtc *p = dev_get_drvdata(dev);
+        unsigned long flags, ret;
+
+        spin_lock_irqsave(&p->lock, flags);
+        ret = get_rtc_time(tm);
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        if (ret & RTC_BATT_BAD)
+                return -EOPNOTSUPP;
+
+        return 0;
+}
+
+static int parisc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct parisc_rtc *p = dev_get_drvdata(dev);
+        unsigned long flags, ret;
+
+        spin_lock_irqsave(&p->lock, flags);
+        ret = set_rtc_time(tm);
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        if (ret < 0)
+                return -EOPNOTSUPP;
+
+        return 0;
+}
+
+static const struct rtc_class_ops parisc_rtc_ops = {
+        .read_time = parisc_get_time,
+        .set_time = parisc_set_time,
+};
+
+static int __devinit parisc_rtc_probe(struct platform_device *dev)
+{
+        struct parisc_rtc *p;
+
+        p = kzalloc(sizeof (*p), GFP_KERNEL);
+        if (!p)
+                return -ENOMEM;
+
+        spin_lock_init(&p->lock);
+
+        p->rtc = rtc_device_register("rtc-parisc", &dev->dev, &parisc_rtc_ops,
+                                        THIS_MODULE);
+        if (IS_ERR(p->rtc)) {
+                int err = PTR_ERR(p->rtc);
+                kfree(p);
+                return err;
+        }
+
+        platform_set_drvdata(dev, p);
+
+        return 0;
+}
+
+static int __devexit parisc_rtc_remove(struct platform_device *dev)
+{
+        struct parisc_rtc *p = platform_get_drvdata(dev);
+
+        rtc_device_unregister(p->rtc);
+        kfree(p);
+
+        return 0;
+}
+
+static struct platform_driver parisc_rtc_driver = {
+        .driver = {
+                .name = "rtc-parisc",
+                .owner = THIS_MODULE,
+        },
+        .probe = parisc_rtc_probe,
+        .remove = __devexit_p(parisc_rtc_remove),
+};
+
+static int __init parisc_rtc_init(void)
+{
+        return platform_driver_register(&parisc_rtc_driver);
+}
+
+static void __exit parisc_rtc_fini(void)
+{
+        platform_driver_unregister(&parisc_rtc_driver);
+}
+
+module_init(parisc_rtc_init);
+module_exit(parisc_rtc_fini);
+
+MODULE_AUTHOR("Kyle McMartin <kyle@mcmartin.ca>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("HP PA-RISC RTC driver");
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
index a829f20ad6d6..b725913ccbe8 100644
--- a/drivers/rtc/rtc-pcf8563.c
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -97,13 +97,13 @@ static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
                 buf[8]);
 
 
-        tm->tm_sec = BCD2BIN(buf[PCF8563_REG_SC] & 0x7F);
-        tm->tm_min = BCD2BIN(buf[PCF8563_REG_MN] & 0x7F);
-        tm->tm_hour = BCD2BIN(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */
-        tm->tm_mday = BCD2BIN(buf[PCF8563_REG_DM] & 0x3F);
+        tm->tm_sec = bcd2bin(buf[PCF8563_REG_SC] & 0x7F);
+        tm->tm_min = bcd2bin(buf[PCF8563_REG_MN] & 0x7F);
+        tm->tm_hour = bcd2bin(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */
+        tm->tm_mday = bcd2bin(buf[PCF8563_REG_DM] & 0x3F);
         tm->tm_wday = buf[PCF8563_REG_DW] & 0x07;
-        tm->tm_mon = BCD2BIN(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
-        tm->tm_year = BCD2BIN(buf[PCF8563_REG_YR]);
+        tm->tm_mon = bcd2bin(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
+        tm->tm_year = bcd2bin(buf[PCF8563_REG_YR]);
         if (tm->tm_year < 70)
                 tm->tm_year += 100;     /* assume we are in 1970...2069 */
         /* detect the polarity heuristically. see note above. */
@@ -138,17 +138,17 @@ static int pcf8563_set_datetime(struct i2c_client *client, struct rtc_time *tm)
                 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
         /* hours, minutes and seconds */
-        buf[PCF8563_REG_SC] = BIN2BCD(tm->tm_sec);
-        buf[PCF8563_REG_MN] = BIN2BCD(tm->tm_min);
-        buf[PCF8563_REG_HR] = BIN2BCD(tm->tm_hour);
+        buf[PCF8563_REG_SC] = bin2bcd(tm->tm_sec);
+        buf[PCF8563_REG_MN] = bin2bcd(tm->tm_min);
+        buf[PCF8563_REG_HR] = bin2bcd(tm->tm_hour);
 
-        buf[PCF8563_REG_DM] = BIN2BCD(tm->tm_mday);
+        buf[PCF8563_REG_DM] = bin2bcd(tm->tm_mday);
 
         /* month, 1 - 12 */
-        buf[PCF8563_REG_MO] = BIN2BCD(tm->tm_mon + 1);
+        buf[PCF8563_REG_MO] = bin2bcd(tm->tm_mon + 1);
 
         /* year and century */
-        buf[PCF8563_REG_YR] = BIN2BCD(tm->tm_year % 100);
+        buf[PCF8563_REG_YR] = bin2bcd(tm->tm_year % 100);
         if (pcf8563->c_polarity ? (tm->tm_year >= 100) : (tm->tm_year < 100))
                 buf[PCF8563_REG_MO] |= PCF8563_MO_C;
 
diff --git a/drivers/rtc/rtc-pcf8583.c b/drivers/rtc/rtc-pcf8583.c
index d388c662bf4b..7d33cda3f8f6 100644
--- a/drivers/rtc/rtc-pcf8583.c
+++ b/drivers/rtc/rtc-pcf8583.c
@@ -76,11 +76,11 @@ static int pcf8583_get_datetime(struct i2c_client *client, struct rtc_time *dt)
                 buf[4] &= 0x3f;
                 buf[5] &= 0x1f;
 
-                dt->tm_sec = BCD2BIN(buf[1]);
-                dt->tm_min = BCD2BIN(buf[2]);
-                dt->tm_hour = BCD2BIN(buf[3]);
-                dt->tm_mday = BCD2BIN(buf[4]);
-                dt->tm_mon = BCD2BIN(buf[5]) - 1;
+                dt->tm_sec = bcd2bin(buf[1]);
+                dt->tm_min = bcd2bin(buf[2]);
+                dt->tm_hour = bcd2bin(buf[3]);
+                dt->tm_mday = bcd2bin(buf[4]);
+                dt->tm_mon = bcd2bin(buf[5]) - 1;
         }
 
         return ret == 2 ? 0 : -EIO;
@@ -94,14 +94,14 @@ static int pcf8583_set_datetime(struct i2c_client *client, struct rtc_time *dt,
         buf[0] = 0;
         buf[1] = get_ctrl(client) | 0x80;
         buf[2] = 0;
-        buf[3] = BIN2BCD(dt->tm_sec);
-        buf[4] = BIN2BCD(dt->tm_min);
-        buf[5] = BIN2BCD(dt->tm_hour);
+        buf[3] = bin2bcd(dt->tm_sec);
+        buf[4] = bin2bcd(dt->tm_min);
+        buf[5] = bin2bcd(dt->tm_hour);
 
         if (datetoo) {
                 len = 8;
-                buf[6] = BIN2BCD(dt->tm_mday) | (dt->tm_year << 6);
-                buf[7] = BIN2BCD(dt->tm_mon + 1)  | (dt->tm_wday << 5);
+                buf[6] = bin2bcd(dt->tm_mday) | (dt->tm_year << 6);
+                buf[7] = bin2bcd(dt->tm_mon + 1)  | (dt->tm_wday << 5);
         }
 
         ret = i2c_master_send(client, (char *)buf, len);
diff --git a/drivers/rtc/rtc-r9701.c b/drivers/rtc/rtc-r9701.c
index 395985b339c9..42028f233bef 100644
--- a/drivers/rtc/rtc-r9701.c
+++ b/drivers/rtc/rtc-r9701.c
@@ -80,13 +80,13 @@ static int r9701_get_datetime(struct device *dev, struct rtc_time *dt)
 
         memset(dt, 0, sizeof(*dt));
 
-        dt->tm_sec = BCD2BIN(buf[0]); /* RSECCNT */
-        dt->tm_min = BCD2BIN(buf[1]); /* RMINCNT */
-        dt->tm_hour = BCD2BIN(buf[2]); /* RHRCNT */
+        dt->tm_sec = bcd2bin(buf[0]); /* RSECCNT */
+        dt->tm_min = bcd2bin(buf[1]); /* RMINCNT */
+        dt->tm_hour = bcd2bin(buf[2]); /* RHRCNT */
 
-        dt->tm_mday = BCD2BIN(buf[3]); /* RDAYCNT */
-        dt->tm_mon = BCD2BIN(buf[4]) - 1; /* RMONCNT */
-        dt->tm_year = BCD2BIN(buf[5]) + 100; /* RYRCNT */
+        dt->tm_mday = bcd2bin(buf[3]); /* RDAYCNT */
+        dt->tm_mon = bcd2bin(buf[4]) - 1; /* RMONCNT */
+        dt->tm_year = bcd2bin(buf[5]) + 100; /* RYRCNT */
 
         /* the rtc device may contain illegal values on power up
          * according to the data sheet. make sure they are valid.
@@ -103,12 +103,12 @@ static int r9701_set_datetime(struct device *dev, struct rtc_time *dt)
         if (year >= 2100 || year < 2000)
                 return -EINVAL;
 
-        ret = write_reg(dev, RHRCNT, BIN2BCD(dt->tm_hour));
-        ret = ret ? ret : write_reg(dev, RMINCNT, BIN2BCD(dt->tm_min));
-        ret = ret ? ret : write_reg(dev, RSECCNT, BIN2BCD(dt->tm_sec));
-        ret = ret ? ret : write_reg(dev, RDAYCNT, BIN2BCD(dt->tm_mday));
-        ret = ret ? ret : write_reg(dev, RMONCNT, BIN2BCD(dt->tm_mon + 1));
-        ret = ret ? ret : write_reg(dev, RYRCNT, BIN2BCD(dt->tm_year - 100));
+        ret = write_reg(dev, RHRCNT, bin2bcd(dt->tm_hour));
+        ret = ret ? ret : write_reg(dev, RMINCNT, bin2bcd(dt->tm_min));
+        ret = ret ? ret : write_reg(dev, RSECCNT, bin2bcd(dt->tm_sec));
+        ret = ret ? ret : write_reg(dev, RDAYCNT, bin2bcd(dt->tm_mday));
+        ret = ret ? ret : write_reg(dev, RMONCNT, bin2bcd(dt->tm_mon + 1));
+        ret = ret ? ret : write_reg(dev, RYRCNT, bin2bcd(dt->tm_year - 100));
         ret = ret ? ret : write_reg(dev, RWKCNT, 1 << dt->tm_wday);
 
         return ret;
diff --git a/drivers/rtc/rtc-rs5c313.c b/drivers/rtc/rtc-rs5c313.c
index 1c14d4497c4d..e6ea3f5ee1eb 100644
--- a/drivers/rtc/rtc-rs5c313.c
+++ b/drivers/rtc/rtc-rs5c313.c
@@ -235,33 +235,33 @@ static int rs5c313_rtc_read_time(struct device *dev, struct rtc_time *tm)
 
         data = rs5c313_read_reg(RS5C313_ADDR_SEC);
         data |= (rs5c313_read_reg(RS5C313_ADDR_SEC10) << 4);
-        tm->tm_sec = BCD2BIN(data);
+        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);
+        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);
+        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);
+        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;
+        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);
+        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);
+        tm->tm_wday = bcd2bin(data);
 
         RS5C313_CEDISABLE;
         ndelay(700);            /* CE:L */
@@ -294,31 +294,31 @@ static int rs5c313_rtc_set_time(struct device *dev, struct rtc_time *tm)
                 }
         }
 
-        data = BIN2BCD(tm->tm_sec);
+        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);
+        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);
+        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);
+        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);
+        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);
+        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);
+        data = bin2bcd(tm->tm_wday);
         rs5c313_write_reg(RS5C313_ADDR_WEEK, data);
 
         RS5C313_CEDISABLE;      /* CE:H */
diff --git a/drivers/rtc/rtc-rs5c348.c b/drivers/rtc/rtc-rs5c348.c
index 839462659afa..dd1e2bc7a472 100644
--- a/drivers/rtc/rtc-rs5c348.c
+++ b/drivers/rtc/rtc-rs5c348.c
@@ -74,20 +74,20 @@ rs5c348_rtc_set_time(struct device *dev, struct rtc_time *tm)
         txbuf[3] = 0;   /* dummy */
         txbuf[4] = RS5C348_CMD_MW(RS5C348_REG_SECS); /* cmd, sec, ... */
         txp = &txbuf[5];
-        txp[RS5C348_REG_SECS] = BIN2BCD(tm->tm_sec);
-        txp[RS5C348_REG_MINS] = BIN2BCD(tm->tm_min);
+        txp[RS5C348_REG_SECS] = bin2bcd(tm->tm_sec);
+        txp[RS5C348_REG_MINS] = bin2bcd(tm->tm_min);
         if (pdata->rtc_24h) {
-                txp[RS5C348_REG_HOURS] = BIN2BCD(tm->tm_hour);
+                txp[RS5C348_REG_HOURS] = bin2bcd(tm->tm_hour);
         } else {
                 /* hour 0 is AM12, noon is PM12 */
-                txp[RS5C348_REG_HOURS] = BIN2BCD((tm->tm_hour + 11) % 12 + 1) |
+                txp[RS5C348_REG_HOURS] = bin2bcd((tm->tm_hour + 11) % 12 + 1) |
                         (tm->tm_hour >= 12 ? RS5C348_BIT_PM : 0);
         }
-        txp[RS5C348_REG_WDAY] = BIN2BCD(tm->tm_wday);
-        txp[RS5C348_REG_DAY] = BIN2BCD(tm->tm_mday);
-        txp[RS5C348_REG_MONTH] = BIN2BCD(tm->tm_mon + 1) |
+        txp[RS5C348_REG_WDAY] = bin2bcd(tm->tm_wday);
+        txp[RS5C348_REG_DAY] = bin2bcd(tm->tm_mday);
+        txp[RS5C348_REG_MONTH] = bin2bcd(tm->tm_mon + 1) |
                 (tm->tm_year >= 100 ? RS5C348_BIT_Y2K : 0);
-        txp[RS5C348_REG_YEAR] = BIN2BCD(tm->tm_year % 100);
+        txp[RS5C348_REG_YEAR] = bin2bcd(tm->tm_year % 100);
         /* write in one transfer to avoid data inconsistency */
         ret = spi_write_then_read(spi, txbuf, sizeof(txbuf), NULL, 0);
         udelay(62);     /* Tcsr 62us */
@@ -116,20 +116,20 @@ rs5c348_rtc_read_time(struct device *dev, struct rtc_time *tm)
         if (ret < 0)
                 return ret;
 
-        tm->tm_sec = BCD2BIN(rxbuf[RS5C348_REG_SECS] & RS5C348_SECS_MASK);
-        tm->tm_min = BCD2BIN(rxbuf[RS5C348_REG_MINS] & RS5C348_MINS_MASK);
-        tm->tm_hour = BCD2BIN(rxbuf[RS5C348_REG_HOURS] & RS5C348_HOURS_MASK);
+        tm->tm_sec = bcd2bin(rxbuf[RS5C348_REG_SECS] & RS5C348_SECS_MASK);
+        tm->tm_min = bcd2bin(rxbuf[RS5C348_REG_MINS] & RS5C348_MINS_MASK);
+        tm->tm_hour = bcd2bin(rxbuf[RS5C348_REG_HOURS] & RS5C348_HOURS_MASK);
         if (!pdata->rtc_24h) {
                 tm->tm_hour %= 12;
                 if (rxbuf[RS5C348_REG_HOURS] & RS5C348_BIT_PM)
                         tm->tm_hour += 12;
         }
-        tm->tm_wday = BCD2BIN(rxbuf[RS5C348_REG_WDAY] & RS5C348_WDAY_MASK);
-        tm->tm_mday = BCD2BIN(rxbuf[RS5C348_REG_DAY] & RS5C348_DAY_MASK);
+        tm->tm_wday = bcd2bin(rxbuf[RS5C348_REG_WDAY] & RS5C348_WDAY_MASK);
+        tm->tm_mday = bcd2bin(rxbuf[RS5C348_REG_DAY] & RS5C348_DAY_MASK);
         tm->tm_mon =
-                BCD2BIN(rxbuf[RS5C348_REG_MONTH] & RS5C348_MONTH_MASK) - 1;
+                bcd2bin(rxbuf[RS5C348_REG_MONTH] & RS5C348_MONTH_MASK) - 1;
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(rxbuf[RS5C348_REG_YEAR]) +
+        tm->tm_year = bcd2bin(rxbuf[RS5C348_REG_YEAR]) +
                 ((rxbuf[RS5C348_REG_MONTH] & RS5C348_BIT_Y2K) ? 100 : 0);
 
         if (rtc_valid_tm(tm) < 0) {
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
index 8b561958fb1e..2f2c68d476da 100644
--- a/drivers/rtc/rtc-rs5c372.c
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -148,9 +148,9 @@ static unsigned rs5c_reg2hr(struct rs5c372 *rs5c, unsigned reg)
         unsigned        hour;
 
         if (rs5c->time24)
-                return BCD2BIN(reg & 0x3f);
+                return bcd2bin(reg & 0x3f);
 
-        hour = BCD2BIN(reg & 0x1f);
+        hour = bcd2bin(reg & 0x1f);
         if (hour == 12)
                 hour = 0;
         if (reg & 0x20)
@@ -161,15 +161,15 @@ static unsigned rs5c_reg2hr(struct rs5c372 *rs5c, unsigned reg)
 static unsigned rs5c_hr2reg(struct rs5c372 *rs5c, unsigned hour)
 {
         if (rs5c->time24)
-                return BIN2BCD(hour);
+                return bin2bcd(hour);
 
         if (hour > 12)
-                return 0x20 | BIN2BCD(hour - 12);
+                return 0x20 | bin2bcd(hour - 12);
         if (hour == 12)
-                return 0x20 | BIN2BCD(12);
+                return 0x20 | bin2bcd(12);
         if (hour == 0)
-                return BIN2BCD(12);
-        return BIN2BCD(hour);
+                return bin2bcd(12);
+        return bin2bcd(hour);
 }
 
 static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
@@ -180,18 +180,18 @@ static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         if (status < 0)
                 return status;
 
-        tm->tm_sec = BCD2BIN(rs5c->regs[RS5C372_REG_SECS] & 0x7f);
-        tm->tm_min = BCD2BIN(rs5c->regs[RS5C372_REG_MINS] & 0x7f);
+        tm->tm_sec = bcd2bin(rs5c->regs[RS5C372_REG_SECS] & 0x7f);
+        tm->tm_min = bcd2bin(rs5c->regs[RS5C372_REG_MINS] & 0x7f);
         tm->tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C372_REG_HOURS]);
 
-        tm->tm_wday = BCD2BIN(rs5c->regs[RS5C372_REG_WDAY] & 0x07);
-        tm->tm_mday = BCD2BIN(rs5c->regs[RS5C372_REG_DAY] & 0x3f);
+        tm->tm_wday = bcd2bin(rs5c->regs[RS5C372_REG_WDAY] & 0x07);
+        tm->tm_mday = bcd2bin(rs5c->regs[RS5C372_REG_DAY] & 0x3f);
 
         /* tm->tm_mon is zero-based */
-        tm->tm_mon = BCD2BIN(rs5c->regs[RS5C372_REG_MONTH] & 0x1f) - 1;
+        tm->tm_mon = bcd2bin(rs5c->regs[RS5C372_REG_MONTH] & 0x1f) - 1;
 
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(rs5c->regs[RS5C372_REG_YEAR]) + 100;
+        tm->tm_year = bcd2bin(rs5c->regs[RS5C372_REG_YEAR]) + 100;
 
         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                 "mday=%d, mon=%d, year=%d, wday=%d\n",
@@ -216,13 +216,13 @@ static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
                 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
         addr   = RS5C_ADDR(RS5C372_REG_SECS);
-        buf[0] = BIN2BCD(tm->tm_sec);
-        buf[1] = BIN2BCD(tm->tm_min);
+        buf[0] = bin2bcd(tm->tm_sec);
+        buf[1] = bin2bcd(tm->tm_min);
         buf[2] = rs5c_hr2reg(rs5c, tm->tm_hour);
-        buf[3] = BIN2BCD(tm->tm_wday);
-        buf[4] = BIN2BCD(tm->tm_mday);
-        buf[5] = BIN2BCD(tm->tm_mon + 1);
-        buf[6] = BIN2BCD(tm->tm_year - 100);
+        buf[3] = bin2bcd(tm->tm_wday);
+        buf[4] = bin2bcd(tm->tm_mday);
+        buf[5] = bin2bcd(tm->tm_mon + 1);
+        buf[6] = bin2bcd(tm->tm_year - 100);
 
         if (i2c_smbus_write_i2c_block_data(client, addr, sizeof(buf), buf) < 0) {
                 dev_err(&client->dev, "%s: write error\n", __func__);
@@ -367,7 +367,7 @@ static int rs5c_read_alarm(struct device *dev, struct rtc_wkalrm *t)
 
         /* report alarm time */
         t->time.tm_sec = 0;
-        t->time.tm_min = BCD2BIN(rs5c->regs[RS5C_REG_ALARM_A_MIN] & 0x7f);
+        t->time.tm_min = bcd2bin(rs5c->regs[RS5C_REG_ALARM_A_MIN] & 0x7f);
         t->time.tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C_REG_ALARM_A_HOURS]);
         t->time.tm_mday = -1;
         t->time.tm_mon = -1;
@@ -413,7 +413,7 @@ static int rs5c_set_alarm(struct device *dev, struct rtc_wkalrm *t)
         }
 
         /* set alarm */
-        buf[0] = BIN2BCD(t->time.tm_min);
+        buf[0] = bin2bcd(t->time.tm_min);
         buf[1] = rs5c_hr2reg(rs5c, t->time.tm_hour);
         buf[2] = 0x7f;  /* any/all days */
 
diff --git a/drivers/rtc/rtc-s35390a.c b/drivers/rtc/rtc-s35390a.c
index a6fa1f2f2ca6..def4d396d0b0 100644
--- a/drivers/rtc/rtc-s35390a.c
+++ b/drivers/rtc/rtc-s35390a.c
@@ -104,12 +104,12 @@ static int s35390a_disable_test_mode(struct s35390a *s35390a)
 static char s35390a_hr2reg(struct s35390a *s35390a, int hour)
 {
         if (s35390a->twentyfourhour)
-                return BIN2BCD(hour);
+                return bin2bcd(hour);
 
         if (hour < 12)
-                return BIN2BCD(hour);
+                return bin2bcd(hour);
 
-        return 0x40 | BIN2BCD(hour - 12);
+        return 0x40 | bin2bcd(hour - 12);
 }
 
 static int s35390a_reg2hr(struct s35390a *s35390a, char reg)
@@ -117,9 +117,9 @@ static int s35390a_reg2hr(struct s35390a *s35390a, char reg)
         unsigned hour;
 
         if (s35390a->twentyfourhour)
-                return BCD2BIN(reg & 0x3f);
+                return bcd2bin(reg & 0x3f);
 
-        hour = BCD2BIN(reg & 0x3f);
+        hour = bcd2bin(reg & 0x3f);
         if (reg & 0x40)
                 hour += 12;
 
@@ -137,13 +137,13 @@ static int s35390a_set_datetime(struct i2c_client *client, struct rtc_time *tm)
                 tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year,
                 tm->tm_wday);
 
-        buf[S35390A_BYTE_YEAR] = BIN2BCD(tm->tm_year - 100);
-        buf[S35390A_BYTE_MONTH] = BIN2BCD(tm->tm_mon + 1);
-        buf[S35390A_BYTE_DAY] = BIN2BCD(tm->tm_mday);
-        buf[S35390A_BYTE_WDAY] = BIN2BCD(tm->tm_wday);
+        buf[S35390A_BYTE_YEAR] = bin2bcd(tm->tm_year - 100);
+        buf[S35390A_BYTE_MONTH] = bin2bcd(tm->tm_mon + 1);
+        buf[S35390A_BYTE_DAY] = bin2bcd(tm->tm_mday);
+        buf[S35390A_BYTE_WDAY] = bin2bcd(tm->tm_wday);
         buf[S35390A_BYTE_HOURS] = s35390a_hr2reg(s35390a, tm->tm_hour);
-        buf[S35390A_BYTE_MINS] = BIN2BCD(tm->tm_min);
-        buf[S35390A_BYTE_SECS] = BIN2BCD(tm->tm_sec);
+        buf[S35390A_BYTE_MINS] = bin2bcd(tm->tm_min);
+        buf[S35390A_BYTE_SECS] = bin2bcd(tm->tm_sec);
 
         /* This chip expects the bits of each byte to be in reverse order */
         for (i = 0; i < 7; ++i)
@@ -168,13 +168,13 @@ static int s35390a_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         for (i = 0; i < 7; ++i)
                 buf[i] = bitrev8(buf[i]);
 
-        tm->tm_sec = BCD2BIN(buf[S35390A_BYTE_SECS]);
-        tm->tm_min = BCD2BIN(buf[S35390A_BYTE_MINS]);
+        tm->tm_sec = bcd2bin(buf[S35390A_BYTE_SECS]);
+        tm->tm_min = bcd2bin(buf[S35390A_BYTE_MINS]);
         tm->tm_hour = s35390a_reg2hr(s35390a, buf[S35390A_BYTE_HOURS]);
-        tm->tm_wday = BCD2BIN(buf[S35390A_BYTE_WDAY]);
-        tm->tm_mday = BCD2BIN(buf[S35390A_BYTE_DAY]);
-        tm->tm_mon = BCD2BIN(buf[S35390A_BYTE_MONTH]) - 1;
-        tm->tm_year = BCD2BIN(buf[S35390A_BYTE_YEAR]) + 100;
+        tm->tm_wday = bcd2bin(buf[S35390A_BYTE_WDAY]);
+        tm->tm_mday = bcd2bin(buf[S35390A_BYTE_DAY]);
+        tm->tm_mon = bcd2bin(buf[S35390A_BYTE_MONTH]) - 1;
+        tm->tm_year = bcd2bin(buf[S35390A_BYTE_YEAR]) + 100;
 
         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "
                 "mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec,
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index e7d19b6c265a..910bc704939c 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -134,12 +134,12 @@ static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
                  rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
                  rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
 
-        BCD_TO_BIN(rtc_tm->tm_sec);
-        BCD_TO_BIN(rtc_tm->tm_min);
-        BCD_TO_BIN(rtc_tm->tm_hour);
-        BCD_TO_BIN(rtc_tm->tm_mday);
-        BCD_TO_BIN(rtc_tm->tm_mon);
-        BCD_TO_BIN(rtc_tm->tm_year);
+        rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
+        rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
+        rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
+        rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
+        rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
+        rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
 
         rtc_tm->tm_year += 100;
         rtc_tm->tm_mon -= 1;
@@ -163,12 +163,12 @@ static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm)
                 return -EINVAL;
         }
 
-        writeb(BIN2BCD(tm->tm_sec),  base + S3C2410_RTCSEC);
-        writeb(BIN2BCD(tm->tm_min),  base + S3C2410_RTCMIN);
-        writeb(BIN2BCD(tm->tm_hour), base + S3C2410_RTCHOUR);
-        writeb(BIN2BCD(tm->tm_mday), base + S3C2410_RTCDATE);
-        writeb(BIN2BCD(tm->tm_mon + 1), base + S3C2410_RTCMON);
-        writeb(BIN2BCD(year), base + S3C2410_RTCYEAR);
+        writeb(bin2bcd(tm->tm_sec),  base + S3C2410_RTCSEC);
+        writeb(bin2bcd(tm->tm_min),  base + S3C2410_RTCMIN);
+        writeb(bin2bcd(tm->tm_hour), base + S3C2410_RTCHOUR);
+        writeb(bin2bcd(tm->tm_mday), base + S3C2410_RTCDATE);
+        writeb(bin2bcd(tm->tm_mon + 1), base + S3C2410_RTCMON);
+        writeb(bin2bcd(year), base + S3C2410_RTCYEAR);
 
         return 0;
 }
@@ -199,34 +199,34 @@ static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
         /* decode the alarm enable field */
 
         if (alm_en & S3C2410_RTCALM_SECEN)
-                BCD_TO_BIN(alm_tm->tm_sec);
+                alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
         else
                 alm_tm->tm_sec = 0xff;
 
         if (alm_en & S3C2410_RTCALM_MINEN)
-                BCD_TO_BIN(alm_tm->tm_min);
+                alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
         else
                 alm_tm->tm_min = 0xff;
 
         if (alm_en & S3C2410_RTCALM_HOUREN)
-                BCD_TO_BIN(alm_tm->tm_hour);
+                alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
         else
                 alm_tm->tm_hour = 0xff;
 
         if (alm_en & S3C2410_RTCALM_DAYEN)
-                BCD_TO_BIN(alm_tm->tm_mday);
+                alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);
         else
                 alm_tm->tm_mday = 0xff;
 
         if (alm_en & S3C2410_RTCALM_MONEN) {
-                BCD_TO_BIN(alm_tm->tm_mon);
+                alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);
                 alm_tm->tm_mon -= 1;
         } else {
                 alm_tm->tm_mon = 0xff;
         }
 
         if (alm_en & S3C2410_RTCALM_YEAREN)
-                BCD_TO_BIN(alm_tm->tm_year);
+                alm_tm->tm_year = bcd2bin(alm_tm->tm_year);
         else
                 alm_tm->tm_year = 0xffff;
 
@@ -250,17 +250,17 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
 
         if (tm->tm_sec < 60 && tm->tm_sec >= 0) {
                 alrm_en |= S3C2410_RTCALM_SECEN;
-                writeb(BIN2BCD(tm->tm_sec), base + S3C2410_ALMSEC);
+                writeb(bin2bcd(tm->tm_sec), base + S3C2410_ALMSEC);
         }
 
         if (tm->tm_min < 60 && tm->tm_min >= 0) {
                 alrm_en |= S3C2410_RTCALM_MINEN;
-                writeb(BIN2BCD(tm->tm_min), base + S3C2410_ALMMIN);
+                writeb(bin2bcd(tm->tm_min), base + S3C2410_ALMMIN);
         }
 
         if (tm->tm_hour < 24 && tm->tm_hour >= 0) {
                 alrm_en |= S3C2410_RTCALM_HOUREN;
-                writeb(BIN2BCD(tm->tm_hour), base + S3C2410_ALMHOUR);
+                writeb(bin2bcd(tm->tm_hour), base + S3C2410_ALMHOUR);
         }
 
         pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en);
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index fcead4c4cd1f..aaf9d6a337cc 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -324,23 +324,23 @@ static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm)
 
                 sec128 = readb(rtc->regbase + R64CNT);
 
-                tm->tm_sec      = BCD2BIN(readb(rtc->regbase + RSECCNT));
-                tm->tm_min      = BCD2BIN(readb(rtc->regbase + RMINCNT));
-                tm->tm_hour     = BCD2BIN(readb(rtc->regbase + RHRCNT));
-                tm->tm_wday     = BCD2BIN(readb(rtc->regbase + RWKCNT));
-                tm->tm_mday     = BCD2BIN(readb(rtc->regbase + RDAYCNT));
-                tm->tm_mon      = BCD2BIN(readb(rtc->regbase + RMONCNT)) - 1;
+                tm->tm_sec      = bcd2bin(readb(rtc->regbase + RSECCNT));
+                tm->tm_min      = bcd2bin(readb(rtc->regbase + RMINCNT));
+                tm->tm_hour     = bcd2bin(readb(rtc->regbase + RHRCNT));
+                tm->tm_wday     = bcd2bin(readb(rtc->regbase + RWKCNT));
+                tm->tm_mday     = bcd2bin(readb(rtc->regbase + RDAYCNT));
+                tm->tm_mon      = bcd2bin(readb(rtc->regbase + RMONCNT)) - 1;
 
                 if (rtc->capabilities & RTC_CAP_4_DIGIT_YEAR) {
                         yr  = readw(rtc->regbase + RYRCNT);
-                        yr100 = BCD2BIN(yr >> 8);
+                        yr100 = bcd2bin(yr >> 8);
                         yr &= 0xff;
                 } else {
                         yr  = readb(rtc->regbase + RYRCNT);
-                        yr100 = BCD2BIN((yr == 0x99) ? 0x19 : 0x20);
+                        yr100 = bcd2bin((yr == 0x99) ? 0x19 : 0x20);
                 }
 
-                tm->tm_year = (yr100 * 100 + BCD2BIN(yr)) - 1900;
+                tm->tm_year = (yr100 * 100 + bcd2bin(yr)) - 1900;
 
                 sec2 = readb(rtc->regbase + R64CNT);
                 cf_bit = readb(rtc->regbase + RCR1) & RCR1_CF;
@@ -382,20 +382,20 @@ static int sh_rtc_set_time(struct device *dev, struct rtc_time *tm)
         tmp &= ~RCR2_START;
         writeb(tmp, rtc->regbase + RCR2);
 
-        writeb(BIN2BCD(tm->tm_sec),  rtc->regbase + RSECCNT);
-        writeb(BIN2BCD(tm->tm_min),  rtc->regbase + RMINCNT);
-        writeb(BIN2BCD(tm->tm_hour), rtc->regbase + RHRCNT);
-        writeb(BIN2BCD(tm->tm_wday), rtc->regbase + RWKCNT);
-        writeb(BIN2BCD(tm->tm_mday), rtc->regbase + RDAYCNT);
-        writeb(BIN2BCD(tm->tm_mon + 1), rtc->regbase + RMONCNT);
+        writeb(bin2bcd(tm->tm_sec),  rtc->regbase + RSECCNT);
+        writeb(bin2bcd(tm->tm_min),  rtc->regbase + RMINCNT);
+        writeb(bin2bcd(tm->tm_hour), rtc->regbase + RHRCNT);
+        writeb(bin2bcd(tm->tm_wday), rtc->regbase + RWKCNT);
+        writeb(bin2bcd(tm->tm_mday), rtc->regbase + RDAYCNT);
+        writeb(bin2bcd(tm->tm_mon + 1), rtc->regbase + RMONCNT);
 
         if (rtc->capabilities & RTC_CAP_4_DIGIT_YEAR) {
-                year = (BIN2BCD((tm->tm_year + 1900) / 100) << 8) |
-                        BIN2BCD(tm->tm_year % 100);
+                year = (bin2bcd((tm->tm_year + 1900) / 100) << 8) |
+                        bin2bcd(tm->tm_year % 100);
                 writew(year, rtc->regbase + RYRCNT);
         } else {
                 year = tm->tm_year % 100;
-                writeb(BIN2BCD(year), rtc->regbase + RYRCNT);
+                writeb(bin2bcd(year), rtc->regbase + RYRCNT);
         }
 
         /* Start RTC */
@@ -417,7 +417,7 @@ static inline int sh_rtc_read_alarm_value(struct sh_rtc *rtc, int reg_off)
         byte = readb(rtc->regbase + reg_off);
         if (byte & AR_ENB) {
                 byte &= ~AR_ENB;        /* strip the enable bit */
-                value = BCD2BIN(byte);
+                value = bcd2bin(byte);
         }
 
         return value;
@@ -455,7 +455,7 @@ static inline void sh_rtc_write_alarm_value(struct sh_rtc *rtc,
         if (value < 0)
                 writeb(0, rtc->regbase + reg_off);
         else
-                writeb(BIN2BCD(value) | AR_ENB,  rtc->regbase + reg_off);
+                writeb(bin2bcd(value) | AR_ENB,  rtc->regbase + reg_off);
 }
 
 static int sh_rtc_check_alarm(struct rtc_time *tm)
@@ -568,7 +568,7 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
         struct sh_rtc *rtc;
         struct resource *res;
         unsigned int tmp;
-        int ret = -ENOENT;
+        int ret;
 
         rtc = kzalloc(sizeof(struct sh_rtc), GFP_KERNEL);
         if (unlikely(!rtc))
@@ -577,26 +577,33 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
         spin_lock_init(&rtc->lock);
 
         /* get periodic/carry/alarm irqs */
-        rtc->periodic_irq = platform_get_irq(pdev, 0);
-        if (unlikely(rtc->periodic_irq < 0)) {
+        ret = platform_get_irq(pdev, 0);
+        if (unlikely(ret < 0)) {
+                ret = -ENOENT;
                 dev_err(&pdev->dev, "No IRQ for period\n");
                 goto err_badres;
         }
+        rtc->periodic_irq = ret;
 
-        rtc->carry_irq = platform_get_irq(pdev, 1);
-        if (unlikely(rtc->carry_irq < 0)) {
+        ret = platform_get_irq(pdev, 1);
+        if (unlikely(ret < 0)) {
+                ret = -ENOENT;
                 dev_err(&pdev->dev, "No IRQ for carry\n");
                 goto err_badres;
         }
+        rtc->carry_irq = ret;
 
-        rtc->alarm_irq = platform_get_irq(pdev, 2);
-        if (unlikely(rtc->alarm_irq < 0)) {
+        ret = platform_get_irq(pdev, 2);
+        if (unlikely(ret < 0)) {
+                ret = -ENOENT;
                 dev_err(&pdev->dev, "No IRQ for alarm\n");
                 goto err_badres;
         }
+        rtc->alarm_irq = ret;
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
         if (unlikely(res == NULL)) {
+                ret = -ENOENT;
                 dev_err(&pdev->dev, "No IO resource\n");
                 goto err_badres;
         }
diff --git a/drivers/rtc/rtc-stk17ta8.c b/drivers/rtc/rtc-stk17ta8.c
index 9a7e920315fa..f4cd46e15af9 100644
--- a/drivers/rtc/rtc-stk17ta8.c
+++ b/drivers/rtc/rtc-stk17ta8.c
@@ -82,14 +82,14 @@ static int stk17ta8_rtc_set_time(struct device *dev, struct rtc_time *tm)
         flags = readb(pdata->ioaddr + RTC_FLAGS);
         writeb(flags | RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
 
-        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
-        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
-        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
-        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
-        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
-        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
-        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
-        writeb(BIN2BCD((tm->tm_year + 1900) / 100), ioaddr + RTC_CENTURY);
+        writeb(bin2bcd(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(bin2bcd(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(bin2bcd(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(bin2bcd(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(bin2bcd(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(bin2bcd(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(bin2bcd(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+        writeb(bin2bcd((tm->tm_year + 1900) / 100), ioaddr + RTC_CENTURY);
 
         writeb(flags & ~RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
         return 0;
@@ -120,14 +120,14 @@ static int stk17ta8_rtc_read_time(struct device *dev, struct rtc_time *tm)
         year = readb(ioaddr + RTC_YEAR);
         century = readb(ioaddr + RTC_CENTURY);
         writeb(flags & ~RTC_READ, ioaddr + RTC_FLAGS);
-        tm->tm_sec = BCD2BIN(second);
-        tm->tm_min = BCD2BIN(minute);
-        tm->tm_hour = BCD2BIN(hour);
-        tm->tm_mday = BCD2BIN(day);
-        tm->tm_wday = BCD2BIN(week);
-        tm->tm_mon = BCD2BIN(month) - 1;
+        tm->tm_sec = bcd2bin(second);
+        tm->tm_min = bcd2bin(minute);
+        tm->tm_hour = bcd2bin(hour);
+        tm->tm_mday = bcd2bin(day);
+        tm->tm_wday = bcd2bin(week);
+        tm->tm_mon = bcd2bin(month) - 1;
         /* year is 1900 + tm->tm_year */
-        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+        tm->tm_year = bcd2bin(year) + bcd2bin(century) * 100 - 1900;
 
         if (rtc_valid_tm(tm) < 0) {
                 dev_err(dev, "retrieved date/time is not valid.\n");
@@ -148,16 +148,16 @@ static void stk17ta8_rtc_update_alarm(struct rtc_plat_data *pdata)
         writeb(flags | RTC_WRITE, ioaddr + RTC_FLAGS);
 
         writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_mday),
+               0x80 : bin2bcd(pdata->alrm_mday),
                ioaddr + RTC_DATE_ALARM);
         writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_hour),
+               0x80 : bin2bcd(pdata->alrm_hour),
                ioaddr + RTC_HOURS_ALARM);
         writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_min),
+               0x80 : bin2bcd(pdata->alrm_min),
                ioaddr + RTC_MINUTES_ALARM);
         writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
-               0x80 : BIN2BCD(pdata->alrm_sec),
+               0x80 : bin2bcd(pdata->alrm_sec),
                ioaddr + RTC_SECONDS_ALARM);
         writeb(pdata->irqen ? RTC_INTS_AIE : 0, ioaddr + RTC_INTERRUPTS);
         readb(ioaddr + RTC_FLAGS);      /* clear interrupts */
@@ -280,7 +280,6 @@ static struct bin_attribute stk17ta8_nvram_attr = {
         .attr = {
                 .name = "nvram",
                 .mode = S_IRUGO | S_IWUSR,
-                .owner = THIS_MODULE,
         },
         .size = RTC_OFFSET,
         .read = stk17ta8_nvram_read,
diff --git a/drivers/rtc/rtc-v3020.c b/drivers/rtc/rtc-v3020.c
index 10025d840268..14d4f036a768 100644
--- a/drivers/rtc/rtc-v3020.c
+++ b/drivers/rtc/rtc-v3020.c
@@ -92,19 +92,19 @@ static int v3020_read_time(struct device *dev, struct rtc_time *dt)
 
         /* ...and then read constant values. */
         tmp = v3020_get_reg(chip, V3020_SECONDS);
-        dt->tm_sec      = BCD2BIN(tmp);
+        dt->tm_sec      = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_MINUTES);
-        dt->tm_min      = BCD2BIN(tmp);
+        dt->tm_min      = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_HOURS);
-        dt->tm_hour     = BCD2BIN(tmp);
+        dt->tm_hour     = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_MONTH_DAY);
-        dt->tm_mday     = BCD2BIN(tmp);
+        dt->tm_mday     = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_MONTH);
-        dt->tm_mon    = BCD2BIN(tmp) - 1;
+        dt->tm_mon    = bcd2bin(tmp) - 1;
         tmp = v3020_get_reg(chip, V3020_WEEK_DAY);
-        dt->tm_wday     = BCD2BIN(tmp);
+        dt->tm_wday     = bcd2bin(tmp);
         tmp = v3020_get_reg(chip, V3020_YEAR);
-        dt->tm_year = BCD2BIN(tmp)+100;
+        dt->tm_year = bcd2bin(tmp)+100;
 
 #ifdef DEBUG
         printk("\n%s : Read RTC values\n",__func__);
@@ -136,13 +136,13 @@ static int v3020_set_time(struct device *dev, struct rtc_time *dt)
 #endif
 
         /* Write all the values to ram... */
-        v3020_set_reg(chip, V3020_SECONDS,      BIN2BCD(dt->tm_sec));
-        v3020_set_reg(chip, V3020_MINUTES,      BIN2BCD(dt->tm_min));
-        v3020_set_reg(chip, V3020_HOURS,        BIN2BCD(dt->tm_hour));
-        v3020_set_reg(chip, V3020_MONTH_DAY,    BIN2BCD(dt->tm_mday));
-        v3020_set_reg(chip, V3020_MONTH,     BIN2BCD(dt->tm_mon + 1));
-        v3020_set_reg(chip, V3020_WEEK_DAY,     BIN2BCD(dt->tm_wday));
-        v3020_set_reg(chip, V3020_YEAR,         BIN2BCD(dt->tm_year % 100));
+        v3020_set_reg(chip, V3020_SECONDS,      bin2bcd(dt->tm_sec));
+        v3020_set_reg(chip, V3020_MINUTES,      bin2bcd(dt->tm_min));
+        v3020_set_reg(chip, V3020_HOURS,        bin2bcd(dt->tm_hour));
+        v3020_set_reg(chip, V3020_MONTH_DAY,    bin2bcd(dt->tm_mday));
+        v3020_set_reg(chip, V3020_MONTH,     bin2bcd(dt->tm_mon + 1));
+        v3020_set_reg(chip, V3020_WEEK_DAY,     bin2bcd(dt->tm_wday));
+        v3020_set_reg(chip, V3020_YEAR,         bin2bcd(dt->tm_year % 100));
 
         /* ...and set the clock. */
         v3020_set_reg(chip, V3020_CMD_RAM2CLOCK, 0);
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index 884b635f028b..834dcc6d785f 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -360,7 +360,7 @@ static int __devinit rtc_probe(struct platform_device *pdev)
         spin_unlock_irq(&rtc_lock);
 
         aie_irq = platform_get_irq(pdev, 0);
-        if (aie_irq < 0 || aie_irq >= NR_IRQS) {
+        if (aie_irq < 0 || aie_irq >= nr_irqs) {
                 retval = -EBUSY;
                 goto err_device_unregister;
         }
@@ -371,7 +371,7 @@ static int __devinit rtc_probe(struct platform_device *pdev)
                 goto err_device_unregister;
 
         pie_irq = platform_get_irq(pdev, 1);
-        if (pie_irq < 0 || pie_irq >= NR_IRQS)
+        if (pie_irq < 0 || pie_irq >= nr_irqs)
                 goto err_free_irq;
 
         retval = request_irq(pie_irq, rtclong1_interrupt, IRQF_DISABLED,
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index 7dcfba1bbfe1..310c10795e9a 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -118,13 +118,13 @@ static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
                 for (i = 0; i <= 4; i++)
                         buf[i] &= 0x7F;
 
-        tm->tm_sec = BCD2BIN(buf[CCR_SEC]);
-        tm->tm_min = BCD2BIN(buf[CCR_MIN]);
-        tm->tm_hour = BCD2BIN(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
-        tm->tm_mday = BCD2BIN(buf[CCR_MDAY]);
-        tm->tm_mon = BCD2BIN(buf[CCR_MONTH]) - 1; /* mon is 0-11 */
-        tm->tm_year = BCD2BIN(buf[CCR_YEAR])
-                        + (BCD2BIN(buf[CCR_Y2K]) * 100) - 1900;
+        tm->tm_sec = bcd2bin(buf[CCR_SEC]);
+        tm->tm_min = bcd2bin(buf[CCR_MIN]);
+        tm->tm_hour = bcd2bin(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
+        tm->tm_mday = bcd2bin(buf[CCR_MDAY]);
+        tm->tm_mon = bcd2bin(buf[CCR_MONTH]) - 1; /* mon is 0-11 */
+        tm->tm_year = bcd2bin(buf[CCR_YEAR])
+                        + (bcd2bin(buf[CCR_Y2K]) * 100) - 1900;
         tm->tm_wday = buf[CCR_WDAY];
 
         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
@@ -174,11 +174,11 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
                 __func__,
                 tm->tm_sec, tm->tm_min, tm->tm_hour);
 
-        buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
-        buf[CCR_MIN] = BIN2BCD(tm->tm_min);
+        buf[CCR_SEC] = bin2bcd(tm->tm_sec);
+        buf[CCR_MIN] = bin2bcd(tm->tm_min);
 
         /* set hour and 24hr bit */
-        buf[CCR_HOUR] = BIN2BCD(tm->tm_hour) | X1205_HR_MIL;
+        buf[CCR_HOUR] = bin2bcd(tm->tm_hour) | X1205_HR_MIL;
 
         /* should we also set the date? */
         if (datetoo) {
@@ -187,15 +187,15 @@ static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
                         __func__,
                         tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
-                buf[CCR_MDAY] = BIN2BCD(tm->tm_mday);
+                buf[CCR_MDAY] = bin2bcd(tm->tm_mday);
 
                 /* month, 1 - 12 */
-                buf[CCR_MONTH] = BIN2BCD(tm->tm_mon + 1);
+                buf[CCR_MONTH] = bin2bcd(tm->tm_mon + 1);
 
                 /* year, since the rtc epoch*/
-                buf[CCR_YEAR] = BIN2BCD(tm->tm_year % 100);
+                buf[CCR_YEAR] = bin2bcd(tm->tm_year % 100);
                 buf[CCR_WDAY] = tm->tm_wday & 0x07;
-                buf[CCR_Y2K] = BIN2BCD(tm->tm_year / 100);
+                buf[CCR_Y2K] = bin2bcd(tm->tm_year / 100);
         }
 
         /* If writing alarm registers, set compare bits on registers 0-4 */
@@ -437,7 +437,7 @@ static int x1205_validate_client(struct i2c_client *client)
                         return -EIO;
                 }
 
-                value = BCD2BIN(reg & probe_limits_pattern[i].mask);
+                value = bcd2bin(reg & probe_limits_pattern[i].mask);
 
                 if (value > probe_limits_pattern[i].max ||
                         value < probe_limits_pattern[i].min) {
diff --git a/drivers/scsi/aha152x.c b/drivers/scsi/aha152x.c
index b5a868d85eb4..1e5478abd90e 100644
--- a/drivers/scsi/aha152x.c
+++ b/drivers/scsi/aha152x.c
@@ -337,7 +337,7 @@ CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
 #else
 #define IRQ_MIN 9
 #if defined(__PPC)
-#define IRQ_MAX (NR_IRQS-1)
+#define IRQ_MAX (nr_irqs-1)
 #else
 #define IRQ_MAX 12
 #endif
diff --git a/drivers/scsi/arcmsr/arcmsr_attr.c b/drivers/scsi/arcmsr/arcmsr_attr.c
index 69f8346aa288..5877f29a6005 100644
--- a/drivers/scsi/arcmsr/arcmsr_attr.c
+++ b/drivers/scsi/arcmsr/arcmsr_attr.c
@@ -189,7 +189,6 @@ static struct bin_attribute arcmsr_sysfs_message_read_attr = {
         .attr = {
                 .name = "mu_read",
                 .mode = S_IRUSR ,
-                .owner = THIS_MODULE,
         },
         .size = 1032,
         .read = arcmsr_sysfs_iop_message_read,
@@ -199,7 +198,6 @@ static struct bin_attribute arcmsr_sysfs_message_write_attr = {
         .attr = {
                 .name = "mu_write",
                 .mode = S_IWUSR,
-                .owner = THIS_MODULE,
         },
         .size = 1032,
         .write = arcmsr_sysfs_iop_message_write,
@@ -209,7 +207,6 @@ static struct bin_attribute arcmsr_sysfs_message_clear_attr = {
         .attr = {
                 .name = "mu_clear",
                 .mode = S_IWUSR,
-                .owner = THIS_MODULE,
         },
         .size = 1,
         .write = arcmsr_sysfs_iop_message_clear,
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 740bad435995..afc96e844a25 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -343,6 +343,11 @@ static ide_startstop_t idescsi_do_request (ide_drive_t *drive, struct request *r
 }
 
 #ifdef CONFIG_IDE_PROC_FS
+static ide_proc_entry_t idescsi_proc[] = {
+        { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL },
+        { NULL, 0, NULL, NULL }
+};
+
 #define ide_scsi_devset_get(name, field) \
 static int get_##name(ide_drive_t *drive) \
 { \
@@ -378,6 +383,16 @@ static const struct ide_proc_devset idescsi_settings[] = {
         IDE_PROC_DEVSET(transform, 0,    3),
         { 0 },
 };
+
+static ide_proc_entry_t *ide_scsi_proc_entries(ide_drive_t *drive)
+{
+        return idescsi_proc;
+}
+
+static const struct ide_proc_devset *ide_scsi_proc_devsets(ide_drive_t *drive)
+{
+        return idescsi_settings;
+}
 #endif
 
 /*
@@ -419,13 +434,6 @@ static void ide_scsi_remove(ide_drive_t *drive)
 
 static int ide_scsi_probe(ide_drive_t *);
 
-#ifdef CONFIG_IDE_PROC_FS
-static ide_proc_entry_t idescsi_proc[] = {
-        { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL },
-        { NULL, 0, NULL, NULL }
-};
-#endif
-
 static ide_driver_t idescsi_driver = {
         .gen_driver = {
                 .owner          = THIS_MODULE,
@@ -439,8 +447,8 @@ static ide_driver_t idescsi_driver = {
         .end_request            = idescsi_end_request,
         .error                  = idescsi_atapi_error,
 #ifdef CONFIG_IDE_PROC_FS
-        .proc                   = idescsi_proc,
-        .settings               = idescsi_settings,
+        .proc_entries           = ide_scsi_proc_entries,
+        .proc_devsets           = ide_scsi_proc_devsets,
 #endif
 };
 
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index d30eb7ba018e..098739deb02e 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -7859,7 +7859,6 @@ static struct pci_driver ipr_driver = {
         .remove = ipr_remove,
         .shutdown = ipr_shutdown,
         .err_handler = &ipr_err_handler,
-        .dynids.use_driver_data = 1
 };
 
 /**
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 83c819216771..f25f41a499e5 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -2108,7 +2108,7 @@ struct scsi_qla_host;
 
 struct qla_msix_entry {
         int have_irq;
-        uint16_t msix_vector;
+        uint32_t msix_vector;
         uint16_t msix_entry;
 };
 
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 2aed4721c0d0..21dd182ad512 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1566,9 +1566,8 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                         goto probe_out;
         }
 
-        if (pci_find_aer_capability(pdev))
-                if (pci_enable_pcie_error_reporting(pdev))
-                        goto probe_out;
+        /* This may fail but that's ok */
+        pci_enable_pcie_error_reporting(pdev);
 
         host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t));
         if (host == NULL) {
diff --git a/drivers/scsi/sr_vendor.c b/drivers/scsi/sr_vendor.c
index 4eb3da996b36..4ad3e017213f 100644
--- a/drivers/scsi/sr_vendor.c
+++ b/drivers/scsi/sr_vendor.c
@@ -223,9 +223,9 @@ int sr_cd_check(struct cdrom_device_info *cdi)
                                 no_multi = 1;
                                 break;
                         }
-                        min = BCD2BIN(buffer[15]);
-                        sec = BCD2BIN(buffer[16]);
-                        frame = BCD2BIN(buffer[17]);
+                        min = bcd2bin(buffer[15]);
+                        sec = bcd2bin(buffer[16]);
+                        frame = bcd2bin(buffer[17]);
                         sector = min * CD_SECS * CD_FRAMES + sec * CD_FRAMES + frame;
                         break;
                 }
@@ -252,9 +252,9 @@ int sr_cd_check(struct cdrom_device_info *cdi)
                         }
                         if (rc != 0)
                                 break;
-                        min = BCD2BIN(buffer[1]);
-                        sec = BCD2BIN(buffer[2]);
-                        frame = BCD2BIN(buffer[3]);
+                        min = bcd2bin(buffer[1]);
+                        sec = bcd2bin(buffer[2]);
+                        frame = bcd2bin(buffer[3]);
                         sector = min * CD_SECS * CD_FRAMES + sec * CD_FRAMES + frame;
                         if (sector)
                                 sector -= CD_MSF_OFFSET;
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index 381b12ac20e0..d935b2d04f93 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -66,7 +66,6 @@
 #endif
 
 static struct m68k_serial m68k_soft[NR_PORTS];
-struct m68k_serial *IRQ_ports[NR_IRQS];
 
 static unsigned int uart_irqs[NR_PORTS] = UART_IRQ_DEFNS;
 
@@ -375,15 +374,11 @@ clear_and_return:
  */
 irqreturn_t rs_interrupt(int irq, void *dev_id)
 {
-        struct m68k_serial * info;
+        struct m68k_serial *info = dev_id;
         m68328_uart *uart;
         unsigned short rx;
         unsigned short tx;
 
-        info = IRQ_ports[irq];
-        if(!info)
-            return IRQ_NONE;
-
         uart = &uart_addr[info->line];
         rx = uart->urx.w;
 
@@ -1383,8 +1378,6 @@ rs68328_init(void)
                    info->port, info->irq);
             printk(" is a builtin MC68328 UART\n");
             
-            IRQ_ports[info->irq] = info;        /* waste of space */
-
 #ifdef CONFIG_M68VZ328
                 if (i > 0 )
                         PJSEL &= 0xCF;  /* PSW enable second port output */
@@ -1393,7 +1386,7 @@ rs68328_init(void)
             if (request_irq(uart_irqs[i],
                             rs_interrupt,
                             IRQF_DISABLED,
-                            "M68328_UART", NULL))
+                            "M68328_UART", info))
                 panic("Unable to attach 68328 serial interrupt\n");
         }
         local_irq_restore(flags);
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 1528de23a650..303272af386e 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -156,11 +156,15 @@ struct uart_8250_port {
 };
 
 struct irq_info {
-        spinlock_t              lock;
+        struct                  hlist_node node;
+        int                     irq;
+        spinlock_t              lock;   /* Protects list not the hash */
         struct list_head        *head;
 };
 
-static struct irq_info irq_lists[NR_IRQS];
+#define NR_IRQ_HASH             32      /* Can be adjusted later */
+static struct hlist_head irq_lists[NR_IRQ_HASH];
+static DEFINE_MUTEX(hash_mutex);        /* Used to walk the hash */
 
 /*
  * Here we define the default xmit fifo size used for each type of UART.
@@ -1545,15 +1549,43 @@ static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
                 BUG_ON(i->head != &up->list);
                 i->head = NULL;
         }
-
         spin_unlock_irq(&i->lock);
+        /* List empty so throw away the hash node */
+        if (i->head == NULL) {
+                hlist_del(&i->node);
+                kfree(i);
+        }
 }
 
 static int serial_link_irq_chain(struct uart_8250_port *up)
 {
-        struct irq_info *i = irq_lists + up->port.irq;
+        struct hlist_head *h;
+        struct hlist_node *n;
+        struct irq_info *i;
         int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0;
 
+        mutex_lock(&hash_mutex);
+
+        h = &irq_lists[up->port.irq % NR_IRQ_HASH];
+
+        hlist_for_each(n, h) {
+                i = hlist_entry(n, struct irq_info, node);
+                if (i->irq == up->port.irq)
+                        break;
+        }
+
+        if (n == NULL) {
+                i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
+                if (i == NULL) {
+                        mutex_unlock(&hash_mutex);
+                        return -ENOMEM;
+                }
+                spin_lock_init(&i->lock);
+                i->irq = up->port.irq;
+                hlist_add_head(&i->node, h);
+        }
+        mutex_unlock(&hash_mutex);
+
         spin_lock_irq(&i->lock);
 
         if (i->head) {
@@ -1577,14 +1609,28 @@ static int serial_link_irq_chain(struct uart_8250_port *up)
 
 static void serial_unlink_irq_chain(struct uart_8250_port *up)
 {
-        struct irq_info *i = irq_lists + up->port.irq;
+        struct irq_info *i;
+        struct hlist_node *n;
+        struct hlist_head *h;
 
+        mutex_lock(&hash_mutex);
+
+        h = &irq_lists[up->port.irq % NR_IRQ_HASH];
+
+        hlist_for_each(n, h) {
+                i = hlist_entry(n, struct irq_info, node);
+                if (i->irq == up->port.irq)
+                        break;
+        }
+
+        BUG_ON(n == NULL);
         BUG_ON(i->head == NULL);
 
         if (list_empty(i->head))
                 free_irq(up->port.irq, i);
 
         serial_do_unlink(i, up);
+        mutex_unlock(&hash_mutex);
 }
 
 /* Base timer interval for polling */
@@ -2447,7 +2493,7 @@ static void serial8250_config_port(struct uart_port *port, int flags)
 static int
 serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-        if (ser->irq >= NR_IRQS || ser->irq < 0 ||
+        if (ser->irq >= nr_irqs || ser->irq < 0 ||
             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
             ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS ||
             ser->type == PORT_STARTECH)
@@ -2967,7 +3013,7 @@ EXPORT_SYMBOL(serial8250_unregister_port);
 
 static int __init serial8250_init(void)
 {
-        int ret, i;
+        int ret;
 
         if (nr_uarts > UART_NR)
                 nr_uarts = UART_NR;
@@ -2976,9 +3022,6 @@ static int __init serial8250_init(void)
                 "%d ports, IRQ sharing %sabled\n", nr_uarts,
                 share_irqs ? "en" : "dis");
 
-        for (i = 0; i < NR_IRQS; i++)
-                spin_lock_init(&irq_lists[i].lock);
-
 #ifdef CONFIG_SPARC
         ret = sunserial_register_minors(&serial8250_reg, UART_NR);
 #else
@@ -3006,15 +3049,15 @@ static int __init serial8250_init(void)
                 goto out;
 
         platform_device_del(serial8250_isa_devs);
- put_dev:
+put_dev:
         platform_device_put(serial8250_isa_devs);
- unreg_uart_drv:
+unreg_uart_drv:
 #ifdef CONFIG_SPARC
         sunserial_unregister_minors(&serial8250_reg, UART_NR);
 #else
         uart_unregister_driver(&serial8250_reg);
 #endif
- out:
+out:
         return ret;
 }
 
diff --git a/drivers/serial/8250_gsc.c b/drivers/serial/8250_gsc.c
index 0416ad3bc127..418b4fe9a0a1 100644
--- a/drivers/serial/8250_gsc.c
+++ b/drivers/serial/8250_gsc.c
@@ -111,7 +111,7 @@ static struct parisc_driver serial_driver = {
         .probe          = serial_init_chip,
 };
 
-int __init probe_serial_gsc(void)
+static int __init probe_serial_gsc(void)
 {
         register_parisc_driver(&lasi_driver);
         register_parisc_driver(&serial_driver);
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index 90b56c2c31e2..71562689116f 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -512,7 +512,7 @@ static int pl010_verify_port(struct uart_port *port, struct serial_struct *ser)
         int ret = 0;
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_AMBA)
                 ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 ret = -EINVAL;
         if (ser->baud_base < 9600)
                 ret = -EINVAL;
diff --git a/drivers/serial/amba-pl011.c b/drivers/serial/amba-pl011.c
index 9d08f27208a1..b7180046f8db 100644
--- a/drivers/serial/amba-pl011.c
+++ b/drivers/serial/amba-pl011.c
@@ -572,7 +572,7 @@ static int pl010_verify_port(struct uart_port *port, struct serial_struct *ser)
         int ret = 0;
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_AMBA)
                 ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 ret = -EINVAL;
         if (ser->baud_base < 9600)
                 ret = -EINVAL;
diff --git a/drivers/serial/cpm_uart/cpm_uart_core.c b/drivers/serial/cpm_uart/cpm_uart_core.c
index a6c4d744495e..bde4b4b0b80f 100644
--- a/drivers/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/serial/cpm_uart/cpm_uart_core.c
@@ -623,7 +623,7 @@ static int cpm_uart_verify_port(struct uart_port *port,
 
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_CPM)
                 ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 ret = -EINVAL;
         if (ser->baud_base < 9600)
                 ret = -EINVAL;
diff --git a/drivers/serial/m32r_sio.c b/drivers/serial/m32r_sio.c
index 23d030511019..611c97a15654 100644
--- a/drivers/serial/m32r_sio.c
+++ b/drivers/serial/m32r_sio.c
@@ -922,7 +922,7 @@ static void m32r_sio_config_port(struct uart_port *port, int flags)
 static int
 m32r_sio_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-        if (ser->irq >= NR_IRQS || ser->irq < 0 ||
+        if (ser->irq >= nr_irqs || ser->irq < 0 ||
             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
             ser->type >= ARRAY_SIZE(uart_config))
                 return -EINVAL;
@@ -1162,7 +1162,7 @@ static int __init m32r_sio_init(void)
 
         printk(KERN_INFO "Serial: M32R SIO driver\n");
 
-        for (i = 0; i < NR_IRQS; i++)
+        for (i = 0; i < nr_irqs; i++)
                 spin_lock_init(&irq_lists[i].lock);
 
         ret = uart_register_driver(&m32r_sio_reg);
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 6bdf3362e3b1..874786a11fe9 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -741,7 +741,7 @@ static int uart_set_info(struct uart_state *state,
         if (port->ops->verify_port)
                 retval = port->ops->verify_port(port, &new_serial);
 
-        if ((new_serial.irq >= NR_IRQS) || (new_serial.irq < 0) ||
+        if ((new_serial.irq >= nr_irqs) || (new_serial.irq < 0) ||
             (new_serial.baud_base < 9600))
                 retval = -EINVAL;
 
diff --git a/drivers/serial/serial_lh7a40x.c b/drivers/serial/serial_lh7a40x.c
index cb49a5ac022f..61dc8b3daa26 100644
--- a/drivers/serial/serial_lh7a40x.c
+++ b/drivers/serial/serial_lh7a40x.c
@@ -460,7 +460,7 @@ static int lh7a40xuart_verify_port (struct uart_port* port,
 
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_LH7A40X)
                 ret = -EINVAL;
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 ret = -EINVAL;
         if (ser->baud_base < 9600) /* *** FIXME: is this true? */
                 ret = -EINVAL;
diff --git a/drivers/serial/serial_txx9.c b/drivers/serial/serial_txx9.c
index 8fcb4c5b9a26..7313c2edcb83 100644
--- a/drivers/serial/serial_txx9.c
+++ b/drivers/serial/serial_txx9.c
@@ -1039,7 +1039,7 @@ static int __devinit serial_txx9_probe(struct platform_device *dev)
                 ret = serial_txx9_register_port(&port);
                 if (ret < 0) {
                         dev_err(&dev->dev, "unable to register port at index %d "
-                                "(IO%x MEM%llx IRQ%d): %d\n", i,
+                                "(IO%lx MEM%llx IRQ%d): %d\n", i,
                                 p->iobase, (unsigned long long)p->mapbase,
                                 p->irq, ret);
                 }
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 3df2aaec829f..f0658d2c45b2 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -3,7 +3,7 @@
  *
  * SuperH on-chip serial module support.  (SCI with no FIFO / with FIFO)
  *
- *  Copyright (C) 2002 - 2006  Paul Mundt
+ *  Copyright (C) 2002 - 2008  Paul Mundt
  *  Modified to support SH7720 SCIF. Markus Brunner, Mark Jonas (Jul 2007).
  *
  * based off of the old drivers/char/sh-sci.c by:
@@ -46,6 +46,7 @@
 #include <linux/cpufreq.h>
 #include <linux/clk.h>
 #include <linux/ctype.h>
+#include <linux/err.h>
 
 #ifdef CONFIG_SUPERH
 #include <asm/clock.h>
@@ -78,7 +79,7 @@ struct sci_port {
         struct timer_list       break_timer;
         int                     break_flag;
 
-#ifdef CONFIG_SUPERH
+#ifdef CONFIG_HAVE_CLK
         /* Port clock */
         struct clk              *clk;
 #endif
@@ -831,7 +832,7 @@ static irqreturn_t sci_mpxed_interrupt(int irq, void *ptr)
         return IRQ_HANDLED;
 }
 
-#ifdef CONFIG_CPU_FREQ
+#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_HAVE_CLK)
 /*
  * Here we define a transistion notifier so that we can update all of our
  * ports' baud rate when the peripheral clock changes.
@@ -860,7 +861,7 @@ static int sci_notifier(struct notifier_block *self,
                          * Clean this up later..
                          */
                         clk = clk_get(NULL, "module_clk");
-                        port->uartclk = clk_get_rate(clk) * 16;
+                        port->uartclk = clk_get_rate(clk);
                         clk_put(clk);
                 }
 
@@ -873,7 +874,7 @@ static int sci_notifier(struct notifier_block *self,
 }
 
 static struct notifier_block sci_nb = { &sci_notifier, NULL, 0 };
-#endif /* CONFIG_CPU_FREQ */
+#endif /* CONFIG_CPU_FREQ && CONFIG_HAVE_CLK */
 
 static int sci_request_irq(struct sci_port *port)
 {
@@ -1008,7 +1009,7 @@ static int sci_startup(struct uart_port *port)
         if (s->enable)
                 s->enable(port);
 
-#if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
+#ifdef CONFIG_HAVE_CLK
         s->clk = clk_get(NULL, "module_clk");
 #endif
 
@@ -1030,7 +1031,7 @@ static void sci_shutdown(struct uart_port *port)
         if (s->disable)
                 s->disable(port);
 
-#if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
+#ifdef CONFIG_HAVE_CLK
         clk_put(s->clk);
         s->clk = NULL;
 #endif
@@ -1041,24 +1042,11 @@ static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
 {
         struct sci_port *s = &sci_ports[port->line];
         unsigned int status, baud, smr_val;
-        int t;
+        int t = -1;
 
         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
-
-        switch (baud) {
-                case 0:
-                        t = -1;
-                        break;
-                default:
-                {
-#if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
-                        t = SCBRR_VALUE(baud, clk_get_rate(s->clk));
-#else
-                        t = SCBRR_VALUE(baud);
-#endif
-                        break;
-                }
-        }
+        if (likely(baud))
+                t = SCBRR_VALUE(baud, port->uartclk);
 
         do {
                 status = sci_in(port, SCxSR);
@@ -1113,7 +1101,7 @@ static const char *sci_type(struct uart_port *port)
                 case PORT_IRDA: return "irda";
         }
 
-        return 0;
+        return NULL;
 }
 
 static void sci_release_port(struct uart_port *port)
@@ -1145,19 +1133,23 @@ static void sci_config_port(struct uart_port *port, int flags)
                 break;
         }
 
-#if defined(CONFIG_CPU_SUBTYPE_SH5_101) || defined(CONFIG_CPU_SUBTYPE_SH5_103)
-        if (port->mapbase == 0)
+        if (port->flags & UPF_IOREMAP && !port->membase) {
+#if defined(CONFIG_SUPERH64)
                 port->mapbase = onchip_remap(SCIF_ADDR_SH5, 1024, "SCIF");
-
-        port->membase = (void __iomem *)port->mapbase;
+                port->membase = (void __iomem *)port->mapbase;
+#else
+                port->membase = ioremap_nocache(port->mapbase, 0x40);
 #endif
+
+                printk(KERN_ERR "sci: can't remap port#%d\n", port->line);
+        }
 }
 
 static int sci_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
         struct sci_port *s = &sci_ports[port->line];
 
-        if (ser->irq != s->irqs[SCIx_TXI_IRQ] || ser->irq > NR_IRQS)
+        if (ser->irq != s->irqs[SCIx_TXI_IRQ] || ser->irq > nr_irqs)
                 return -EINVAL;
         if (ser->baud_base < 2400)
                 /* No paper tape reader for Mitch.. */
@@ -1207,17 +1199,17 @@ static void __init sci_init_ports(void)
                 sci_ports[i].disable    = h8300_sci_disable;
 #endif
                 sci_ports[i].port.uartclk = CONFIG_CPU_CLOCK;
-#elif defined(CONFIG_SUPERH64)
-                sci_ports[i].port.uartclk = current_cpu_data.module_clock * 16;
-#else
+#elif defined(CONFIG_HAVE_CLK)
                 /*
                  * XXX: We should use a proper SCI/SCIF clock
                  */
                 {
                         struct clk *clk = clk_get(NULL, "module_clk");
-                        sci_ports[i].port.uartclk = clk_get_rate(clk) * 16;
+                        sci_ports[i].port.uartclk = clk_get_rate(clk);
                         clk_put(clk);
                 }
+#else
+#error "Need a valid uartclk"
 #endif
 
                 sci_ports[i].break_timer.data = (unsigned long)&sci_ports[i];
@@ -1285,7 +1277,7 @@ static int __init serial_console_setup(struct console *co, char *options)
 
         port->type = serial_console_port->type;
 
-#if defined(CONFIG_SUPERH) && !defined(CONFIG_SUPERH64)
+#ifdef CONFIG_HAVE_CLK
         if (!serial_console_port->clk)
                 serial_console_port->clk = clk_get(NULL, "module_clk");
 #endif
@@ -1436,7 +1428,7 @@ static struct uart_driver sci_uart_driver = {
 static int __devinit sci_probe(struct platform_device *dev)
 {
         struct plat_sci_port *p = dev->dev.platform_data;
-        int i;
+        int i, ret = -EINVAL;
 
         for (i = 0; p && p->flags != 0; p++, i++) {
                 struct sci_port *sciport = &sci_ports[i];
@@ -1453,12 +1445,22 @@ static int __devinit sci_probe(struct platform_device *dev)
 
                 sciport->port.mapbase   = p->mapbase;
 
-                /*
-                 * For the simple (and majority of) cases where we don't need
-                 * to do any remapping, just cast the cookie directly.
-                 */
-                if (p->mapbase && !p->membase && !(p->flags & UPF_IOREMAP))
-                        p->membase = (void __iomem *)p->mapbase;
+                if (p->mapbase && !p->membase) {
+                        if (p->flags & UPF_IOREMAP) {
+                                p->membase = ioremap_nocache(p->mapbase, 0x40);
+                                if (IS_ERR(p->membase)) {
+                                        ret = PTR_ERR(p->membase);
+                                        goto err_unreg;
+                                }
+                        } else {
+                                /*
+                                 * For the simple (and majority of) cases
+                                 * where we don't need to do any remapping,
+                                 * just cast the cookie directly.
+                                 */
+                                p->membase = (void __iomem *)p->mapbase;
+                        }
+                }
 
                 sciport->port.membase   = p->membase;
 
@@ -1479,7 +1481,7 @@ static int __devinit sci_probe(struct platform_device *dev)
         kgdb_putchar    = kgdb_sci_putchar;
 #endif
 
-#ifdef CONFIG_CPU_FREQ
+#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_HAVE_CLK)
         cpufreq_register_notifier(&sci_nb, CPUFREQ_TRANSITION_NOTIFIER);
         dev_info(&dev->dev, "CPU frequency notifier registered\n");
 #endif
@@ -1489,6 +1491,12 @@ static int __devinit sci_probe(struct platform_device *dev)
 #endif
 
         return 0;
+
+err_unreg:
+        for (i = i - 1; i >= 0; i--)
+                uart_remove_one_port(&sci_uart_driver, &sci_ports[i].port);
+
+        return ret;
 }
 
 static int __devexit sci_remove(struct platform_device *dev)
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index 8a0749e34ca3..7cd28b226800 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -320,18 +320,16 @@
 #define SCI_EVENT_WRITE_WAKEUP  0
 
 #define SCI_IN(size, offset)                                    \
-  unsigned int addr = port->mapbase + (offset);                 \
   if ((size) == 8) {                                            \
-    return ctrl_inb(addr);                                      \
+    return ioread8(port->membase + (offset));                   \
   } else {                                                      \
-    return ctrl_inw(addr);                                      \
+    return ioread16(port->membase + (offset));                  \
   }
 #define SCI_OUT(size, offset, value)                            \
-  unsigned int addr = port->mapbase + (offset);                 \
   if ((size) == 8) {                                            \
-    ctrl_outb(value, addr);                                     \
+    iowrite8(value, port->membase + (offset));                  \
   } else if ((size) == 16) {                                    \
-    ctrl_outw(value, addr);                                     \
+    iowrite16(value, port->membase + (offset));                 \
   }
 
 #define CPU_SCIx_FNS(name, sci_offset, sci_size, scif_offset, scif_size)\
@@ -791,11 +789,16 @@ static inline int sci_rxd_in(struct uart_port *port)
       defined(CONFIG_CPU_SUBTYPE_SH7721)
 #define SCBRR_VALUE(bps, clk) (((clk*2)+16*bps)/(32*bps)-1)
 #elif defined(CONFIG_CPU_SUBTYPE_SH7723)
-#define SCBRR_VALUE(bps, clk) (((clk*2)+16*bps)/(16*bps)-1)
+static inline int scbrr_calc(struct uart_port *port, int bps, int clk)
+{
+        if (port->type == PORT_SCIF)
+                return (clk+16*bps)/(32*bps)-1;
+        else
+                return ((clk*2)+16*bps)/(16*bps)-1;
+}
+#define SCBRR_VALUE(bps, clk) scbrr_calc(port, bps, clk)
 #elif defined(__H8300H__) || defined(__H8300S__)
-#define SCBRR_VALUE(bps) (((CONFIG_CPU_CLOCK*1000/32)/bps)-1)
-#elif defined(CONFIG_SUPERH64)
-#define SCBRR_VALUE(bps) ((current_cpu_data.module_clock+16*bps)/(32*bps)-1)
+#define SCBRR_VALUE(bps, clk) (((clk*1000/32)/bps)-1)
 #else /* Generic SH */
 #define SCBRR_VALUE(bps, clk) ((clk+16*bps)/(32*bps)-1)
 #endif
diff --git a/drivers/serial/sn_console.c b/drivers/serial/sn_console.c
index b73e3c0056cd..d5276c012f78 100644
--- a/drivers/serial/sn_console.c
+++ b/drivers/serial/sn_console.c
@@ -61,7 +61,7 @@
 #define SN_SAL_BUFFER_SIZE (64 * (1 << 10))
 
 #define SN_SAL_UART_FIFO_DEPTH 16
-#define SN_SAL_UART_FIFO_SPEED_CPS 9600/10
+#define SN_SAL_UART_FIFO_SPEED_CPS (9600/10)
 
 /* sn_transmit_chars() calling args */
 #define TRANSMIT_BUFFERED       0
diff --git a/drivers/serial/ucc_uart.c b/drivers/serial/ucc_uart.c
index 539c933b335f..315a9333ca3c 100644
--- a/drivers/serial/ucc_uart.c
+++ b/drivers/serial/ucc_uart.c
@@ -1066,7 +1066,7 @@ static int qe_uart_verify_port(struct uart_port *port,
         if (ser->type != PORT_UNKNOWN && ser->type != PORT_CPM)
                 return -EINVAL;
 
-        if (ser->irq < 0 || ser->irq >= NR_IRQS)
+        if (ser->irq < 0 || ser->irq >= nr_irqs)
                 return -EINVAL;
 
         if (ser->baud_base < 9600)
diff --git a/drivers/sh/Makefile b/drivers/sh/Makefile
index a96f4a8cfeb8..6a025cefe6dc 100644
--- a/drivers/sh/Makefile
+++ b/drivers/sh/Makefile
@@ -1,6 +1,6 @@
 #
 # Makefile for the SuperH specific drivers.
 #
-
 obj-$(CONFIG_SUPERHYWAY)        += superhyway/
 obj-$(CONFIG_MAPLE)             += maple/
+obj-y                           += intc.o
diff --git a/drivers/sh/intc.c b/drivers/sh/intc.c
new file mode 100644
index 000000000000..58d24c5a76ce
--- /dev/null
+++ b/drivers/sh/intc.c
@@ -0,0 +1,713 @@
+/*
+ * Shared interrupt handling code for IPR and INTC2 types of IRQs.
+ *
+ * Copyright (C) 2007, 2008 Magnus Damm
+ *
+ * Based on intc2.c and ipr.c
+ *
+ * Copyright (C) 1999  Niibe Yutaka & Takeshi Yaegashi
+ * Copyright (C) 2000  Kazumoto Kojima
+ * Copyright (C) 2001  David J. Mckay (david.mckay@st.com)
+ * Copyright (C) 2003  Takashi Kusuda <kusuda-takashi@hitachi-ul.co.jp>
+ * Copyright (C) 2005, 2006  Paul Mundt
+ *
+ * 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/init.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/io.h>
+#include <linux/interrupt.h>
+#include <linux/bootmem.h>
+#include <linux/sh_intc.h>
+
+#define _INTC_MK(fn, mode, addr_e, addr_d, width, shift) \
+        ((shift) | ((width) << 5) | ((fn) << 9) | ((mode) << 13) | \
+         ((addr_e) << 16) | ((addr_d << 24)))
+
+#define _INTC_SHIFT(h) (h & 0x1f)
+#define _INTC_WIDTH(h) ((h >> 5) & 0xf)
+#define _INTC_FN(h) ((h >> 9) & 0xf)
+#define _INTC_MODE(h) ((h >> 13) & 0x7)
+#define _INTC_ADDR_E(h) ((h >> 16) & 0xff)
+#define _INTC_ADDR_D(h) ((h >> 24) & 0xff)
+
+struct intc_handle_int {
+        unsigned int irq;
+        unsigned long handle;
+};
+
+struct intc_desc_int {
+        unsigned long *reg;
+#ifdef CONFIG_SMP
+        unsigned long *smp;
+#endif
+        unsigned int nr_reg;
+        struct intc_handle_int *prio;
+        unsigned int nr_prio;
+        struct intc_handle_int *sense;
+        unsigned int nr_sense;
+        struct irq_chip chip;
+};
+
+#ifdef CONFIG_SMP
+#define IS_SMP(x) x.smp
+#define INTC_REG(d, x, c) (d->reg[(x)] + ((d->smp[(x)] & 0xff) * c))
+#define SMP_NR(d, x) ((d->smp[(x)] >> 8) ? (d->smp[(x)] >> 8) : 1)
+#else
+#define IS_SMP(x) 0
+#define INTC_REG(d, x, c) (d->reg[(x)])
+#define SMP_NR(d, x) 1
+#endif
+
+static unsigned int intc_prio_level[NR_IRQS]; /* for now */
+#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
+static unsigned long ack_handle[NR_IRQS];
+#endif
+
+static inline struct intc_desc_int *get_intc_desc(unsigned int irq)
+{
+        struct irq_chip *chip = get_irq_chip(irq);
+        return (void *)((char *)chip - offsetof(struct intc_desc_int, chip));
+}
+
+static inline unsigned int set_field(unsigned int value,
+                                     unsigned int field_value,
+                                     unsigned int handle)
+{
+        unsigned int width = _INTC_WIDTH(handle);
+        unsigned int shift = _INTC_SHIFT(handle);
+
+        value &= ~(((1 << width) - 1) << shift);
+        value |= field_value << shift;
+        return value;
+}
+
+static void write_8(unsigned long addr, unsigned long h, unsigned long data)
+{
+        __raw_writeb(set_field(0, data, h), addr);
+}
+
+static void write_16(unsigned long addr, unsigned long h, unsigned long data)
+{
+        __raw_writew(set_field(0, data, h), addr);
+}
+
+static void write_32(unsigned long addr, unsigned long h, unsigned long data)
+{
+        __raw_writel(set_field(0, data, h), addr);
+}
+
+static void modify_8(unsigned long addr, unsigned long h, unsigned long data)
+{
+        unsigned long flags;
+        local_irq_save(flags);
+        __raw_writeb(set_field(__raw_readb(addr), data, h), addr);
+        local_irq_restore(flags);
+}
+
+static void modify_16(unsigned long addr, unsigned long h, unsigned long data)
+{
+        unsigned long flags;
+        local_irq_save(flags);
+        __raw_writew(set_field(__raw_readw(addr), data, h), addr);
+        local_irq_restore(flags);
+}
+
+static void modify_32(unsigned long addr, unsigned long h, unsigned long data)
+{
+        unsigned long flags;
+        local_irq_save(flags);
+        __raw_writel(set_field(__raw_readl(addr), data, h), addr);
+        local_irq_restore(flags);
+}
+
+enum {  REG_FN_ERR = 0, REG_FN_WRITE_BASE = 1, REG_FN_MODIFY_BASE = 5 };
+
+static void (*intc_reg_fns[])(unsigned long addr,
+                              unsigned long h,
+                              unsigned long data) = {
+        [REG_FN_WRITE_BASE + 0] = write_8,
+        [REG_FN_WRITE_BASE + 1] = write_16,
+        [REG_FN_WRITE_BASE + 3] = write_32,
+        [REG_FN_MODIFY_BASE + 0] = modify_8,
+        [REG_FN_MODIFY_BASE + 1] = modify_16,
+        [REG_FN_MODIFY_BASE + 3] = modify_32,
+};
+
+enum {  MODE_ENABLE_REG = 0, /* Bit(s) set -> interrupt enabled */
+        MODE_MASK_REG,       /* Bit(s) set -> interrupt disabled */
+        MODE_DUAL_REG,       /* Two registers, set bit to enable / disable */
+        MODE_PRIO_REG,       /* Priority value written to enable interrupt */
+        MODE_PCLR_REG,       /* Above plus all bits set to disable interrupt */
+};
+
+static void intc_mode_field(unsigned long addr,
+                            unsigned long handle,
+                            void (*fn)(unsigned long,
+                                       unsigned long,
+                                       unsigned long),
+                            unsigned int irq)
+{
+        fn(addr, handle, ((1 << _INTC_WIDTH(handle)) - 1));
+}
+
+static void intc_mode_zero(unsigned long addr,
+                           unsigned long handle,
+                           void (*fn)(unsigned long,
+                                       unsigned long,
+                                       unsigned long),
+                           unsigned int irq)
+{
+        fn(addr, handle, 0);
+}
+
+static void intc_mode_prio(unsigned long addr,
+                           unsigned long handle,
+                           void (*fn)(unsigned long,
+                                       unsigned long,
+                                       unsigned long),
+                           unsigned int irq)
+{
+        fn(addr, handle, intc_prio_level[irq]);
+}
+
+static void (*intc_enable_fns[])(unsigned long addr,
+                                 unsigned long handle,
+                                 void (*fn)(unsigned long,
+                                            unsigned long,
+                                            unsigned long),
+                                 unsigned int irq) = {
+        [MODE_ENABLE_REG] = intc_mode_field,
+        [MODE_MASK_REG] = intc_mode_zero,
+        [MODE_DUAL_REG] = intc_mode_field,
+        [MODE_PRIO_REG] = intc_mode_prio,
+        [MODE_PCLR_REG] = intc_mode_prio,
+};
+
+static void (*intc_disable_fns[])(unsigned long addr,
+                                  unsigned long handle,
+                                  void (*fn)(unsigned long,
+                                             unsigned long,
+                                             unsigned long),
+                                  unsigned int irq) = {
+        [MODE_ENABLE_REG] = intc_mode_zero,
+        [MODE_MASK_REG] = intc_mode_field,
+        [MODE_DUAL_REG] = intc_mode_field,
+        [MODE_PRIO_REG] = intc_mode_zero,
+        [MODE_PCLR_REG] = intc_mode_field,
+};
+
+static inline void _intc_enable(unsigned int irq, unsigned long handle)
+{
+        struct intc_desc_int *d = get_intc_desc(irq);
+        unsigned long addr;
+        unsigned int cpu;
+
+        for (cpu = 0; cpu < SMP_NR(d, _INTC_ADDR_E(handle)); cpu++) {
+                addr = INTC_REG(d, _INTC_ADDR_E(handle), cpu);
+                intc_enable_fns[_INTC_MODE(handle)](addr, handle, intc_reg_fns\
+                                                    [_INTC_FN(handle)], irq);
+        }
+}
+
+static void intc_enable(unsigned int irq)
+{
+        _intc_enable(irq, (unsigned long)get_irq_chip_data(irq));
+}
+
+static void intc_disable(unsigned int irq)
+{
+        struct intc_desc_int *d = get_intc_desc(irq);
+        unsigned long handle = (unsigned long) get_irq_chip_data(irq);
+        unsigned long addr;
+        unsigned int cpu;
+
+        for (cpu = 0; cpu < SMP_NR(d, _INTC_ADDR_D(handle)); cpu++) {
+                addr = INTC_REG(d, _INTC_ADDR_D(handle), cpu);
+                intc_disable_fns[_INTC_MODE(handle)](addr, handle,intc_reg_fns\
+                                                     [_INTC_FN(handle)], irq);
+        }
+}
+
+#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
+static void intc_mask_ack(unsigned int irq)
+{
+        struct intc_desc_int *d = get_intc_desc(irq);
+        unsigned long handle = ack_handle[irq];
+        unsigned long addr;
+
+        intc_disable(irq);
+
+        /* read register and write zero only to the assocaited bit */
+
+        if (handle) {
+                addr = INTC_REG(d, _INTC_ADDR_D(handle), 0);
+                switch (_INTC_FN(handle)) {
+                case REG_FN_MODIFY_BASE + 0:    /* 8bit */
+                        __raw_readb(addr);
+                        __raw_writeb(0xff ^ set_field(0, 1, handle), addr);
+                        break;
+                case REG_FN_MODIFY_BASE + 1:    /* 16bit */
+                        __raw_readw(addr);
+                        __raw_writew(0xffff ^ set_field(0, 1, handle), addr);
+                        break;
+                case REG_FN_MODIFY_BASE + 3:    /* 32bit */
+                        __raw_readl(addr);
+                        __raw_writel(0xffffffff ^ set_field(0, 1, handle), addr);
+                        break;
+                default:
+                        BUG();
+                        break;
+                }
+        }
+}
+#endif
+
+static struct intc_handle_int *intc_find_irq(struct intc_handle_int *hp,
+                                             unsigned int nr_hp,
+                                             unsigned int irq)
+{
+        int i;
+
+        /* this doesn't scale well, but...
+         *
+         * this function should only be used for cerain uncommon
+         * operations such as intc_set_priority() and intc_set_sense()
+         * and in those rare cases performance doesn't matter that much.
+         * keeping the memory footprint low is more important.
+         *
+         * one rather simple way to speed this up and still keep the
+         * memory footprint down is to make sure the array is sorted
+         * and then perform a bisect to lookup the irq.
+         */
+
+        for (i = 0; i < nr_hp; i++) {
+                if ((hp + i)->irq != irq)
+                        continue;
+
+                return hp + i;
+        }
+
+        return NULL;
+}
+
+int intc_set_priority(unsigned int irq, unsigned int prio)
+{
+        struct intc_desc_int *d = get_intc_desc(irq);
+        struct intc_handle_int *ihp;
+
+        if (!intc_prio_level[irq] || prio <= 1)
+                return -EINVAL;
+
+        ihp = intc_find_irq(d->prio, d->nr_prio, irq);
+        if (ihp) {
+                if (prio >= (1 << _INTC_WIDTH(ihp->handle)))
+                        return -EINVAL;
+
+                intc_prio_level[irq] = prio;
+
+                /*
+                 * only set secondary masking method directly
+                 * primary masking method is using intc_prio_level[irq]
+                 * priority level will be set during next enable()
+                 */
+
+                if (_INTC_FN(ihp->handle) != REG_FN_ERR)
+                        _intc_enable(irq, ihp->handle);
+        }
+        return 0;
+}
+
+#define VALID(x) (x | 0x80)
+
+static unsigned char intc_irq_sense_table[IRQ_TYPE_SENSE_MASK + 1] = {
+        [IRQ_TYPE_EDGE_FALLING] = VALID(0),
+        [IRQ_TYPE_EDGE_RISING] = VALID(1),
+        [IRQ_TYPE_LEVEL_LOW] = VALID(2),
+        /* SH7706, SH7707 and SH7709 do not support high level triggered */
+#if !defined(CONFIG_CPU_SUBTYPE_SH7706) && \
+    !defined(CONFIG_CPU_SUBTYPE_SH7707) && \
+    !defined(CONFIG_CPU_SUBTYPE_SH7709)
+        [IRQ_TYPE_LEVEL_HIGH] = VALID(3),
+#endif
+};
+
+static int intc_set_sense(unsigned int irq, unsigned int type)
+{
+        struct intc_desc_int *d = get_intc_desc(irq);
+        unsigned char value = intc_irq_sense_table[type & IRQ_TYPE_SENSE_MASK];
+        struct intc_handle_int *ihp;
+        unsigned long addr;
+
+        if (!value)
+                return -EINVAL;
+
+        ihp = intc_find_irq(d->sense, d->nr_sense, irq);
+        if (ihp) {
+                addr = INTC_REG(d, _INTC_ADDR_E(ihp->handle), 0);
+                intc_reg_fns[_INTC_FN(ihp->handle)](addr, ihp->handle, value);
+        }
+        return 0;
+}
+
+static unsigned int __init intc_get_reg(struct intc_desc_int *d,
+                                 unsigned long address)
+{
+        unsigned int k;
+
+        for (k = 0; k < d->nr_reg; k++) {
+                if (d->reg[k] == address)
+                        return k;
+        }
+
+        BUG();
+        return 0;
+}
+
+static intc_enum __init intc_grp_id(struct intc_desc *desc,
+                                    intc_enum enum_id)
+{
+        struct intc_group *g = desc->groups;
+        unsigned int i, j;
+
+        for (i = 0; g && enum_id && i < desc->nr_groups; i++) {
+                g = desc->groups + i;
+
+                for (j = 0; g->enum_ids[j]; j++) {
+                        if (g->enum_ids[j] != enum_id)
+                                continue;
+
+                        return g->enum_id;
+                }
+        }
+
+        return 0;
+}
+
+static unsigned int __init intc_mask_data(struct intc_desc *desc,
+                                          struct intc_desc_int *d,
+                                          intc_enum enum_id, int do_grps)
+{
+        struct intc_mask_reg *mr = desc->mask_regs;
+        unsigned int i, j, fn, mode;
+        unsigned long reg_e, reg_d;
+
+        for (i = 0; mr && enum_id && i < desc->nr_mask_regs; i++) {
+                mr = desc->mask_regs + i;
+
+                for (j = 0; j < ARRAY_SIZE(mr->enum_ids); j++) {
+                        if (mr->enum_ids[j] != enum_id)
+                                continue;
+
+                        if (mr->set_reg && mr->clr_reg) {
+                                fn = REG_FN_WRITE_BASE;
+                                mode = MODE_DUAL_REG;
+                                reg_e = mr->clr_reg;
+                                reg_d = mr->set_reg;
+                        } else {
+                                fn = REG_FN_MODIFY_BASE;
+                                if (mr->set_reg) {
+                                        mode = MODE_ENABLE_REG;
+                                        reg_e = mr->set_reg;
+                                        reg_d = mr->set_reg;
+                                } else {
+                                        mode = MODE_MASK_REG;
+                                        reg_e = mr->clr_reg;
+                                        reg_d = mr->clr_reg;
+                                }
+                        }
+
+                        fn += (mr->reg_width >> 3) - 1;
+                        return _INTC_MK(fn, mode,
+                                        intc_get_reg(d, reg_e),
+                                        intc_get_reg(d, reg_d),
+                                        1,
+                                        (mr->reg_width - 1) - j);
+                }
+        }
+
+        if (do_grps)
+                return intc_mask_data(desc, d, intc_grp_id(desc, enum_id), 0);
+
+        return 0;
+}
+
+static unsigned int __init intc_prio_data(struct intc_desc *desc,
+                                          struct intc_desc_int *d,
+                                          intc_enum enum_id, int do_grps)
+{
+        struct intc_prio_reg *pr = desc->prio_regs;
+        unsigned int i, j, fn, mode, bit;
+        unsigned long reg_e, reg_d;
+
+        for (i = 0; pr && enum_id && i < desc->nr_prio_regs; i++) {
+                pr = desc->prio_regs + i;
+
+                for (j = 0; j < ARRAY_SIZE(pr->enum_ids); j++) {
+                        if (pr->enum_ids[j] != enum_id)
+                                continue;
+
+                        if (pr->set_reg && pr->clr_reg) {
+                                fn = REG_FN_WRITE_BASE;
+                                mode = MODE_PCLR_REG;
+                                reg_e = pr->set_reg;
+                                reg_d = pr->clr_reg;
+                        } else {
+                                fn = REG_FN_MODIFY_BASE;
+                                mode = MODE_PRIO_REG;
+                                if (!pr->set_reg)
+                                        BUG();
+                                reg_e = pr->set_reg;
+                                reg_d = pr->set_reg;
+                        }
+
+                        fn += (pr->reg_width >> 3) - 1;
+
+                        BUG_ON((j + 1) * pr->field_width > pr->reg_width);
+
+                        bit = pr->reg_width - ((j + 1) * pr->field_width);
+
+                        return _INTC_MK(fn, mode,
+                                        intc_get_reg(d, reg_e),
+                                        intc_get_reg(d, reg_d),
+                                        pr->field_width, bit);
+                }
+        }
+
+        if (do_grps)
+                return intc_prio_data(desc, d, intc_grp_id(desc, enum_id), 0);
+
+        return 0;
+}
+
+#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
+static unsigned int __init intc_ack_data(struct intc_desc *desc,
+                                          struct intc_desc_int *d,
+                                          intc_enum enum_id)
+{
+        struct intc_mask_reg *mr = desc->ack_regs;
+        unsigned int i, j, fn, mode;
+        unsigned long reg_e, reg_d;
+
+        for (i = 0; mr && enum_id && i < desc->nr_ack_regs; i++) {
+                mr = desc->ack_regs + i;
+
+                for (j = 0; j < ARRAY_SIZE(mr->enum_ids); j++) {
+                        if (mr->enum_ids[j] != enum_id)
+                                continue;
+
+                        fn = REG_FN_MODIFY_BASE;
+                        mode = MODE_ENABLE_REG;
+                        reg_e = mr->set_reg;
+                        reg_d = mr->set_reg;
+
+                        fn += (mr->reg_width >> 3) - 1;
+                        return _INTC_MK(fn, mode,
+                                        intc_get_reg(d, reg_e),
+                                        intc_get_reg(d, reg_d),
+                                        1,
+                                        (mr->reg_width - 1) - j);
+                }
+        }
+
+        return 0;
+}
+#endif
+
+static unsigned int __init intc_sense_data(struct intc_desc *desc,
+                                           struct intc_desc_int *d,
+                                           intc_enum enum_id)
+{
+        struct intc_sense_reg *sr = desc->sense_regs;
+        unsigned int i, j, fn, bit;
+
+        for (i = 0; sr && enum_id && i < desc->nr_sense_regs; i++) {
+                sr = desc->sense_regs + i;
+
+                for (j = 0; j < ARRAY_SIZE(sr->enum_ids); j++) {
+                        if (sr->enum_ids[j] != enum_id)
+                                continue;
+
+                        fn = REG_FN_MODIFY_BASE;
+                        fn += (sr->reg_width >> 3) - 1;
+
+                        BUG_ON((j + 1) * sr->field_width > sr->reg_width);
+
+                        bit = sr->reg_width - ((j + 1) * sr->field_width);
+
+                        return _INTC_MK(fn, 0, intc_get_reg(d, sr->reg),
+                                        0, sr->field_width, bit);
+                }
+        }
+
+        return 0;
+}
+
+static void __init intc_register_irq(struct intc_desc *desc,
+                                     struct intc_desc_int *d,
+                                     intc_enum enum_id,
+                                     unsigned int irq)
+{
+        struct intc_handle_int *hp;
+        unsigned int data[2], primary;
+
+        /* Prefer single interrupt source bitmap over other combinations:
+         * 1. bitmap, single interrupt source
+         * 2. priority, single interrupt source
+         * 3. bitmap, multiple interrupt sources (groups)
+         * 4. priority, multiple interrupt sources (groups)
+         */
+
+        data[0] = intc_mask_data(desc, d, enum_id, 0);
+        data[1] = intc_prio_data(desc, d, enum_id, 0);
+
+        primary = 0;
+        if (!data[0] && data[1])
+                primary = 1;
+
+        data[0] = data[0] ? data[0] : intc_mask_data(desc, d, enum_id, 1);
+        data[1] = data[1] ? data[1] : intc_prio_data(desc, d, enum_id, 1);
+
+        if (!data[primary])
+                primary ^= 1;
+
+        BUG_ON(!data[primary]); /* must have primary masking method */
+
+        disable_irq_nosync(irq);
+        set_irq_chip_and_handler_name(irq, &d->chip,
+                                      handle_level_irq, "level");
+        set_irq_chip_data(irq, (void *)data[primary]);
+
+        /* set priority level
+         * - this needs to be at least 2 for 5-bit priorities on 7780
+         */
+        intc_prio_level[irq] = 2;
+
+        /* enable secondary masking method if present */
+        if (data[!primary])
+                _intc_enable(irq, data[!primary]);
+
+        /* add irq to d->prio list if priority is available */
+        if (data[1]) {
+                hp = d->prio + d->nr_prio;
+                hp->irq = irq;
+                hp->handle = data[1];
+
+                if (primary) {
+                        /*
+                         * only secondary priority should access registers, so
+                         * set _INTC_FN(h) = REG_FN_ERR for intc_set_priority()
+                         */
+
+                        hp->handle &= ~_INTC_MK(0x0f, 0, 0, 0, 0, 0);
+                        hp->handle |= _INTC_MK(REG_FN_ERR, 0, 0, 0, 0, 0);
+                }
+                d->nr_prio++;
+        }
+
+        /* add irq to d->sense list if sense is available */
+        data[0] = intc_sense_data(desc, d, enum_id);
+        if (data[0]) {
+                (d->sense + d->nr_sense)->irq = irq;
+                (d->sense + d->nr_sense)->handle = data[0];
+                d->nr_sense++;
+        }
+
+        /* irq should be disabled by default */
+        d->chip.mask(irq);
+
+#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
+        if (desc->ack_regs)
+                ack_handle[irq] = intc_ack_data(desc, d, enum_id);
+#endif
+}
+
+static unsigned int __init save_reg(struct intc_desc_int *d,
+                                    unsigned int cnt,
+                                    unsigned long value,
+                                    unsigned int smp)
+{
+        if (value) {
+                d->reg[cnt] = value;
+#ifdef CONFIG_SMP
+                d->smp[cnt] = smp;
+#endif
+                return 1;
+        }
+
+        return 0;
+}
+
+
+void __init register_intc_controller(struct intc_desc *desc)
+{
+        unsigned int i, k, smp;
+        struct intc_desc_int *d;
+
+        d = alloc_bootmem(sizeof(*d));
+
+        d->nr_reg = desc->mask_regs ? desc->nr_mask_regs * 2 : 0;
+        d->nr_reg += desc->prio_regs ? desc->nr_prio_regs * 2 : 0;
+        d->nr_reg += desc->sense_regs ? desc->nr_sense_regs : 0;
+
+#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
+        d->nr_reg += desc->ack_regs ? desc->nr_ack_regs : 0;
+#endif
+        d->reg = alloc_bootmem(d->nr_reg * sizeof(*d->reg));
+#ifdef CONFIG_SMP
+        d->smp = alloc_bootmem(d->nr_reg * sizeof(*d->smp));
+#endif
+        k = 0;
+
+        if (desc->mask_regs) {
+                for (i = 0; i < desc->nr_mask_regs; i++) {
+                        smp = IS_SMP(desc->mask_regs[i]);
+                        k += save_reg(d, k, desc->mask_regs[i].set_reg, smp);
+                        k += save_reg(d, k, desc->mask_regs[i].clr_reg, smp);
+                }
+        }
+
+        if (desc->prio_regs) {
+                d->prio = alloc_bootmem(desc->nr_vectors * sizeof(*d->prio));
+
+                for (i = 0; i < desc->nr_prio_regs; i++) {
+                        smp = IS_SMP(desc->prio_regs[i]);
+                        k += save_reg(d, k, desc->prio_regs[i].set_reg, smp);
+                        k += save_reg(d, k, desc->prio_regs[i].clr_reg, smp);
+                }
+        }
+
+        if (desc->sense_regs) {
+                d->sense = alloc_bootmem(desc->nr_vectors * sizeof(*d->sense));
+
+                for (i = 0; i < desc->nr_sense_regs; i++) {
+                        k += save_reg(d, k, desc->sense_regs[i].reg, 0);
+                }
+        }
+
+        d->chip.name = desc->name;
+        d->chip.mask = intc_disable;
+        d->chip.unmask = intc_enable;
+        d->chip.mask_ack = intc_disable;
+        d->chip.set_type = intc_set_sense;
+
+#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
+        if (desc->ack_regs) {
+                for (i = 0; i < desc->nr_ack_regs; i++)
+                        k += save_reg(d, k, desc->ack_regs[i].set_reg, 0);
+
+                d->chip.mask_ack = intc_mask_ack;
+        }
+#endif
+
+        BUG_ON(k > 256); /* _INTC_ADDR_E() and _INTC_ADDR_D() are 8 bits */
+
+        for (i = 0; i < desc->nr_vectors; i++) {
+                struct intc_vect *vect = desc->vectors + i;
+
+                intc_register_irq(desc, d, vect->enum_id, evt2irq(vect->vect));
+        }
+}
diff --git a/drivers/staging/go7007/Kconfig b/drivers/staging/go7007/Kconfig
index 57a121c338c4..593fdb767aad 100644
--- a/drivers/staging/go7007/Kconfig
+++ b/drivers/staging/go7007/Kconfig
@@ -1,10 +1,12 @@
 config VIDEO_GO7007
         tristate "Go 7007 support"
         depends on VIDEO_DEV && PCI && I2C && INPUT
+        depends on SND
         select VIDEOBUF_DMA_SG
         select VIDEO_IR
         select VIDEO_TUNER
         select VIDEO_TVEEPROM
+        select SND_PCM
         select CRC32
         default N
         ---help---
diff --git a/drivers/staging/sxg/Kconfig b/drivers/staging/sxg/Kconfig
index 1ae350806600..6e6cf0b9ef99 100644
--- a/drivers/staging/sxg/Kconfig
+++ b/drivers/staging/sxg/Kconfig
@@ -1,6 +1,7 @@
 config SXG
         tristate "Alacritech SLIC Technology Non-Accelerated 10Gbe support"
         depends on PCI && NETDEV_10000
+        depends on X86
         default n
         help
           This driver supports the Alacritech SLIC Technology Non-Accelerated
diff --git a/drivers/telephony/phonedev.c b/drivers/telephony/phonedev.c
index 4d74ba36c3a1..37caf4d69037 100644
--- a/drivers/telephony/phonedev.c
+++ b/drivers/telephony/phonedev.c
@@ -54,7 +54,6 @@ static int phone_open(struct inode *inode, struct file *file)
         if (minor >= PHONE_NUM_DEVICES)
                 return -ENODEV;
 
-        lock_kernel();
         mutex_lock(&phone_lock);
         p = phone_device[minor];
         if (p)
@@ -81,7 +80,6 @@ static int phone_open(struct inode *inode, struct file *file)
         fops_put(old_fops);
 end:
         mutex_unlock(&phone_lock);
-        unlock_kernel();
         return err;
 }
 
diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
index 5dccf057a7dd..f9b4647255aa 100644
--- a/drivers/uio/uio.c
+++ b/drivers/uio/uio.c
@@ -47,6 +47,9 @@ static struct uio_class {
         struct class *class;
 } *uio_class;
 
+/* Protect idr accesses */
+static DEFINE_MUTEX(minor_lock);
+
 /*
  * attributes
  */
@@ -239,7 +242,6 @@ static void uio_dev_del_attributes(struct uio_device *idev)
 
 static int uio_get_minor(struct uio_device *idev)
 {
-        static DEFINE_MUTEX(minor_lock);
         int retval = -ENOMEM;
         int id;
 
@@ -261,7 +263,9 @@ exit:
 
 static void uio_free_minor(struct uio_device *idev)
 {
+        mutex_lock(&minor_lock);
         idr_remove(&uio_idr, idev->minor);
+        mutex_unlock(&minor_lock);
 }
 
 /**
@@ -305,8 +309,9 @@ static int uio_open(struct inode *inode, struct file *filep)
         struct uio_listener *listener;
         int ret = 0;
 
-        lock_kernel();
+        mutex_lock(&minor_lock);
         idev = idr_find(&uio_idr, iminor(inode));
+        mutex_unlock(&minor_lock);
         if (!idev) {
                 ret = -ENODEV;
                 goto out;
@@ -332,18 +337,15 @@ static int uio_open(struct inode *inode, struct file *filep)
                 if (ret)
                         goto err_infoopen;
         }
-        unlock_kernel();
         return 0;
 
 err_infoopen:
-
         kfree(listener);
-err_alloc_listener:
 
+err_alloc_listener:
         module_put(idev->owner);
 
 out:
-        unlock_kernel();
         return ret;
 }
 
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index d343afacb0b0..15a803b206b8 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -1111,8 +1111,8 @@ clean0:
 #ifdef DEBUG
         debugfs_remove(ehci_debug_root);
         ehci_debug_root = NULL;
-#endif
 err_debug:
+#endif
         clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
         return retval;
 }
diff --git a/drivers/video/backlight/hp680_bl.c b/drivers/video/backlight/hp680_bl.c
index 6fa0b9d5559a..d4cfed0b26d5 100644
--- a/drivers/video/backlight/hp680_bl.c
+++ b/drivers/video/backlight/hp680_bl.c
@@ -19,7 +19,7 @@
 #include <linux/backlight.h>
 
 #include <cpu/dac.h>
-#include <asm/hp6xx.h>
+#include <mach/hp6xx.h>
 #include <asm/hd64461.h>
 
 #define HP680_MAX_INTENSITY 255
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 217c5118ae9e..cd5f20da738a 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -1002,101 +1002,132 @@ fb_blank(struct fb_info *info, int blank)
         return ret;
 }
 
-static int 
-fb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+static long
+fb_ioctl(struct file *file, unsigned int cmd,
          unsigned long arg)
 {
+        struct inode *inode = file->f_path.dentry->d_inode;
         int fbidx = iminor(inode);
-        struct fb_info *info = registered_fb[fbidx];
-        struct fb_ops *fb = info->fbops;
+        struct fb_info *info;
+        struct fb_ops *fb;
         struct fb_var_screeninfo var;
         struct fb_fix_screeninfo fix;
         struct fb_con2fbmap con2fb;
         struct fb_cmap_user cmap;
         struct fb_event event;
         void __user *argp = (void __user *)arg;
-        int i;
-        
-        if (!fb)
+        long ret = 0;
+
+        info = registered_fb[fbidx];
+        mutex_lock(&info->lock);
+        fb = info->fbops;
+
+        if (!fb) {
+                mutex_unlock(&info->lock);
                 return -ENODEV;
+        }
         switch (cmd) {
         case FBIOGET_VSCREENINFO:
-                return copy_to_user(argp, &info->var,
+                ret = copy_to_user(argp, &info->var,
                                     sizeof(var)) ? -EFAULT : 0;
+                break;
         case FBIOPUT_VSCREENINFO:
-                if (copy_from_user(&var, argp, sizeof(var)))
-                        return -EFAULT;
+                if (copy_from_user(&var, argp, sizeof(var))) {
+                        ret =  -EFAULT;
+                        break;
+                }
                 acquire_console_sem();
                 info->flags |= FBINFO_MISC_USEREVENT;
-                i = fb_set_var(info, &var);
+                ret = fb_set_var(info, &var);
                 info->flags &= ~FBINFO_MISC_USEREVENT;
                 release_console_sem();
-                if (i) return i;
-                if (copy_to_user(argp, &var, sizeof(var)))
-                        return -EFAULT;
-                return 0;
+                if (ret == 0 && copy_to_user(argp, &var, sizeof(var)))
+                        ret = -EFAULT;
+                break;
         case FBIOGET_FSCREENINFO:
-                return copy_to_user(argp, &info->fix,
+                ret = copy_to_user(argp, &info->fix,
                                     sizeof(fix)) ? -EFAULT : 0;
+                break;
         case FBIOPUTCMAP:
                 if (copy_from_user(&cmap, argp, sizeof(cmap)))
-                        return -EFAULT;
-                return (fb_set_user_cmap(&cmap, info));
+                        ret = -EFAULT;
+                else
+                        ret = fb_set_user_cmap(&cmap, info);
+                break;
         case FBIOGETCMAP:
                 if (copy_from_user(&cmap, argp, sizeof(cmap)))
-                        return -EFAULT;
-                return fb_cmap_to_user(&info->cmap, &cmap);
+                        ret = -EFAULT;
+                else
+                        ret = fb_cmap_to_user(&info->cmap, &cmap);
+                break;
         case FBIOPAN_DISPLAY:
-                if (copy_from_user(&var, argp, sizeof(var)))
-                        return -EFAULT;
+                if (copy_from_user(&var, argp, sizeof(var))) {
+                        ret = -EFAULT;
+                        break;
+                }
                 acquire_console_sem();
-                i = fb_pan_display(info, &var);
+                ret = fb_pan_display(info, &var);
                 release_console_sem();
-                if (i)
-                        return i;
-                if (copy_to_user(argp, &var, sizeof(var)))
-                        return -EFAULT;
-                return 0;
+                if (ret == 0 && copy_to_user(argp, &var, sizeof(var)))
+                        ret = -EFAULT;
+                break;
         case FBIO_CURSOR:
-                return -EINVAL;
+                ret = -EINVAL;
+                break;
         case FBIOGET_CON2FBMAP:
                 if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
-                        return -EFAULT;
-                if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
-                    return -EINVAL;
-                con2fb.framebuffer = -1;
-                event.info = info;
-                event.data = &con2fb;
-                fb_notifier_call_chain(FB_EVENT_GET_CONSOLE_MAP, &event);
-                return copy_to_user(argp, &con2fb,
+                        ret = -EFAULT;
+                else if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
+                        ret = -EINVAL;
+                else {
+                        con2fb.framebuffer = -1;
+                        event.info = info;
+                        event.data = &con2fb;
+                        fb_notifier_call_chain(FB_EVENT_GET_CONSOLE_MAP,
+                                                                &event);
+                        ret = copy_to_user(argp, &con2fb,
                                     sizeof(con2fb)) ? -EFAULT : 0;
+                }
+                break;
         case FBIOPUT_CON2FBMAP:
-                if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
-                        return - EFAULT;
-                if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
-                    return -EINVAL;
-                if (con2fb.framebuffer < 0 || con2fb.framebuffer >= FB_MAX)
-                    return -EINVAL;
-                if (!registered_fb[con2fb.framebuffer])
-                    request_module("fb%d", con2fb.framebuffer);
+                if (copy_from_user(&con2fb, argp, sizeof(con2fb))) {
+                        ret = -EFAULT;
+                        break;
+                }
+                if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES) {
+                        ret = -EINVAL;
+                        break;
+                }
+                if (con2fb.framebuffer < 0 || con2fb.framebuffer >= FB_MAX) {
+                        ret = -EINVAL;
+                        break;
+                }
                 if (!registered_fb[con2fb.framebuffer])
-                    return -EINVAL;
+                        request_module("fb%d", con2fb.framebuffer);
+                if (!registered_fb[con2fb.framebuffer]) {
+                        ret = -EINVAL;
+                        break;
+                }
                 event.info = info;
                 event.data = &con2fb;
-                return fb_notifier_call_chain(FB_EVENT_SET_CONSOLE_MAP,
+                ret = fb_notifier_call_chain(FB_EVENT_SET_CONSOLE_MAP,
                                               &event);
+                break;
         case FBIOBLANK:
                 acquire_console_sem();
                 info->flags |= FBINFO_MISC_USEREVENT;
-                i = fb_blank(info, arg);
+                ret = fb_blank(info, arg);
                 info->flags &= ~FBINFO_MISC_USEREVENT;
                 release_console_sem();
-                return i;
+                break;;
         default:
                 if (fb->fb_ioctl == NULL)
-                        return -EINVAL;
-                return fb->fb_ioctl(info, cmd, arg);
+                        ret = -ENOTTY;
+                else
+                        ret = fb->fb_ioctl(info, cmd, arg);
         }
+        mutex_unlock(&info->lock);
+        return ret;
 }
 
 #ifdef CONFIG_COMPAT
@@ -1150,7 +1181,7 @@ static int fb_getput_cmap(struct inode *inode, struct file *file,
             put_user(compat_ptr(data), &cmap->transp))
                 return -EFAULT;
 
-        err = fb_ioctl(inode, file, cmd, (unsigned long) cmap);
+        err = fb_ioctl(file, cmd, (unsigned long) cmap);
 
         if (!err) {
                 if (copy_in_user(&cmap32->start,
@@ -1204,7 +1235,7 @@ static int fb_get_fscreeninfo(struct inode *inode, struct file *file,
 
         old_fs = get_fs();
         set_fs(KERNEL_DS);
-        err = fb_ioctl(inode, file, cmd, (unsigned long) &fix);
+        err = fb_ioctl(file, cmd, (unsigned long) &fix);
         set_fs(old_fs);
 
         if (!err)
@@ -1222,7 +1253,7 @@ fb_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         struct fb_ops *fb = info->fbops;
         long ret = -ENOIOCTLCMD;
 
-        lock_kernel();
+        mutex_lock(&info->lock);
         switch(cmd) {
         case FBIOGET_VSCREENINFO:
         case FBIOPUT_VSCREENINFO:
@@ -1231,7 +1262,7 @@ fb_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         case FBIOPUT_CON2FBMAP:
                 arg = (unsigned long) compat_ptr(arg);
         case FBIOBLANK:
-                ret = fb_ioctl(inode, file, cmd, arg);
+                ret = fb_ioctl(file, cmd, arg);
                 break;
 
         case FBIOGET_FSCREENINFO:
@@ -1248,7 +1279,7 @@ fb_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                         ret = fb->fb_compat_ioctl(info, cmd, arg);
                 break;
         }
-        unlock_kernel();
+        mutex_unlock(&info->lock);
         return ret;
 }
 #endif
@@ -1270,13 +1301,13 @@ fb_mmap(struct file *file, struct vm_area_struct * vma)
                 return -ENODEV;
         if (fb->fb_mmap) {
                 int res;
-                lock_kernel();
+                mutex_lock(&info->lock);
                 res = fb->fb_mmap(info, vma);
-                unlock_kernel();
+                mutex_unlock(&info->lock);
                 return res;
         }
 
-        lock_kernel();
+        mutex_lock(&info->lock);
 
         /* frame buffer memory */
         start = info->fix.smem_start;
@@ -1285,13 +1316,13 @@ fb_mmap(struct file *file, struct vm_area_struct * vma)
                 /* memory mapped io */
                 off -= len;
                 if (info->var.accel_flags) {
-                        unlock_kernel();
+                        mutex_unlock(&info->lock);
                         return -EINVAL;
                 }
                 start = info->fix.mmio_start;
                 len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.mmio_len);
         }
-        unlock_kernel();
+        mutex_unlock(&info->lock);
         start &= PAGE_MASK;
         if ((vma->vm_end - vma->vm_start + off) > len)
                 return -EINVAL;
@@ -1315,13 +1346,13 @@ fb_open(struct inode *inode, struct file *file)
 
         if (fbidx >= FB_MAX)
                 return -ENODEV;
-        lock_kernel();
-        if (!(info = registered_fb[fbidx]))
+        info = registered_fb[fbidx];
+        if (!info)
                 request_module("fb%d", fbidx);
-        if (!(info = registered_fb[fbidx])) {
-                res = -ENODEV;
-                goto out;
-        }
+        info = registered_fb[fbidx];
+        if (!info)
+                return -ENODEV;
+        mutex_lock(&info->lock);
         if (!try_module_get(info->fbops->owner)) {
                 res = -ENODEV;
                 goto out;
@@ -1337,7 +1368,7 @@ fb_open(struct inode *inode, struct file *file)
                 fb_deferred_io_open(info, inode, file);
 #endif
 out:
-        unlock_kernel();
+        mutex_unlock(&info->lock);
         return res;
 }
 
@@ -1346,11 +1377,11 @@ fb_release(struct inode *inode, struct file *file)
 {
         struct fb_info * const info = file->private_data;
 
-        lock_kernel();
+        mutex_lock(&info->lock);
         if (info->fbops->fb_release)
                 info->fbops->fb_release(info,1);
         module_put(info->fbops->owner);
-        unlock_kernel();
+        mutex_unlock(&info->lock);
         return 0;
 }
 
@@ -1358,7 +1389,7 @@ static const struct file_operations fb_fops = {
         .owner =        THIS_MODULE,
         .read =         fb_read,
         .write =        fb_write,
-        .ioctl =        fb_ioctl,
+        .unlocked_ioctl = fb_ioctl,
 #ifdef CONFIG_COMPAT
         .compat_ioctl = fb_compat_ioctl,
 #endif
@@ -1429,6 +1460,7 @@ register_framebuffer(struct fb_info *fb_info)
                 if (!registered_fb[i])
                         break;
         fb_info->node = i;
+        mutex_init(&fb_info->lock);
 
         fb_info->dev = device_create(fb_class, fb_info->device,
                                      MKDEV(FB_MAJOR, i), NULL, "fb%d", i);
diff --git a/drivers/video/imacfb.c b/drivers/video/imacfb.c
deleted file mode 100644
index e69de29bb2d1..000000000000
--- a/drivers/video/imacfb.c
+++ /dev/null
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index 4c32c06579a0..efff672fd7b8 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -16,7 +16,7 @@
 #include <linux/clk.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <asm/sh_mobile_lcdc.h>
+#include <video/sh_mobile_lcdc.h>
 
 #define PALETTE_NR 16
 
@@ -34,7 +34,9 @@ struct sh_mobile_lcdc_chan {
 
 struct sh_mobile_lcdc_priv {
         void __iomem *base;
+#ifdef CONFIG_HAVE_CLK
         struct clk *clk;
+#endif
         unsigned long lddckr;
         struct sh_mobile_lcdc_chan ch[2];
 };
@@ -260,6 +262,11 @@ static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv)
                 tmp = ch->ldmt1r_value;
                 tmp |= (lcd_cfg->sync & FB_SYNC_VERT_HIGH_ACT) ? 0 : 1 << 28;
                 tmp |= (lcd_cfg->sync & FB_SYNC_HOR_HIGH_ACT) ? 0 : 1 << 27;
+                tmp |= (ch->cfg.flags & LCDC_FLAGS_DWPOL) ? 1 << 26 : 0;
+                tmp |= (ch->cfg.flags & LCDC_FLAGS_DIPOL) ? 1 << 25 : 0;
+                tmp |= (ch->cfg.flags & LCDC_FLAGS_DAPOL) ? 1 << 24 : 0;
+                tmp |= (ch->cfg.flags & LCDC_FLAGS_HSCNT) ? 1 << 17 : 0;
+                tmp |= (ch->cfg.flags & LCDC_FLAGS_DWCNT) ? 1 << 16 : 0;
                 lcdc_write_chan(ch, LDMT1R, tmp);
 
                 /* setup SYS bus */
@@ -422,6 +429,7 @@ static int sh_mobile_lcdc_setup_clocks(struct device *dev, int clock_source,
 
         priv->lddckr = icksel << 16;
 
+#ifdef CONFIG_HAVE_CLK
         if (str) {
                 priv->clk = clk_get(dev, str);
                 if (IS_ERR(priv->clk)) {
@@ -431,6 +439,7 @@ static int sh_mobile_lcdc_setup_clocks(struct device *dev, int clock_source,
 
                 clk_enable(priv->clk);
         }
+#endif
 
         return 0;
 }
@@ -585,7 +594,6 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
                 goto err1;
         }
 
-        priv->lddckr = pdata->lddckr;
         priv->base = ioremap_nocache(res->start, (res->end - res->start) + 1);
 
         for (i = 0; i < j; i++) {
@@ -688,10 +696,12 @@ static int sh_mobile_lcdc_remove(struct platform_device *pdev)
                 fb_dealloc_cmap(&info->cmap);
         }
 
+#ifdef CONFIG_HAVE_CLK
         if (priv->clk) {
                 clk_disable(priv->clk);
                 clk_put(priv->clk);
         }
+#endif
 
         if (priv->base)
                 iounmap(priv->base);
diff --git a/drivers/w1/slaves/w1_ds2760.c b/drivers/w1/slaves/w1_ds2760.c
index ed6b0576208c..1f09d4e4144c 100644
--- a/drivers/w1/slaves/w1_ds2760.c
+++ b/drivers/w1/slaves/w1_ds2760.c
@@ -80,7 +80,6 @@ static struct bin_attribute w1_ds2760_bin_attr = {
         .attr = {
                 .name = "w1_slave",
                 .mode = S_IRUGO,
-                .owner = THIS_MODULE,
         },
         .size = DS2760_DATA_SIZE,
         .read = w1_ds2760_read_bin,
diff --git a/drivers/watchdog/ib700wdt.c b/drivers/watchdog/ib700wdt.c
index 05a28106e8eb..8782ec1f5aa0 100644
--- a/drivers/watchdog/ib700wdt.c
+++ b/drivers/watchdog/ib700wdt.c
@@ -154,7 +154,7 @@ static int ibwdt_set_heartbeat(int t)
                 return -EINVAL;
 
         for (i = 0x0F; i > -1; i--)
-                if (wd_times[i] > t)
+                if (wd_times[i] >= t)
                         break;
         wd_margin = i;
         return 0;
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index c3290bc186a0..9ce1ab6c268d 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -125,7 +125,7 @@ static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
 
         BUG_ON(irq == -1);
 #ifdef CONFIG_SMP
-        irq_desc[irq].affinity = cpumask_of_cpu(cpu);
+        irq_to_desc(irq)->affinity = cpumask_of_cpu(cpu);
 #endif
 
         __clear_bit(chn, cpu_evtchn_mask[cpu_evtchn[chn]]);
@@ -137,10 +137,12 @@ static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
 static void init_evtchn_cpu_bindings(void)
 {
 #ifdef CONFIG_SMP
+        struct irq_desc *desc;
         int i;
+
         /* By default all event channels notify CPU#0. */
-        for (i = 0; i < NR_IRQS; i++)
-                irq_desc[i].affinity = cpumask_of_cpu(0);
+        for_each_irq_desc(i, desc)
+                desc->affinity = cpumask_of_cpu(0);
 #endif
 
         memset(cpu_evtchn, 0, sizeof(cpu_evtchn));
@@ -229,12 +231,12 @@ static int find_unbound_irq(void)
         int irq;
 
         /* Only allocate from dynirq range */
-        for (irq = 0; irq < NR_IRQS; irq++)
+        for_each_irq_nr(irq)
                 if (irq_bindcount[irq] == 0)
                         break;
 
-        if (irq == NR_IRQS)
-                panic("No available IRQ to bind to: increase NR_IRQS!\n");
+        if (irq == nr_irqs)
+                panic("No available IRQ to bind to: increase nr_irqs!\n");
 
         return irq;
 }
@@ -790,7 +792,7 @@ void xen_irq_resume(void)
                 mask_evtchn(evtchn);
 
         /* No IRQ <-> event-channel mappings. */
-        for (irq = 0; irq < NR_IRQS; irq++)
+        for_each_irq_nr(irq)
                 irq_info[irq].evtchn = 0; /* zap event-channel binding */
 
         for (evtchn = 0; evtchn < NR_EVENT_CHANNELS; evtchn++)
@@ -822,7 +824,7 @@ void __init xen_init_IRQ(void)
                 mask_evtchn(i);
 
         /* Dynamic IRQ space is currently unbound. Zero the refcnts. */
-        for (i = 0; i < NR_IRQS; i++)
+        for_each_irq_nr(i)
                 irq_bindcount[i] = 0;
 
         irq_ctx_init(smp_processor_id());