122 files changed, 2359 insertions, 697 deletions

diff --git a/drivers/acpi/processor_throttling.c b/drivers/acpi/processor_throttling.c
index 1b8e592a8241..0bba3a914e86 100644
--- a/drivers/acpi/processor_throttling.c
+++ b/drivers/acpi/processor_throttling.c
@@ -838,10 +838,10 @@ static int acpi_processor_get_throttling(struct acpi_processor *pr)
          * Migrate task to the cpu pointed by pr.
          */
         saved_mask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(pr->id));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(pr->id));
         ret = pr->throttling.acpi_processor_get_throttling(pr);
         /* restore the previous state */
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
 
         return ret;
 }
@@ -1025,7 +1025,7 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
          * it can be called only for the cpu pointed by pr.
          */
         if (p_throttling->shared_type == DOMAIN_COORD_TYPE_SW_ANY) {
-                set_cpus_allowed(current, cpumask_of_cpu(pr->id));
+                set_cpus_allowed_ptr(current, &cpumask_of_cpu(pr->id));
                 ret = p_throttling->acpi_processor_set_throttling(pr,
                                                 t_state.target_state);
         } else {
@@ -1056,7 +1056,7 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
                                 continue;
                         }
                         t_state.cpu = i;
-                        set_cpus_allowed(current, cpumask_of_cpu(i));
+                        set_cpus_allowed_ptr(current, &cpumask_of_cpu(i));
                         ret = match_pr->throttling.
                                 acpi_processor_set_throttling(
                                 match_pr, t_state.target_state);
@@ -1074,7 +1074,7 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
                                                         &t_state);
         }
         /* restore the previous state */
-        set_cpus_allowed(current, saved_mask);
+        set_cpus_allowed_ptr(current, &saved_mask);
         return ret;
 }
 
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 733eb94d055e..b0b00af90d0e 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -61,7 +61,6 @@
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
-#include <asm/semaphore.h>
 #include <asm/byteorder.h>
 #include <linux/cdrom.h>
 
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index 05ff8c776497..d52ce1188327 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -76,6 +76,7 @@
 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/ata_platform.h>
+#include <linux/mbus.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
@@ -370,6 +371,9 @@ enum {
 #define IS_GEN_IIE(hpriv) ((hpriv)->hp_flags & MV_HP_GEN_IIE)
 #define HAS_PCI(host) (!((host)->ports[0]->flags & MV_FLAG_SOC))
 
+#define WINDOW_CTRL(i)          (0x20030 + ((i) << 4))
+#define WINDOW_BASE(i)          (0x20034 + ((i) << 4))
+
 enum {
         /* DMA boundary 0xffff is required by the s/g splitting
          * we need on /length/ in mv_fill-sg().
@@ -2769,6 +2773,27 @@ static int mv_create_dma_pools(struct mv_host_priv *hpriv, struct device *dev)
         return 0;
 }
 
+static void mv_conf_mbus_windows(struct mv_host_priv *hpriv,
+                                 struct mbus_dram_target_info *dram)
+{
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                writel(0, hpriv->base + WINDOW_CTRL(i));
+                writel(0, hpriv->base + WINDOW_BASE(i));
+        }
+
+        for (i = 0; i < dram->num_cs; i++) {
+                struct mbus_dram_window *cs = dram->cs + i;
+
+                writel(((cs->size - 1) & 0xffff0000) |
+                        (cs->mbus_attr << 8) |
+                        (dram->mbus_dram_target_id << 4) | 1,
+                        hpriv->base + WINDOW_CTRL(i));
+                writel(cs->base, hpriv->base + WINDOW_BASE(i));
+        }
+}
+
 /**
  *      mv_platform_probe - handle a positive probe of an soc Marvell
  *      host
@@ -2823,6 +2848,12 @@ static int mv_platform_probe(struct platform_device *pdev)
                                    res->end - res->start + 1);
         hpriv->base -= MV_SATAHC0_REG_BASE;
 
+        /*
+         * (Re-)program MBUS remapping windows if we are asked to.
+         */
+        if (mv_platform_data->dram != NULL)
+                mv_conf_mbus_windows(hpriv, mv_platform_data->dram);
+
         rc = mv_create_dma_pools(hpriv, &pdev->dev);
         if (rc)
                 return rc;
diff --git a/drivers/atm/iphase.c b/drivers/atm/iphase.c
index 670c093ed25f..5c28ca7380ff 100644
--- a/drivers/atm/iphase.c
+++ b/drivers/atm/iphase.c
@@ -60,7 +60,8 @@
 #include <asm/uaccess.h>  
 #include <asm/string.h>  
 #include <asm/byteorder.h>  
-#include <linux/vmalloc.h>  
+#include <linux/vmalloc.h>
+#include <linux/jiffies.h>
 #include "iphase.h"               
 #include "suni.h"                 
 #define swap(x) (((x & 0xff) << 8) | ((x & 0xff00) >> 8))  
@@ -189,7 +190,7 @@ static u16 get_desc (IADEV *dev, struct ia_vcc *iavcc) {
   int ltimeout;
 
   ia_hack_tcq (dev);
-  if(((jiffies - timer)>50)||((dev->ffL.tcq_rd==dev->host_tcq_wr))){      
+  if((time_after(jiffies,timer+50)) || ((dev->ffL.tcq_rd==dev->host_tcq_wr))) {
      timer = jiffies; 
      i=0;
      while (i < dev->num_tx_desc) {
@@ -1225,7 +1226,7 @@ static void rx_intr(struct atm_dev *dev)
         iadev->rx_tmp_jif = jiffies; 
         iadev->rxing = 0;
      } 
-     else if (((jiffies - iadev->rx_tmp_jif) > 50) && 
+     else if ((time_after(jiffies, iadev->rx_tmp_jif + 50)) &&
                ((iadev->rx_pkt_cnt - iadev->rx_tmp_cnt) == 0)) {
         for (i = 1; i <= iadev->num_rx_desc; i++)
                free_desc(dev, i);
diff --git a/drivers/atm/nicstar.c b/drivers/atm/nicstar.c
index 0c205b000e8b..38c769f8d2b7 100644
--- a/drivers/atm/nicstar.c
+++ b/drivers/atm/nicstar.c
@@ -125,85 +125,6 @@
 #define ATM_SKB(s) (&(s)->atm)
 #endif
 
-   /* Spinlock debugging stuff */
-#ifdef NS_DEBUG_SPINLOCKS /* See nicstar.h */
-#define ns_grab_int_lock(card,flags) \
- do { \
-    unsigned long nsdsf, nsdsf2; \
-    local_irq_save(flags); \
-    save_flags(nsdsf); cli();\
-    if (nsdsf & (1<<9)) printk ("nicstar.c: ints %sabled -> enabled.\n", \
-                                (flags)&(1<<9)?"en":"dis"); \
-    if (spin_is_locked(&(card)->int_lock) && \
-        (card)->cpu_int == smp_processor_id()) { \
-       printk("nicstar.c: line %d (cpu %d) int_lock already locked at line %d (cpu %d)\n", \
-              __LINE__, smp_processor_id(), (card)->has_int_lock, \
-              (card)->cpu_int); \
-       printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
-    } \
-    if (spin_is_locked(&(card)->res_lock) && \
-        (card)->cpu_res == smp_processor_id()) { \
-       printk("nicstar.c: line %d (cpu %d) res_lock locked at line %d (cpu %d)(trying int)\n", \
-              __LINE__, smp_processor_id(), (card)->has_res_lock, \
-              (card)->cpu_res); \
-       printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
-    } \
-    spin_lock_irq(&(card)->int_lock); \
-    (card)->has_int_lock = __LINE__; \
-    (card)->cpu_int = smp_processor_id(); \
-    restore_flags(nsdsf); } while (0)
-#define ns_grab_res_lock(card,flags) \
- do { \
-    unsigned long nsdsf, nsdsf2; \
-    local_irq_save(flags); \
-    save_flags(nsdsf); cli();\
-    if (nsdsf & (1<<9)) printk ("nicstar.c: ints %sabled -> enabled.\n", \
-                                (flags)&(1<<9)?"en":"dis"); \
-    if (spin_is_locked(&(card)->res_lock) && \
-        (card)->cpu_res == smp_processor_id()) { \
-       printk("nicstar.c: line %d (cpu %d) res_lock already locked at line %d (cpu %d)\n", \
-              __LINE__, smp_processor_id(), (card)->has_res_lock, \
-              (card)->cpu_res); \
-       printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
-    } \
-    spin_lock_irq(&(card)->res_lock); \
-    (card)->has_res_lock = __LINE__; \
-    (card)->cpu_res = smp_processor_id(); \
-    restore_flags(nsdsf); } while (0)
-#define ns_grab_scq_lock(card,scq,flags) \
- do { \
-    unsigned long nsdsf, nsdsf2; \
-    local_irq_save(flags); \
-    save_flags(nsdsf); cli();\
-    if (nsdsf & (1<<9)) printk ("nicstar.c: ints %sabled -> enabled.\n", \
-                                (flags)&(1<<9)?"en":"dis"); \
-    if (spin_is_locked(&(scq)->lock) && \
-        (scq)->cpu_lock == smp_processor_id()) { \
-       printk("nicstar.c: line %d (cpu %d) this scq_lock already locked at line %d (cpu %d)\n", \
-              __LINE__, smp_processor_id(), (scq)->has_lock, \
-              (scq)->cpu_lock); \
-       printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
-    } \
-    if (spin_is_locked(&(card)->res_lock) && \
-        (card)->cpu_res == smp_processor_id()) { \
-       printk("nicstar.c: line %d (cpu %d) res_lock locked at line %d (cpu %d)(trying scq)\n", \
-              __LINE__, smp_processor_id(), (card)->has_res_lock, \
-              (card)->cpu_res); \
-       printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
-    } \
-    spin_lock_irq(&(scq)->lock); \
-    (scq)->has_lock = __LINE__; \
-    (scq)->cpu_lock = smp_processor_id(); \
-    restore_flags(nsdsf); } while (0)
-#else /* !NS_DEBUG_SPINLOCKS */
-#define ns_grab_int_lock(card,flags) \
-        spin_lock_irqsave(&(card)->int_lock,(flags))
-#define ns_grab_res_lock(card,flags) \
-        spin_lock_irqsave(&(card)->res_lock,(flags))
-#define ns_grab_scq_lock(card,scq,flags) \
-        spin_lock_irqsave(&(scq)->lock,flags)
-#endif /* NS_DEBUG_SPINLOCKS */
-
 
 /* Function declarations ******************************************************/
 
@@ -422,7 +343,7 @@ static u32 ns_read_sram(ns_dev *card, u32 sram_address)
    sram_address <<= 2;
    sram_address &= 0x0007FFFC;  /* address must be dword aligned */
    sram_address |= 0x50000000;  /* SRAM read command */
-   ns_grab_res_lock(card, flags);
+   spin_lock_irqsave(&card->res_lock, flags);
    while (CMD_BUSY(card));
    writel(sram_address, card->membase + CMD);
    while (CMD_BUSY(card));
@@ -440,7 +361,7 @@ static void ns_write_sram(ns_dev *card, u32 sram_address, u32 *value, int count)
    count--;     /* count range now is 0..3 instead of 1..4 */
    c = count;
    c <<= 2;     /* to use increments of 4 */
-   ns_grab_res_lock(card, flags);
+   spin_lock_irqsave(&card->res_lock, flags);
    while (CMD_BUSY(card));
    for (i = 0; i <= c; i += 4)
       writel(*(value++), card->membase + i);
@@ -1166,7 +1087,7 @@ static void push_rxbufs(ns_dev *card, struct sk_buff *skb)
             card->lbfqc += 2;
       }
 
-      ns_grab_res_lock(card, flags);
+      spin_lock_irqsave(&card->res_lock, flags);
 
       while (CMD_BUSY(card));
       writel(addr2, card->membase + DR3);
@@ -1206,7 +1127,7 @@ static irqreturn_t ns_irq_handler(int irq, void *dev_id)
 
    PRINTK("nicstar%d: NICStAR generated an interrupt\n", card->index);
 
-   ns_grab_int_lock(card, flags);
+   spin_lock_irqsave(&card->int_lock, flags);
    
    stat_r = readl(card->membase + STAT);
 
@@ -1585,7 +1506,7 @@ static void ns_close(struct atm_vcc *vcc)
       unsigned long flags;
       
       addr = NS_RCT + (vcc->vpi << card->vcibits | vcc->vci) * NS_RCT_ENTRY_SIZE;
-      ns_grab_res_lock(card, flags);
+      spin_lock_irqsave(&card->res_lock, flags);
       while(CMD_BUSY(card));
       writel(NS_CMD_CLOSE_CONNECTION | addr << 2, card->membase + CMD);
       spin_unlock_irqrestore(&card->res_lock, flags);
@@ -1607,7 +1528,7 @@ static void ns_close(struct atm_vcc *vcc)
                                NS_SKB(iovb)->iovcnt);
          NS_SKB(iovb)->iovcnt = 0;
          NS_SKB(iovb)->vcc = NULL;
-         ns_grab_int_lock(card, flags);
+         spin_lock_irqsave(&card->int_lock, flags);
          recycle_iov_buf(card, iovb);
          spin_unlock_irqrestore(&card->int_lock, flags);
          vc->rx_iov = NULL;
@@ -1629,7 +1550,7 @@ static void ns_close(struct atm_vcc *vcc)
 
       for (;;)
       {
-         ns_grab_scq_lock(card, scq, flags);
+         spin_lock_irqsave(&scq->lock, flags);
          scqep = scq->next;
          if (scqep == scq->base)
             scqep = scq->last;
@@ -1691,7 +1612,7 @@ static void ns_close(struct atm_vcc *vcc)
      unsigned long flags;
      scq_info *scq = card->scq0;
 
-     ns_grab_scq_lock(card, scq, flags);
+     spin_lock_irqsave(&scq->lock, flags);
 
      for(i = 0; i < scq->num_entries; i++) {
        if(scq->skb[i] && ATM_SKB(scq->skb[i])->vcc == vcc) {
@@ -1892,7 +1813,7 @@ static int push_scqe(ns_dev *card, vc_map *vc, scq_info *scq, ns_scqe *tbd,
    u32 data;
    int index;
    
-   ns_grab_scq_lock(card, scq, flags);
+   spin_lock_irqsave(&scq->lock, flags);
    while (scq->tail == scq->next)
    {
       if (in_interrupt()) {
@@ -1904,7 +1825,7 @@ static int push_scqe(ns_dev *card, vc_map *vc, scq_info *scq, ns_scqe *tbd,
       scq->full = 1;
       spin_unlock_irqrestore(&scq->lock, flags);
       interruptible_sleep_on_timeout(&scq->scqfull_waitq, SCQFULL_TIMEOUT);
-      ns_grab_scq_lock(card, scq, flags);
+      spin_lock_irqsave(&scq->lock, flags);
 
       if (scq->full) {
          spin_unlock_irqrestore(&scq->lock, flags);
@@ -1953,7 +1874,7 @@ static int push_scqe(ns_dev *card, vc_map *vc, scq_info *scq, ns_scqe *tbd,
          if (has_run++) break;
          spin_unlock_irqrestore(&scq->lock, flags);
          interruptible_sleep_on_timeout(&scq->scqfull_waitq, SCQFULL_TIMEOUT);
-         ns_grab_scq_lock(card, scq, flags);
+         spin_lock_irqsave(&scq->lock, flags);
       }
 
       if (!scq->full)
@@ -2090,7 +2011,7 @@ static void drain_scq(ns_dev *card, scq_info *scq, int pos)
       return;
    }
 
-   ns_grab_scq_lock(card, scq, flags);
+   spin_lock_irqsave(&scq->lock, flags);
    i = (int) (scq->tail - scq->base);
    if (++i == scq->num_entries)
       i = 0;
@@ -2898,7 +2819,7 @@ static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg)
                {
                   struct sk_buff *hb;
 
-                  ns_grab_int_lock(card, flags);
+                  spin_lock_irqsave(&card->int_lock, flags);
                   hb = skb_dequeue(&card->hbpool.queue);
                   card->hbpool.count--;
                   spin_unlock_irqrestore(&card->int_lock, flags);
@@ -2917,7 +2838,7 @@ static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg)
                   if (hb == NULL)
                      return -ENOMEM;
                   NS_SKB_CB(hb)->buf_type = BUF_NONE;
-                  ns_grab_int_lock(card, flags);
+                  spin_lock_irqsave(&card->int_lock, flags);
                   skb_queue_tail(&card->hbpool.queue, hb);
                   card->hbpool.count++;
                   spin_unlock_irqrestore(&card->int_lock, flags);
@@ -2929,7 +2850,7 @@ static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg)
                {
                   struct sk_buff *iovb;
 
-                  ns_grab_int_lock(card, flags);
+                  spin_lock_irqsave(&card->int_lock, flags);
                   iovb = skb_dequeue(&card->iovpool.queue);
                   card->iovpool.count--;
                   spin_unlock_irqrestore(&card->int_lock, flags);
@@ -2948,7 +2869,7 @@ static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg)
                   if (iovb == NULL)
                      return -ENOMEM;
                   NS_SKB_CB(iovb)->buf_type = BUF_NONE;
-                  ns_grab_int_lock(card, flags);
+                  spin_lock_irqsave(&card->int_lock, flags);
                   skb_queue_tail(&card->iovpool.queue, iovb);
                   card->iovpool.count++;
                   spin_unlock_irqrestore(&card->int_lock, flags);
@@ -2995,7 +2916,7 @@ static void ns_poll(unsigned long arg)
       /* Probably it isn't worth spinning */
          continue;
       }
-      ns_grab_int_lock(card, flags);
+      spin_lock_irqsave(&card->int_lock, flags);
 
       stat_w = 0;
       stat_r = readl(card->membase + STAT);
@@ -3062,7 +2983,7 @@ static void ns_phy_put(struct atm_dev *dev, unsigned char value,
    unsigned long flags;
 
    card = dev->dev_data;
-   ns_grab_res_lock(card, flags);
+   spin_lock_irqsave(&card->res_lock, flags);
    while(CMD_BUSY(card));
    writel((unsigned long) value, card->membase + DR0);
    writel(NS_CMD_WRITE_UTILITY | 0x00000200 | (addr & 0x000000FF),
@@ -3079,7 +3000,7 @@ static unsigned char ns_phy_get(struct atm_dev *dev, unsigned long addr)
    unsigned long data;
 
    card = dev->dev_data;
-   ns_grab_res_lock(card, flags);
+   spin_lock_irqsave(&card->res_lock, flags);
    while(CMD_BUSY(card));
    writel(NS_CMD_READ_UTILITY | 0x00000200 | (addr & 0x000000FF),
           card->membase + CMD);
diff --git a/drivers/atm/nicstar.h b/drivers/atm/nicstar.h
index 5997bcb45b59..6010e3daa6a2 100644
--- a/drivers/atm/nicstar.h
+++ b/drivers/atm/nicstar.h
@@ -28,8 +28,6 @@
 
 /* Options ********************************************************************/
 
-#undef NS_DEBUG_SPINLOCKS
-
 #define NS_MAX_CARDS 4          /* Maximum number of NICStAR based cards
                                    controlled by the device driver. Must
                                    be <= 5 */
@@ -721,10 +719,6 @@ typedef struct scq_info
    wait_queue_head_t scqfull_waitq;
    volatile char full;                  /* SCQ full indicator */
    spinlock_t lock;                     /* SCQ spinlock */
-#ifdef NS_DEBUG_SPINLOCKS
-   volatile long has_lock;
-   volatile int cpu_lock;
-#endif /* NS_DEBUG_SPINLOCKS */
 } scq_info;
 
 
@@ -810,12 +804,6 @@ typedef struct ns_dev
    unsigned intcnt;                     /* Interrupt counter */
    spinlock_t int_lock;         /* Interrupt lock */
    spinlock_t res_lock;         /* Card resource lock */
-#ifdef NS_DEBUG_SPINLOCKS
-   volatile long has_int_lock;
-   volatile int cpu_int;
-   volatile long has_res_lock;
-   volatile int cpu_res;
-#endif /* NS_DEBUG_SPINLOCKS */
 } ns_dev;
 
 
diff --git a/drivers/base/core.c b/drivers/base/core.c
index 0737fe5392a3..9248e0927d08 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -20,7 +20,7 @@
 #include <linux/notifier.h>
 #include <linux/genhd.h>
 #include <linux/kallsyms.h>
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 
 #include "base.h"
 #include "power/power.h"
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 3e417a97681d..6fe417429977 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -103,6 +103,51 @@ static SYSDEV_ATTR(crash_notes, 0400, show_crash_notes, NULL);
 #endif
 
 /*
+ * Print cpu online, possible, present, and system maps
+ */
+static ssize_t print_cpus_map(char *buf, cpumask_t *map)
+{
+        int n = cpulist_scnprintf(buf, PAGE_SIZE-2, *map);
+
+        buf[n++] = '\n';
+        buf[n] = '\0';
+        return n;
+}
+
+#define print_cpus_func(type) \
+static ssize_t print_cpus_##type(struct sysdev_class *class, char *buf) \
+{                                                                       \
+        return print_cpus_map(buf, &cpu_##type##_map);                  \
+}                                                                       \
+struct sysdev_class_attribute attr_##type##_map =                       \
+        _SYSDEV_CLASS_ATTR(type, 0444, print_cpus_##type, NULL)
+
+print_cpus_func(online);
+print_cpus_func(possible);
+print_cpus_func(present);
+
+struct sysdev_class_attribute *cpu_state_attr[] = {
+        &attr_online_map,
+        &attr_possible_map,
+        &attr_present_map,
+};
+
+static int cpu_states_init(void)
+{
+        int i;
+        int err = 0;
+
+        for (i = 0;  i < ARRAY_SIZE(cpu_state_attr); i++) {
+                int ret;
+                ret = sysdev_class_create_file(&cpu_sysdev_class,
+                                                cpu_state_attr[i]);
+                if (!err)
+                        err = ret;
+        }
+        return err;
+}
+
+/*
  * register_cpu - Setup a sysfs device for a CPU.
  * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
  *        sysfs for this CPU.
@@ -147,6 +192,9 @@ int __init cpu_dev_init(void)
         int err;
 
         err = sysdev_class_register(&cpu_sysdev_class);
+        if (!err)
+                err = cpu_states_init();
+
 #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
         if (!err)
                 err = sched_create_sysfs_power_savings_entries(&cpu_sysdev_class);
diff --git a/drivers/base/node.c b/drivers/base/node.c
index e59861f18ce5..12fde2d03d69 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -19,21 +19,34 @@ static struct sysdev_class node_class = {
 };
 
 
-static ssize_t node_read_cpumap(struct sys_device * dev, char * buf)
+static ssize_t node_read_cpumap(struct sys_device *dev, int type, char *buf)
 {
         struct node *node_dev = to_node(dev);
-        cpumask_t mask = node_to_cpumask(node_dev->sysdev.id);
+        node_to_cpumask_ptr(mask, node_dev->sysdev.id);
         int len;
 
-        /* 2004/06/03: buf currently PAGE_SIZE, need > 1 char per 4 bits. */
-        BUILD_BUG_ON(MAX_NUMNODES/4 > PAGE_SIZE/2);
+        /* 2008/04/07: buf currently PAGE_SIZE, need 9 chars per 32 bits. */
+        BUILD_BUG_ON((NR_CPUS/32 * 9) > (PAGE_SIZE-1));
 
-        len = cpumask_scnprintf(buf, PAGE_SIZE-1, mask);
-        len += sprintf(buf + len, "\n");
+        len = type?
+                cpulist_scnprintf(buf, PAGE_SIZE-2, *mask):
+                cpumask_scnprintf(buf, PAGE_SIZE-2, *mask);
+        buf[len++] = '\n';
+        buf[len] = '\0';
         return len;
 }
 
-static SYSDEV_ATTR(cpumap, S_IRUGO, node_read_cpumap, NULL);
+static inline ssize_t node_read_cpumask(struct sys_device *dev, char *buf)
+{
+        return node_read_cpumap(dev, 0, buf);
+}
+static inline ssize_t node_read_cpulist(struct sys_device *dev, char *buf)
+{
+        return node_read_cpumap(dev, 1, buf);
+}
+
+static SYSDEV_ATTR(cpumap,  S_IRUGO, node_read_cpumask, NULL);
+static SYSDEV_ATTR(cpulist, S_IRUGO, node_read_cpulist, NULL);
 
 #define K(x) ((x) << (PAGE_SHIFT - 10))
 static ssize_t node_read_meminfo(struct sys_device * dev, char * buf)
@@ -149,6 +162,7 @@ int register_node(struct node *node, int num, struct node *parent)
 
         if (!error){
                 sysdev_create_file(&node->sysdev, &attr_cpumap);
+                sysdev_create_file(&node->sysdev, &attr_cpulist);
                 sysdev_create_file(&node->sysdev, &attr_meminfo);
                 sysdev_create_file(&node->sysdev, &attr_numastat);
                 sysdev_create_file(&node->sysdev, &attr_distance);
@@ -166,6 +180,7 @@ int register_node(struct node *node, int num, struct node *parent)
 void unregister_node(struct node *node)
 {
         sysdev_remove_file(&node->sysdev, &attr_cpumap);
+        sysdev_remove_file(&node->sysdev, &attr_cpulist);
         sysdev_remove_file(&node->sysdev, &attr_meminfo);
         sysdev_remove_file(&node->sysdev, &attr_numastat);
         sysdev_remove_file(&node->sysdev, &attr_distance);
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
index e1d3ad4db2f0..fdf4044d2e74 100644
--- a/drivers/base/topology.c
+++ b/drivers/base/topology.c
@@ -40,15 +40,38 @@ static ssize_t show_##name(struct sys_device *dev, char *buf)	\
         return sprintf(buf, "%d\n", topology_##name(cpu));      \
 }
 
-#define define_siblings_show_func(name)                                 \
-static ssize_t show_##name(struct sys_device *dev, char *buf)           \
+static ssize_t show_cpumap(int type, cpumask_t *mask, char *buf)
+{
+        ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
+        int n = 0;
+
+        if (len > 1) {
+                n = type?
+                        cpulist_scnprintf(buf, len-2, *mask):
+                        cpumask_scnprintf(buf, len-2, *mask);
+                buf[n++] = '\n';
+                buf[n] = '\0';
+        }
+        return n;
+}
+
+#define define_siblings_show_map(name)                                  \
+static inline ssize_t show_##name(struct sys_device *dev, char *buf)    \
 {                                                                       \
-        ssize_t len = -1;                                               \
         unsigned int cpu = dev->id;                                     \
-        len = cpumask_scnprintf(buf, NR_CPUS+1, topology_##name(cpu));  \
-        return (len + sprintf(buf + len, "\n"));                        \
+        return show_cpumap(0, &(topology_##name(cpu)), buf);            \
 }
 
+#define define_siblings_show_list(name)                                 \
+static inline ssize_t show_##name##_list(struct sys_device *dev, char *buf) \
+{                                                                       \
+        unsigned int cpu = dev->id;                                     \
+        return show_cpumap(1, &(topology_##name(cpu)), buf);            \
+}
+
+#define define_siblings_show_func(name)         \
+        define_siblings_show_map(name); define_siblings_show_list(name)
+
 #ifdef  topology_physical_package_id
 define_id_show_func(physical_package_id);
 define_one_ro(physical_package_id);
@@ -68,7 +91,9 @@ define_one_ro(core_id);
 #ifdef topology_thread_siblings
 define_siblings_show_func(thread_siblings);
 define_one_ro(thread_siblings);
-#define ref_thread_siblings_attr        &attr_thread_siblings.attr,
+define_one_ro(thread_siblings_list);
+#define ref_thread_siblings_attr        \
+                &attr_thread_siblings.attr, &attr_thread_siblings_list.attr,
 #else
 #define ref_thread_siblings_attr
 #endif
@@ -76,7 +101,9 @@ define_one_ro(thread_siblings);
 #ifdef topology_core_siblings
 define_siblings_show_func(core_siblings);
 define_one_ro(core_siblings);
-#define ref_core_siblings_attr          &attr_core_siblings.attr,
+define_one_ro(core_siblings_list);
+#define ref_core_siblings_attr          \
+                &attr_core_siblings.attr, &attr_core_siblings_list.attr,
 #else
 #define ref_core_siblings_attr
 #endif
diff --git a/drivers/block/cryptoloop.c b/drivers/block/cryptoloop.c
index 241167878edf..8b6bb764b0a3 100644
--- a/drivers/block/cryptoloop.c
+++ b/drivers/block/cryptoloop.c
@@ -27,7 +27,6 @@
 #include <linux/blkdev.h>
 #include <linux/loop.h>
 #include <linux/scatterlist.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/bluetooth/hci_usb.c b/drivers/bluetooth/hci_usb.c
index 8b884f87d8b7..192522ebb771 100644
--- a/drivers/bluetooth/hci_usb.c
+++ b/drivers/bluetooth/hci_usb.c
@@ -62,13 +62,13 @@
 #define URB_ZERO_PACKET 0
 #endif
 
-static int ignore = 0;
-static int ignore_dga = 0;
-static int ignore_csr = 0;
-static int ignore_sniffer = 0;
-static int disable_scofix = 0;
-static int force_scofix = 0;
-static int reset = 0;
+static int ignore;
+static int ignore_dga;
+static int ignore_csr;
+static int ignore_sniffer;
+static int disable_scofix;
+static int force_scofix;
+static int reset;
 
 #ifdef CONFIG_BT_HCIUSB_SCO
 static int isoc = 2;
@@ -265,7 +265,7 @@ static int hci_usb_intr_rx_submit(struct hci_usb *husb)
                 BT_ERR("%s intr rx submit failed urb %p err %d",
                                 husb->hdev->name, urb, err);
                 _urb_unlink(_urb);
-                _urb_free(_urb);
+                kfree(_urb);
                 kfree(buf);
         }
         return err;
@@ -302,7 +302,7 @@ static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
                 BT_ERR("%s bulk rx submit failed urb %p err %d",
                                 husb->hdev->name, urb, err);
                 _urb_unlink(_urb);
-                _urb_free(_urb);
+                kfree(_urb);
                 kfree(buf);
         }
         return err;
@@ -353,7 +353,7 @@ static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
                 BT_ERR("%s isoc rx submit failed urb %p err %d",
                                 husb->hdev->name, urb, err);
                 _urb_unlink(_urb);
-                _urb_free(_urb);
+                kfree(_urb);
                 kfree(buf);
         }
         return err;
@@ -431,7 +431,7 @@ static void hci_usb_unlink_urbs(struct hci_usb *husb)
                                         husb->hdev->name, _urb, _urb->type, urb);
                         kfree(urb->setup_packet);
                         kfree(urb->transfer_buffer);
-                        _urb_free(_urb);
+                        kfree(_urb);
                 }
         }
 }
@@ -490,7 +490,7 @@ static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
 
                 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
                 if (!dr) {
-                        _urb_free(_urb);
+                        kfree(_urb);
                         return -ENOMEM;
                 }
         } else
diff --git a/drivers/bluetooth/hci_usb.h b/drivers/bluetooth/hci_usb.h
index 56cd3a92ceca..414080a4e8ff 100644
--- a/drivers/bluetooth/hci_usb.h
+++ b/drivers/bluetooth/hci_usb.h
@@ -60,11 +60,6 @@ struct _urb {
         struct urb        urb;
 };
 
-static inline void _urb_free(struct _urb *_urb)
-{
-        kfree(_urb);
-}
-
 static inline void _urb_queue_init(struct _urb_queue *q)
 {
         INIT_LIST_HEAD(&q->head);
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 47c6be84fc84..a87b89db08e9 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -706,7 +706,7 @@ config NVRAM
 
 config RTC
         tristate "Enhanced Real Time Clock Support"
-        depends on !PPC && !PARISC && !IA64 && !M68K && !SPARC && !FRV && !ARM && !SUPERH && !S390
+        depends on !PPC && !PARISC && !IA64 && !M68K && !SPARC && !FRV && !ARM && !SUPERH && !S390 && !AVR32
         ---help---
           If you say Y here and create a character special file /dev/rtc with
           major number 10 and minor number 135 using mknod ("man mknod"), you
@@ -776,7 +776,7 @@ config SGI_IP27_RTC
 
 config GEN_RTC
         tristate "Generic /dev/rtc emulation"
-        depends on RTC!=y && !IA64 && !ARM && !M32R && !MIPS && !SPARC && !FRV && !S390 && !SUPERH
+        depends on RTC!=y && !IA64 && !ARM && !M32R && !MIPS && !SPARC && !FRV && !S390 && !SUPERH && !AVR32
         ---help---
           If you say Y here and create a character special file /dev/rtc with
           major number 10 and minor number 135 using mknod ("man mknod"), you
diff --git a/drivers/char/generic_serial.c b/drivers/char/generic_serial.c
index 8facf3e25c49..7ed7da1d99cf 100644
--- a/drivers/char/generic_serial.c
+++ b/drivers/char/generic_serial.c
@@ -28,7 +28,6 @@
 #include <linux/interrupt.h>
 #include <linux/tty_flip.h>
 #include <linux/delay.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #define DEBUG 
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index 4dbd3425e928..9769bf8279a6 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -1033,7 +1033,8 @@ DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);
 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
     defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
     defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
-    (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
+    (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC)) ||\
+    defined(CONFIG_AVR32)
 
 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
                         ((dev)->id.bustype == BUS_I8042) && ((dev)->id.vendor == 0x0001) && ((dev)->id.product == 0x0001))
diff --git a/drivers/char/rio/rioboot.c b/drivers/char/rio/rioboot.c
index eca2b95343e2..d956dd316005 100644
--- a/drivers/char/rio/rioboot.c
+++ b/drivers/char/rio/rioboot.c
@@ -35,7 +35,6 @@
 #include <linux/termios.h>
 #include <linux/serial.h>
 #include <linux/vmalloc.h>
-#include <asm/semaphore.h>
 #include <linux/generic_serial.h>
 #include <linux/errno.h>
 #include <linux/interrupt.h>
diff --git a/drivers/char/rio/riocmd.c b/drivers/char/rio/riocmd.c
index 7321d002c34f..bf36959fc121 100644
--- a/drivers/char/rio/riocmd.c
+++ b/drivers/char/rio/riocmd.c
@@ -41,7 +41,6 @@ static char *_riocmd_c_sccs_ = "@(#)riocmd.c	1.2";
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #include <linux/termios.h>
diff --git a/drivers/char/rio/rioctrl.c b/drivers/char/rio/rioctrl.c
index 7ce77619707c..d8eb2bcbe015 100644
--- a/drivers/char/rio/rioctrl.c
+++ b/drivers/char/rio/rioctrl.c
@@ -40,7 +40,6 @@ static char *_rioctrl_c_sccs_ = "@(#)rioctrl.c	1.3";
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #include <linux/termios.h>
diff --git a/drivers/char/rio/rioinit.c b/drivers/char/rio/rioinit.c
index 0794844369d6..add1718295ef 100644
--- a/drivers/char/rio/rioinit.c
+++ b/drivers/char/rio/rioinit.c
@@ -40,7 +40,6 @@ static char *_rioinit_c_sccs_ = "@(#)rioinit.c	1.3";
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #include <linux/termios.h>
diff --git a/drivers/char/rio/riointr.c b/drivers/char/rio/riointr.c
index ebc76342712c..4734e26e1ccd 100644
--- a/drivers/char/rio/riointr.c
+++ b/drivers/char/rio/riointr.c
@@ -42,7 +42,6 @@ static char *_riointr_c_sccs_ = "@(#)riointr.c	1.2";
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #include <linux/termios.h>
diff --git a/drivers/char/rio/rioparam.c b/drivers/char/rio/rioparam.c
index bb498d24adcc..da276ed57b3f 100644
--- a/drivers/char/rio/rioparam.c
+++ b/drivers/char/rio/rioparam.c
@@ -41,7 +41,6 @@ static char *_rioparam_c_sccs_ = "@(#)rioparam.c	1.3";
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #include <linux/termios.h>
diff --git a/drivers/char/rio/rioroute.c b/drivers/char/rio/rioroute.c
index a99f3d9d7d65..85091ff74d96 100644
--- a/drivers/char/rio/rioroute.c
+++ b/drivers/char/rio/rioroute.c
@@ -39,7 +39,6 @@ static char *_rioroute_c_sccs_ = "@(#)rioroute.c	1.3";
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #include <linux/termios.h>
diff --git a/drivers/char/rio/riotable.c b/drivers/char/rio/riotable.c
index 9b52892a501f..2b24488e95f2 100644
--- a/drivers/char/rio/riotable.c
+++ b/drivers/char/rio/riotable.c
@@ -42,7 +42,6 @@ static char *_riotable_c_sccs_ = "@(#)riotable.c	1.2";
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #include <linux/termios.h>
diff --git a/drivers/char/rio/riotty.c b/drivers/char/rio/riotty.c
index cfa54361473f..1cb8580a161d 100644
--- a/drivers/char/rio/riotty.c
+++ b/drivers/char/rio/riotty.c
@@ -44,7 +44,6 @@ static char *_riotty_c_sccs_ = "@(#)riotty.c	1.3";
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #include <linux/termios.h>
diff --git a/drivers/char/snsc.h b/drivers/char/snsc.h
index 8a98169b60c1..4be62eda9fbc 100644
--- a/drivers/char/snsc.h
+++ b/drivers/char/snsc.h
@@ -22,8 +22,8 @@
 #include <linux/kobject.h>
 #include <linux/fs.h>
 #include <linux/cdev.h>
+#include <linux/semaphore.h>
 #include <asm/sn/types.h>
-#include <asm/semaphore.h>
 
 #define CHUNKSIZE 127
 
diff --git a/drivers/clocksource/Makefile b/drivers/clocksource/Makefile
index a52225470225..1525882190fd 100644
--- a/drivers/clocksource/Makefile
+++ b/drivers/clocksource/Makefile
@@ -1,3 +1,4 @@
+obj-$(CONFIG_ATMEL_TCB_CLKSRC)  += tcb_clksrc.o
 obj-$(CONFIG_X86_CYCLONE_TIMER) += cyclone.o
 obj-$(CONFIG_X86_PM_TIMER)      += acpi_pm.o
 obj-$(CONFIG_SCx200HR_TIMER)    += scx200_hrt.o
diff --git a/drivers/clocksource/tcb_clksrc.c b/drivers/clocksource/tcb_clksrc.c
new file mode 100644
index 000000000000..f450588e5858
--- /dev/null
+++ b/drivers/clocksource/tcb_clksrc.c
@@ -0,0 +1,302 @@
+#include <linux/init.h>
+#include <linux/clocksource.h>
+#include <linux/clockchips.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/atmel_tc.h>
+
+
+/*
+ * We're configured to use a specific TC block, one that's not hooked
+ * up to external hardware, to provide a time solution:
+ *
+ *   - Two channels combine to create a free-running 32 bit counter
+ *     with a base rate of 5+ MHz, packaged as a clocksource (with
+ *     resolution better than 200 nsec).
+ *
+ *   - The third channel may be used to provide a 16-bit clockevent
+ *     source, used in either periodic or oneshot mode.  This runs
+ *     at 32 KiHZ, and can handle delays of up to two seconds.
+ *
+ * A boot clocksource and clockevent source are also currently needed,
+ * unless the relevant platforms (ARM/AT91, AVR32/AT32) are changed so
+ * this code can be used when init_timers() is called, well before most
+ * devices are set up.  (Some low end AT91 parts, which can run uClinux,
+ * have only the timers in one TC block... they currently don't support
+ * the tclib code, because of that initialization issue.)
+ *
+ * REVISIT behavior during system suspend states... we should disable
+ * all clocks and save the power.  Easily done for clockevent devices,
+ * but clocksources won't necessarily get the needed notifications.
+ * For deeper system sleep states, this will be mandatory...
+ */
+
+static void __iomem *tcaddr;
+
+static cycle_t tc_get_cycles(void)
+{
+        unsigned long   flags;
+        u32             lower, upper;
+
+        raw_local_irq_save(flags);
+        do {
+                upper = __raw_readl(tcaddr + ATMEL_TC_REG(1, CV));
+                lower = __raw_readl(tcaddr + ATMEL_TC_REG(0, CV));
+        } while (upper != __raw_readl(tcaddr + ATMEL_TC_REG(1, CV)));
+
+        raw_local_irq_restore(flags);
+        return (upper << 16) | lower;
+}
+
+static struct clocksource clksrc = {
+        .name           = "tcb_clksrc",
+        .rating         = 200,
+        .read           = tc_get_cycles,
+        .mask           = CLOCKSOURCE_MASK(32),
+        .shift          = 18,
+        .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
+};
+
+#ifdef CONFIG_GENERIC_CLOCKEVENTS
+
+struct tc_clkevt_device {
+        struct clock_event_device       clkevt;
+        struct clk                      *clk;
+        void __iomem                    *regs;
+};
+
+static struct tc_clkevt_device *to_tc_clkevt(struct clock_event_device *clkevt)
+{
+        return container_of(clkevt, struct tc_clkevt_device, clkevt);
+}
+
+/* For now, we always use the 32K clock ... this optimizes for NO_HZ,
+ * because using one of the divided clocks would usually mean the
+ * tick rate can never be less than several dozen Hz (vs 0.5 Hz).
+ *
+ * A divided clock could be good for high resolution timers, since
+ * 30.5 usec resolution can seem "low".
+ */
+static u32 timer_clock;
+
+static void tc_mode(enum clock_event_mode m, struct clock_event_device *d)
+{
+        struct tc_clkevt_device *tcd = to_tc_clkevt(d);
+        void __iomem            *regs = tcd->regs;
+
+        if (tcd->clkevt.mode == CLOCK_EVT_MODE_PERIODIC
+                        || tcd->clkevt.mode == CLOCK_EVT_MODE_ONESHOT) {
+                __raw_writel(0xff, regs + ATMEL_TC_REG(2, IDR));
+                __raw_writel(ATMEL_TC_CLKDIS, regs + ATMEL_TC_REG(2, CCR));
+                clk_disable(tcd->clk);
+        }
+
+        switch (m) {
+
+        /* By not making the gentime core emulate periodic mode on top
+         * of oneshot, we get lower overhead and improved accuracy.
+         */
+        case CLOCK_EVT_MODE_PERIODIC:
+                clk_enable(tcd->clk);
+
+                /* slow clock, count up to RC, then irq and restart */
+                __raw_writel(timer_clock
+                                | ATMEL_TC_WAVE | ATMEL_TC_WAVESEL_UP_AUTO,
+                                regs + ATMEL_TC_REG(2, CMR));
+                __raw_writel((32768 + HZ/2) / HZ, tcaddr + ATMEL_TC_REG(2, RC));
+
+                /* Enable clock and interrupts on RC compare */
+                __raw_writel(ATMEL_TC_CPCS, regs + ATMEL_TC_REG(2, IER));
+
+                /* go go gadget! */
+                __raw_writel(ATMEL_TC_CLKEN | ATMEL_TC_SWTRG,
+                                regs + ATMEL_TC_REG(2, CCR));
+                break;
+
+        case CLOCK_EVT_MODE_ONESHOT:
+                clk_enable(tcd->clk);
+
+                /* slow clock, count up to RC, then irq and stop */
+                __raw_writel(timer_clock | ATMEL_TC_CPCSTOP
+                                | ATMEL_TC_WAVE | ATMEL_TC_WAVESEL_UP_AUTO,
+                                regs + ATMEL_TC_REG(2, CMR));
+                __raw_writel(ATMEL_TC_CPCS, regs + ATMEL_TC_REG(2, IER));
+
+                /* set_next_event() configures and starts the timer */
+                break;
+
+        default:
+                break;
+        }
+}
+
+static int tc_next_event(unsigned long delta, struct clock_event_device *d)
+{
+        __raw_writel(delta, tcaddr + ATMEL_TC_REG(2, RC));
+
+        /* go go gadget! */
+        __raw_writel(ATMEL_TC_CLKEN | ATMEL_TC_SWTRG,
+                        tcaddr + ATMEL_TC_REG(2, CCR));
+        return 0;
+}
+
+static struct tc_clkevt_device clkevt = {
+        .clkevt = {
+                .name           = "tc_clkevt",
+                .features       = CLOCK_EVT_FEAT_PERIODIC
+                                        | CLOCK_EVT_FEAT_ONESHOT,
+                .shift          = 32,
+                /* Should be lower than at91rm9200's system timer */
+                .rating         = 125,
+                .cpumask        = CPU_MASK_CPU0,
+                .set_next_event = tc_next_event,
+                .set_mode       = tc_mode,
+        },
+};
+
+static irqreturn_t ch2_irq(int irq, void *handle)
+{
+        struct tc_clkevt_device *dev = handle;
+        unsigned int            sr;
+
+        sr = __raw_readl(dev->regs + ATMEL_TC_REG(2, SR));
+        if (sr & ATMEL_TC_CPCS) {
+                dev->clkevt.event_handler(&dev->clkevt);
+                return IRQ_HANDLED;
+        }
+
+        return IRQ_NONE;
+}
+
+static struct irqaction tc_irqaction = {
+        .name           = "tc_clkevt",
+        .flags          = IRQF_TIMER | IRQF_DISABLED,
+        .handler        = ch2_irq,
+};
+
+static void __init setup_clkevents(struct atmel_tc *tc, int clk32k_divisor_idx)
+{
+        struct clk *t2_clk = tc->clk[2];
+        int irq = tc->irq[2];
+
+        clkevt.regs = tc->regs;
+        clkevt.clk = t2_clk;
+        tc_irqaction.dev_id = &clkevt;
+
+        timer_clock = clk32k_divisor_idx;
+
+        clkevt.clkevt.mult = div_sc(32768, NSEC_PER_SEC, clkevt.clkevt.shift);
+        clkevt.clkevt.max_delta_ns
+                = clockevent_delta2ns(0xffff, &clkevt.clkevt);
+        clkevt.clkevt.min_delta_ns = clockevent_delta2ns(1, &clkevt.clkevt) + 1;
+
+        setup_irq(irq, &tc_irqaction);
+
+        clockevents_register_device(&clkevt.clkevt);
+}
+
+#else /* !CONFIG_GENERIC_CLOCKEVENTS */
+
+static void __init setup_clkevents(struct atmel_tc *tc, int clk32k_divisor_idx)
+{
+        /* NOTHING */
+}
+
+#endif
+
+static int __init tcb_clksrc_init(void)
+{
+        static char bootinfo[] __initdata
+                = KERN_DEBUG "%s: tc%d at %d.%03d MHz\n";
+
+        struct platform_device *pdev;
+        struct atmel_tc *tc;
+        struct clk *t0_clk;
+        u32 rate, divided_rate = 0;
+        int best_divisor_idx = -1;
+        int clk32k_divisor_idx = -1;
+        int i;
+
+        tc = atmel_tc_alloc(CONFIG_ATMEL_TCB_CLKSRC_BLOCK, clksrc.name);
+        if (!tc) {
+                pr_debug("can't alloc TC for clocksource\n");
+                return -ENODEV;
+        }
+        tcaddr = tc->regs;
+        pdev = tc->pdev;
+
+        t0_clk = tc->clk[0];
+        clk_enable(t0_clk);
+
+        /* How fast will we be counting?  Pick something over 5 MHz.  */
+        rate = (u32) clk_get_rate(t0_clk);
+        for (i = 0; i < 5; i++) {
+                unsigned divisor = atmel_tc_divisors[i];
+                unsigned tmp;
+
+                /* remember 32 KiHz clock for later */
+                if (!divisor) {
+                        clk32k_divisor_idx = i;
+                        continue;
+                }
+
+                tmp = rate / divisor;
+                pr_debug("TC: %u / %-3u [%d] --> %u\n", rate, divisor, i, tmp);
+                if (best_divisor_idx > 0) {
+                        if (tmp < 5 * 1000 * 1000)
+                                continue;
+                }
+                divided_rate = tmp;
+                best_divisor_idx = i;
+        }
+
+        clksrc.mult = clocksource_hz2mult(divided_rate, clksrc.shift);
+
+        printk(bootinfo, clksrc.name, CONFIG_ATMEL_TCB_CLKSRC_BLOCK,
+                        divided_rate / 1000000,
+                        ((divided_rate + 500000) % 1000000) / 1000);
+
+        /* tclib will give us three clocks no matter what the
+         * underlying platform supports.
+         */
+        clk_enable(tc->clk[1]);
+
+        /* channel 0:  waveform mode, input mclk/8, clock TIOA0 on overflow */
+        __raw_writel(best_divisor_idx                   /* likely divide-by-8 */
+                        | ATMEL_TC_WAVE
+                        | ATMEL_TC_WAVESEL_UP           /* free-run */
+                        | ATMEL_TC_ACPA_SET             /* TIOA0 rises at 0 */
+                        | ATMEL_TC_ACPC_CLEAR,          /* (duty cycle 50%) */
+                        tcaddr + ATMEL_TC_REG(0, CMR));
+        __raw_writel(0x0000, tcaddr + ATMEL_TC_REG(0, RA));
+        __raw_writel(0x8000, tcaddr + ATMEL_TC_REG(0, RC));
+        __raw_writel(0xff, tcaddr + ATMEL_TC_REG(0, IDR));      /* no irqs */
+        __raw_writel(ATMEL_TC_CLKEN, tcaddr + ATMEL_TC_REG(0, CCR));
+
+        /* channel 1:  waveform mode, input TIOA0 */
+        __raw_writel(ATMEL_TC_XC1                       /* input: TIOA0 */
+                        | ATMEL_TC_WAVE
+                        | ATMEL_TC_WAVESEL_UP,          /* free-run */
+                        tcaddr + ATMEL_TC_REG(1, CMR));
+        __raw_writel(0xff, tcaddr + ATMEL_TC_REG(1, IDR));      /* no irqs */
+        __raw_writel(ATMEL_TC_CLKEN, tcaddr + ATMEL_TC_REG(1, CCR));
+
+        /* chain channel 0 to channel 1, then reset all the timers */
+        __raw_writel(ATMEL_TC_TC1XC1S_TIOA0, tcaddr + ATMEL_TC_BMR);
+        __raw_writel(ATMEL_TC_SYNC, tcaddr + ATMEL_TC_BCR);
+
+        /* and away we go! */
+        clocksource_register(&clksrc);
+
+        /* channel 2:  periodic and oneshot timer support */
+        setup_clkevents(tc, clk32k_divisor_idx);
+
+        return 0;
+}
+arch_initcall(tcb_clksrc_init);
diff --git a/drivers/firewire/fw-device.c b/drivers/firewire/fw-device.c
index 2d01bc1b9752..d9c8daf7ae7d 100644
--- a/drivers/firewire/fw-device.c
+++ b/drivers/firewire/fw-device.c
@@ -26,7 +26,8 @@
 #include <linux/delay.h>
 #include <linux/idr.h>
 #include <linux/string.h>
-#include <asm/semaphore.h>
+#include <linux/rwsem.h>
+#include <linux/semaphore.h>
 #include <asm/system.h>
 #include <linux/ctype.h>
 #include "fw-transaction.h"
diff --git a/drivers/firewire/fw-transaction.c b/drivers/firewire/fw-transaction.c
index 3a59e9b783b0..ccf0e4cf108f 100644
--- a/drivers/firewire/fw-transaction.c
+++ b/drivers/firewire/fw-transaction.c
@@ -29,7 +29,6 @@
 #include <linux/list.h>
 #include <linux/kthread.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 
 #include "fw-transaction.h"
 #include "fw-topology.h"
diff --git a/drivers/firmware/dcdbas.c b/drivers/firmware/dcdbas.c
index 1636806ec55e..f235940719e7 100644
--- a/drivers/firmware/dcdbas.c
+++ b/drivers/firmware/dcdbas.c
@@ -35,7 +35,6 @@
 #include <linux/types.h>
 #include <linux/mutex.h>
 #include <asm/io.h>
-#include <asm/semaphore.h>
 
 #include "dcdbas.h"
 
@@ -265,7 +264,7 @@ static int smi_request(struct smi_cmd *smi_cmd)
 
         /* SMI requires CPU 0 */
         old_mask = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(0));
+        set_cpus_allowed_ptr(current, &cpumask_of_cpu(0));
         if (smp_processor_id() != 0) {
                 dev_dbg(&dcdbas_pdev->dev, "%s: failed to get CPU 0\n",
                         __FUNCTION__);
@@ -285,7 +284,7 @@ static int smi_request(struct smi_cmd *smi_cmd)
         );
 
 out:
-        set_cpus_allowed(current, old_mask);
+        set_cpus_allowed_ptr(current, &old_mask);
         return ret;
 }
 
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 5fa9c3c67e0c..b04c99580d0d 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -645,7 +645,7 @@ config I2C_PCA_ISA
 
 config I2C_MV64XXX
         tristate "Marvell mv64xxx I2C Controller"
-        depends on (MV64X60 || ARCH_ORION) && EXPERIMENTAL
+        depends on (MV64X60 || PLAT_ORION) && EXPERIMENTAL
         help
           If you say yes to this option, support will be included for the
           built-in I2C interface on the Marvell 64xxx line of host bridges.
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index 2d2087ad708f..6fd2d6a84eff 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
@@ -39,6 +39,7 @@
 #include <asm/io.h>
 #include <asm/arch/i2c.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-gpio.h>
 
 struct pxa_i2c {
         spinlock_t              lock;
diff --git a/drivers/i2c/chips/Kconfig b/drivers/i2c/chips/Kconfig
index b21593f93586..2da2edfa68ec 100644
--- a/drivers/i2c/chips/Kconfig
+++ b/drivers/i2c/chips/Kconfig
@@ -93,6 +93,7 @@ config ISP1301_OMAP
 
 config TPS65010
         tristate "TPS6501x Power Management chips"
+        depends on HAVE_GPIO_LIB
         default y if MACH_OMAP_H2 || MACH_OMAP_H3 || MACH_OMAP_OSK
         help
           If you say yes here you get support for the TPS6501x series of
diff --git a/drivers/i2c/chips/tps65010.c b/drivers/i2c/chips/tps65010.c
index 4154a9108859..b67f69c2e7f3 100644
--- a/drivers/i2c/chips/tps65010.c
+++ b/drivers/i2c/chips/tps65010.c
@@ -30,9 +30,13 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/mutex.h>
+#include <linux/platform_device.h>
 
 #include <linux/i2c/tps65010.h>
 
+#include <asm/gpio.h>
+
+
 /*-------------------------------------------------------------------------*/
 
 #define DRIVER_VERSION  "2 May 2005"
@@ -84,7 +88,9 @@ struct tps65010 {
         u8                      chgstatus, regstatus, chgconf;
         u8                      nmask1, nmask2;
 
-        /* not currently tracking GPIO state */
+        u8                      outmask;
+        struct gpio_chip        chip;
+        struct platform_device  *leds;
 };
 
 #define POWER_POLL_DELAY        msecs_to_jiffies(5000)
@@ -449,12 +455,72 @@ static irqreturn_t tps65010_irq(int irq, void *_tps)
 
 /*-------------------------------------------------------------------------*/
 
+/* offsets 0..3 == GPIO1..GPIO4
+ * offsets 4..5 == LED1/nPG, LED2 (we set one of the non-BLINK modes)
+ */
+static void
+tps65010_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        if (offset < 4)
+                tps65010_set_gpio_out_value(offset + 1, value);
+        else
+                tps65010_set_led(offset - 3, value ? ON : OFF);
+}
+
+static int
+tps65010_output(struct gpio_chip *chip, unsigned offset, int value)
+{
+        /* GPIOs may be input-only */
+        if (offset < 4) {
+                struct tps65010         *tps;
+
+                tps = container_of(chip, struct tps65010, chip);
+                if (!(tps->outmask & (1 << offset)))
+                        return -EINVAL;
+                tps65010_set_gpio_out_value(offset + 1, value);
+        } else
+                tps65010_set_led(offset - 3, value ? ON : OFF);
+
+        return 0;
+}
+
+static int tps65010_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        int                     value;
+        struct tps65010         *tps;
+
+        tps = container_of(chip, struct tps65010, chip);
+
+        if (offset < 4) {
+                value = i2c_smbus_read_byte_data(tps->client, TPS_DEFGPIO);
+                if (value < 0)
+                        return 0;
+                if (value & (1 << (offset + 4)))        /* output */
+                        return !(value & (1 << offset));
+                else                                    /* input */
+                        return (value & (1 << offset));
+        }
+
+        /* REVISIT we *could* report LED1/nPG and LED2 state ... */
+        return 0;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
 static struct tps65010 *the_tps;
 
 static int __exit tps65010_remove(struct i2c_client *client)
 {
         struct tps65010         *tps = i2c_get_clientdata(client);
+        struct tps65010_board   *board = client->dev.platform_data;
 
+        if (board && board->teardown) {
+                int status = board->teardown(client, board->context);
+                if (status < 0)
+                        dev_dbg(&client->dev, "board %s %s err %d\n",
+                                "teardown", client->name, status);
+        }
         if (client->irq > 0)
                 free_irq(client->irq, tps);
         cancel_delayed_work(&tps->work);
@@ -469,6 +535,7 @@ static int tps65010_probe(struct i2c_client *client)
 {
         struct tps65010         *tps;
         int                     status;
+        struct tps65010_board   *board = client->dev.platform_data;
 
         if (the_tps) {
                 dev_dbg(&client->dev, "only one tps6501x chip allowed\n");
@@ -577,6 +644,38 @@ static int tps65010_probe(struct i2c_client *client)
 
         tps->file = debugfs_create_file(DRIVER_NAME, S_IRUGO, NULL,
                                 tps, DEBUG_FOPS);
+
+        /* optionally register GPIOs */
+        if (board && board->base > 0) {
+                tps->outmask = board->outmask;
+
+                tps->chip.label = client->name;
+
+                tps->chip.set = tps65010_gpio_set;
+                tps->chip.direction_output = tps65010_output;
+
+                /* NOTE:  only partial support for inputs; nyet IRQs */
+                tps->chip.get = tps65010_gpio_get;
+
+                tps->chip.base = board->base;
+                tps->chip.ngpio = 6;
+                tps->chip.can_sleep = 1;
+
+                status = gpiochip_add(&tps->chip);
+                if (status < 0)
+                        dev_err(&client->dev, "can't add gpiochip, err %d\n",
+                                        status);
+                else if (board->setup) {
+                        status = board->setup(client, board->context);
+                        if (status < 0) {
+                                dev_dbg(&client->dev,
+                                        "board %s %s err %d\n",
+                                        "setup", client->name, status);
+                                status = 0;
+                        }
+                }
+        }
+
         return 0;
 fail1:
         kfree(tps);
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 8b645c6b2cb5..e186df657119 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -35,8 +35,8 @@
 #include <linux/completion.h>
 #include <linux/hardirq.h>
 #include <linux/irqflags.h>
+#include <linux/semaphore.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 
 #include "i2c-core.h"
 
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 70afa3786f3f..29d833e71cbf 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -18,8 +18,8 @@
 #include <linux/moduleparam.h>
 #include <linux/mutex.h>
 #include <linux/freezer.h>
+#include <linux/semaphore.h>
 #include <asm/atomic.h>
-#include <asm/semaphore.h>
 
 #include "csr.h"
 #include "highlevel.h"
diff --git a/drivers/infiniband/core/user_mad.c b/drivers/infiniband/core/user_mad.c
index 9a9d3446c6ed..3aa2db54eae4 100644
--- a/drivers/infiniband/core/user_mad.c
+++ b/drivers/infiniband/core/user_mad.c
@@ -46,9 +46,9 @@
 #include <linux/mutex.h>
 #include <linux/kref.h>
 #include <linux/compat.h>
+#include <linux/semaphore.h>
 
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 
 #include <rdma/ib_mad.h>
 #include <rdma/ib_user_mad.h>
diff --git a/drivers/infiniband/hw/amso1100/c2.h b/drivers/infiniband/hw/amso1100/c2.h
index ed38ab8d9c0c..d12a24a84fd9 100644
--- a/drivers/infiniband/hw/amso1100/c2.h
+++ b/drivers/infiniband/hw/amso1100/c2.h
@@ -40,7 +40,6 @@
 #include <linux/pci.h>
 #include <linux/dma-mapping.h>
 #include <linux/idr.h>
-#include <asm/semaphore.h>
 
 #include "c2_provider.h"
 #include "c2_mq.h"
diff --git a/drivers/infiniband/hw/mthca/mthca_dev.h b/drivers/infiniband/hw/mthca/mthca_dev.h
index 0e842e023400..7bc32f8e377e 100644
--- a/drivers/infiniband/hw/mthca/mthca_dev.h
+++ b/drivers/infiniband/hw/mthca/mthca_dev.h
@@ -46,8 +46,7 @@
 #include <linux/timer.h>
 #include <linux/mutex.h>
 #include <linux/list.h>
-
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 
 #include "mthca_provider.h"
 #include "mthca_doorbell.h"
diff --git a/drivers/infiniband/hw/nes/nes.h b/drivers/infiniband/hw/nes/nes.h
index 1626124a156d..cdf2e9ad62f7 100644
--- a/drivers/infiniband/hw/nes/nes.h
+++ b/drivers/infiniband/hw/nes/nes.h
@@ -43,7 +43,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/workqueue.h>
 #include <linux/slab.h>
-#include <asm/semaphore.h>
 #include <linux/version.h>
 #include <asm/io.h>
 #include <linux/crc32c.h>
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 8ea709be3306..efd70a974591 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -314,4 +314,13 @@ config KEYBOARD_BFIN
           To compile this driver as a module, choose M here: the
           module will be called bf54x-keys.
 
+config KEYBOARD_SH_KEYSC
+        tristate "SuperH KEYSC keypad support"
+        depends on SUPERH
+        help
+          Say Y here if you want to use a keypad attached to the KEYSC block
+          on SuperH processors such as sh7722 and sh7343.
+
+          To compile this driver as a module, choose M here: the
+          module will be called sh_keysc.
 endif
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index e741f4031012..0edc8f285d1c 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -26,3 +26,4 @@ obj-$(CONFIG_KEYBOARD_HP6XX)		+= jornada680_kbd.o
 obj-$(CONFIG_KEYBOARD_HP7XX)            += jornada720_kbd.o
 obj-$(CONFIG_KEYBOARD_MAPLE)            += maple_keyb.o
 obj-$(CONFIG_KEYBOARD_BFIN)             += bf54x-keys.o
+obj-$(CONFIG_KEYBOARD_SH_KEYSC)         += sh_keysc.o
diff --git a/drivers/input/keyboard/corgikbd.c b/drivers/input/keyboard/corgikbd.c
index 790fed368aae..5d6cc7f1dc94 100644
--- a/drivers/input/keyboard/corgikbd.c
+++ b/drivers/input/keyboard/corgikbd.c
@@ -23,6 +23,7 @@
 #include <asm/arch/corgi.h>
 #include <asm/arch/hardware.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-gpio.h>
 #include <asm/hardware/scoop.h>
 
 #define KB_ROWS                         8
diff --git a/drivers/input/keyboard/sh_keysc.c b/drivers/input/keyboard/sh_keysc.c
new file mode 100644
index 000000000000..8486abc457ed
--- /dev/null
+++ b/drivers/input/keyboard/sh_keysc.c
@@ -0,0 +1,280 @@
+/*
+ * SuperH KEYSC Keypad Driver
+ *
+ * Copyright (C) 2008 Magnus Damm
+ *
+ * Based on gpio_keys.c, Copyright 2005 Phil Blundell
+ *
+ * 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/init.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/io.h>
+#include <asm/sh_keysc.h>
+
+#define KYCR1_OFFS   0x00
+#define KYCR2_OFFS   0x04
+#define KYINDR_OFFS  0x08
+#define KYOUTDR_OFFS 0x0c
+
+#define KYCR2_IRQ_LEVEL    0x10
+#define KYCR2_IRQ_DISABLED 0x00
+
+static const struct {
+        unsigned char kymd, keyout, keyin;
+} sh_keysc_mode[] = {
+        [SH_KEYSC_MODE_1] = { 0, 6, 5 },
+        [SH_KEYSC_MODE_2] = { 1, 5, 6 },
+        [SH_KEYSC_MODE_3] = { 2, 4, 7 },
+};
+
+struct sh_keysc_priv {
+        void __iomem *iomem_base;
+        unsigned long last_keys;
+        struct input_dev *input;
+        struct sh_keysc_info pdata;
+};
+
+static irqreturn_t sh_keysc_isr(int irq, void *dev_id)
+{
+        struct platform_device *pdev = dev_id;
+        struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
+        struct sh_keysc_info *pdata = &priv->pdata;
+        unsigned long keys, keys1, keys0, mask;
+        unsigned char keyin_set, tmp;
+        int i, k;
+
+        dev_dbg(&pdev->dev, "isr!\n");
+
+        keys1 = ~0;
+        keys0 = 0;
+
+        do {
+                keys = 0;
+                keyin_set = 0;
+
+                iowrite16(KYCR2_IRQ_DISABLED, priv->iomem_base + KYCR2_OFFS);
+
+                for (i = 0; i < sh_keysc_mode[pdata->mode].keyout; i++) {
+                        iowrite16(0xfff ^ (3 << (i * 2)),
+                                  priv->iomem_base + KYOUTDR_OFFS);
+                        udelay(pdata->delay);
+                        tmp = ioread16(priv->iomem_base + KYINDR_OFFS);
+                        keys |= tmp << (sh_keysc_mode[pdata->mode].keyin * i);
+                        tmp ^= (1 << sh_keysc_mode[pdata->mode].keyin) - 1;
+                        keyin_set |= tmp;
+                }
+
+                iowrite16(0, priv->iomem_base + KYOUTDR_OFFS);
+                iowrite16(KYCR2_IRQ_LEVEL | (keyin_set << 8),
+                          priv->iomem_base + KYCR2_OFFS);
+
+                keys ^= ~0;
+                keys &= (1 << (sh_keysc_mode[pdata->mode].keyin *
+                               sh_keysc_mode[pdata->mode].keyout)) - 1;
+                keys1 &= keys;
+                keys0 |= keys;
+
+                dev_dbg(&pdev->dev, "keys 0x%08lx\n", keys);
+
+        } while (ioread16(priv->iomem_base + KYCR2_OFFS) & 0x01);
+
+        dev_dbg(&pdev->dev, "last_keys 0x%08lx keys0 0x%08lx keys1 0x%08lx\n",
+                priv->last_keys, keys0, keys1);
+
+        for (i = 0; i < SH_KEYSC_MAXKEYS; i++) {
+                k = pdata->keycodes[i];
+                if (!k)
+                        continue;
+
+                mask = 1 << i;
+
+                if (!((priv->last_keys ^ keys0) & mask))
+                        continue;
+
+                if ((keys1 | keys0) & mask) {
+                        input_event(priv->input, EV_KEY, k, 1);
+                        priv->last_keys |= mask;
+                }
+
+                if (!(keys1 & mask)) {
+                        input_event(priv->input, EV_KEY, k, 0);
+                        priv->last_keys &= ~mask;
+                }
+
+        }
+        input_sync(priv->input);
+
+        return IRQ_HANDLED;
+}
+
+#define res_size(res) ((res)->end - (res)->start + 1)
+
+static int __devinit sh_keysc_probe(struct platform_device *pdev)
+{
+        struct sh_keysc_priv *priv;
+        struct sh_keysc_info *pdata;
+        struct resource *res;
+        struct input_dev *input;
+        int i, k;
+        int irq, error;
+
+        if (!pdev->dev.platform_data) {
+                dev_err(&pdev->dev, "no platform data defined\n");
+                error = -EINVAL;
+                goto err0;
+        }
+
+        error = -ENXIO;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "failed to get I/O memory\n");
+                goto err0;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "failed to get irq\n");
+                goto err0;
+        }
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (priv == NULL) {
+                dev_err(&pdev->dev, "failed to allocate driver data\n");
+                error = -ENOMEM;
+                goto err0;
+        }
+
+        platform_set_drvdata(pdev, priv);
+        memcpy(&priv->pdata, pdev->dev.platform_data, sizeof(priv->pdata));
+        pdata = &priv->pdata;
+
+        res = request_mem_region(res->start, res_size(res), pdev->name);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "failed to request I/O memory\n");
+                error = -EBUSY;
+                goto err1;
+        }
+
+        priv->iomem_base = ioremap_nocache(res->start, res_size(res));
+        if (priv->iomem_base == NULL) {
+                dev_err(&pdev->dev, "failed to remap I/O memory\n");
+                error = -ENXIO;
+                goto err2;
+        }
+
+        priv->input = input_allocate_device();
+        if (!priv->input) {
+                dev_err(&pdev->dev, "failed to allocate input device\n");
+                error = -ENOMEM;
+                goto err3;
+        }
+
+        input = priv->input;
+        input->evbit[0] = BIT_MASK(EV_KEY);
+
+        input->name = pdev->name;
+        input->phys = "sh-keysc-keys/input0";
+        input->dev.parent = &pdev->dev;
+
+        input->id.bustype = BUS_HOST;
+        input->id.vendor = 0x0001;
+        input->id.product = 0x0001;
+        input->id.version = 0x0100;
+
+        error = request_irq(irq, sh_keysc_isr, 0, pdev->name, pdev);
+        if (error) {
+                dev_err(&pdev->dev, "failed to request IRQ\n");
+                goto err4;
+        }
+
+        for (i = 0; i < SH_KEYSC_MAXKEYS; i++) {
+                k = pdata->keycodes[i];
+                if (k)
+                        input_set_capability(input, EV_KEY, k);
+        }
+
+        error = input_register_device(input);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register input device\n");
+                goto err5;
+        }
+
+        iowrite16((sh_keysc_mode[pdata->mode].kymd << 8) |
+                  pdata->scan_timing, priv->iomem_base + KYCR1_OFFS);
+        iowrite16(0, priv->iomem_base + KYOUTDR_OFFS);
+        iowrite16(KYCR2_IRQ_LEVEL, priv->iomem_base + KYCR2_OFFS);
+        return 0;
+ err5:
+        free_irq(irq, pdev);
+ err4:
+        input_free_device(input);
+ err3:
+        iounmap(priv->iomem_base);
+ err2:
+        release_mem_region(res->start, res_size(res));
+ err1:
+        platform_set_drvdata(pdev, NULL);
+        kfree(priv);
+ err0:
+        return error;
+}
+
+static int __devexit sh_keysc_remove(struct platform_device *pdev)
+{
+        struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
+        struct resource *res;
+
+        iowrite16(KYCR2_IRQ_DISABLED, priv->iomem_base + KYCR2_OFFS);
+
+        input_unregister_device(priv->input);
+        free_irq(platform_get_irq(pdev, 0), pdev);
+        iounmap(priv->iomem_base);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, res_size(res));
+
+        platform_set_drvdata(pdev, NULL);
+        kfree(priv);
+        return 0;
+}
+
+
+#define sh_keysc_suspend NULL
+#define sh_keysc_resume NULL
+
+struct platform_driver sh_keysc_device_driver = {
+        .probe          = sh_keysc_probe,
+        .remove         = __devexit_p(sh_keysc_remove),
+        .suspend        = sh_keysc_suspend,
+        .resume         = sh_keysc_resume,
+        .driver         = {
+                .name   = "sh_keysc",
+        }
+};
+
+static int __init sh_keysc_init(void)
+{
+        return platform_driver_register(&sh_keysc_device_driver);
+}
+
+static void __exit sh_keysc_exit(void)
+{
+        platform_driver_unregister(&sh_keysc_device_driver);
+}
+
+module_init(sh_keysc_init);
+module_exit(sh_keysc_exit);
+
+MODULE_AUTHOR("Magnus Damm");
+MODULE_DESCRIPTION("SuperH KEYSC Keypad Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/spitzkbd.c b/drivers/input/keyboard/spitzkbd.c
index 1d59a2dc3c17..0be74bfc58fe 100644
--- a/drivers/input/keyboard/spitzkbd.c
+++ b/drivers/input/keyboard/spitzkbd.c
@@ -23,6 +23,7 @@
 #include <asm/arch/spitz.h>
 #include <asm/arch/hardware.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-gpio.h>
 
 #define KB_ROWS                 7
 #define KB_COLS                 11
diff --git a/drivers/input/serio/hp_sdc_mlc.c b/drivers/input/serio/hp_sdc_mlc.c
index c45ea74d53e4..f1fd3b638a37 100644
--- a/drivers/input/serio/hp_sdc_mlc.c
+++ b/drivers/input/serio/hp_sdc_mlc.c
@@ -40,7 +40,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/string.h>
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 
 #define PREFIX "HP SDC MLC: "
 
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index 57a1c28bf122..39573b91c8de 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -28,13 +28,6 @@
 #include <linux/spi/ads7846.h>
 #include <asm/irq.h>
 
-#ifdef  CONFIG_ARM
-#include <asm/mach-types.h>
-#ifdef  CONFIG_ARCH_OMAP
-#include <asm/arch/gpio.h>
-#endif
-#endif
-
 
 /*
  * This code has been heavily tested on a Nokia 770, and lightly
@@ -1174,31 +1167,6 @@ static struct spi_driver ads7846_driver = {
 
 static int __init ads7846_init(void)
 {
-        /* grr, board-specific init should stay out of drivers!! */
-
-#ifdef  CONFIG_ARCH_OMAP
-        if (machine_is_omap_osk()) {
-                /* GPIO4 = PENIRQ; GPIO6 = BUSY */
-                omap_request_gpio(4);
-                omap_set_gpio_direction(4, 1);
-                omap_request_gpio(6);
-                omap_set_gpio_direction(6, 1);
-        }
-        // also TI 1510 Innovator, bitbanging through FPGA
-        // also Nokia 770
-        // also Palm Tungsten T2
-#endif
-
-        // PXA:
-        // also Dell Axim X50
-        // also HP iPaq H191x/H192x/H415x/H435x
-        // also Intel Lubbock (additional to UCB1400; as temperature sensor)
-        // also Sharp Zaurus C7xx, C8xx (corgi/sheperd/husky)
-
-        // Atmel at91sam9261-EK uses ads7843
-
-        // also various AMD Au1x00 devel boards
-
         return spi_register_driver(&ads7846_driver);
 }
 module_init(ads7846_init);
@@ -1206,14 +1174,6 @@ module_init(ads7846_init);
 static void __exit ads7846_exit(void)
 {
         spi_unregister_driver(&ads7846_driver);
-
-#ifdef  CONFIG_ARCH_OMAP
-        if (machine_is_omap_osk()) {
-                omap_free_gpio(4);
-                omap_free_gpio(6);
-        }
-#endif
-
 }
 module_exit(ads7846_exit);
 
diff --git a/drivers/input/touchscreen/corgi_ts.c b/drivers/input/touchscreen/corgi_ts.c
index 99d92f5c93d6..a22576779acd 100644
--- a/drivers/input/touchscreen/corgi_ts.c
+++ b/drivers/input/touchscreen/corgi_ts.c
@@ -22,6 +22,7 @@
 #include <asm/arch/sharpsl.h>
 #include <asm/arch/hardware.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-gpio.h>
 
 
 #define PWR_MODE_ACTIVE         0
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index 859814f62cb0..a3a6199639f9 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -46,13 +46,6 @@ config LEDS_SPITZ
           This option enables support for the LEDs on Sharp Zaurus
           SL-Cxx00 series (C1000, C3000, C3100).
 
-config LEDS_TOSA
-        tristate "LED Support for the Sharp SL-6000 series"
-        depends on LEDS_CLASS && PXA_SHARPSL
-        help
-          This option enables support for the LEDs on Sharp Zaurus
-          SL-6000 series.
-
 config LEDS_S3C24XX
         tristate "LED Support for Samsung S3C24XX GPIO LEDs"
         depends on LEDS_CLASS && ARCH_S3C2410
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index 84ced3b1a13d..e54f42da21a2 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -9,7 +9,6 @@ obj-$(CONFIG_LEDS_ATMEL_PWM)		+= leds-atmel-pwm.o
 obj-$(CONFIG_LEDS_CORGI)                += leds-corgi.o
 obj-$(CONFIG_LEDS_LOCOMO)               += leds-locomo.o
 obj-$(CONFIG_LEDS_SPITZ)                += leds-spitz.o
-obj-$(CONFIG_LEDS_TOSA)                 += leds-tosa.o
 obj-$(CONFIG_LEDS_S3C24XX)              += leds-s3c24xx.o
 obj-$(CONFIG_LEDS_AMS_DELTA)            += leds-ams-delta.o
 obj-$(CONFIG_LEDS_NET48XX)              += leds-net48xx.o
diff --git a/drivers/leds/leds-tosa.c b/drivers/leds/leds-tosa.c
deleted file mode 100644
index 7ebecc41a9be..000000000000
--- a/drivers/leds/leds-tosa.c
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * LED Triggers Core
- *
- * Copyright 2005 Dirk Opfer
- *
- * Author: Dirk Opfer <Dirk@Opfer-Online.de>
- *      based on spitz.c
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/leds.h>
-#include <asm/hardware/scoop.h>
-#include <asm/mach-types.h>
-#include <asm/arch/hardware.h>
-#include <asm/arch/pxa-regs.h>
-#include <asm/arch/tosa.h>
-
-static void tosaled_amber_set(struct led_classdev *led_cdev,
-                                enum led_brightness value)
-{
-        if (value)
-                set_scoop_gpio(&tosascoop_jc_device.dev,
-                                TOSA_SCOOP_JC_CHRG_ERR_LED);
-        else
-                reset_scoop_gpio(&tosascoop_jc_device.dev,
-                                TOSA_SCOOP_JC_CHRG_ERR_LED);
-}
-
-static void tosaled_green_set(struct led_classdev *led_cdev,
-                                enum led_brightness value)
-{
-        if (value)
-                set_scoop_gpio(&tosascoop_jc_device.dev,
-                                TOSA_SCOOP_JC_NOTE_LED);
-        else
-                reset_scoop_gpio(&tosascoop_jc_device.dev,
-                                TOSA_SCOOP_JC_NOTE_LED);
-}
-
-static struct led_classdev tosa_amber_led = {
-        .name                   = "tosa:amber:charge",
-        .default_trigger        = "sharpsl-charge",
-        .brightness_set         = tosaled_amber_set,
-};
-
-static struct led_classdev tosa_green_led = {
-        .name                   = "tosa:green:mail",
-        .default_trigger        = "nand-disk",
-        .brightness_set         = tosaled_green_set,
-};
-
-#ifdef CONFIG_PM
-static int tosaled_suspend(struct platform_device *dev, pm_message_t state)
-{
-#ifdef CONFIG_LEDS_TRIGGERS
-        if (tosa_amber_led.trigger && strcmp(tosa_amber_led.trigger->name,
-                                                "sharpsl-charge"))
-#endif
-                led_classdev_suspend(&tosa_amber_led);
-        led_classdev_suspend(&tosa_green_led);
-        return 0;
-}
-
-static int tosaled_resume(struct platform_device *dev)
-{
-        led_classdev_resume(&tosa_amber_led);
-        led_classdev_resume(&tosa_green_led);
-        return 0;
-}
-#else
-#define tosaled_suspend NULL
-#define tosaled_resume NULL
-#endif
-
-static int tosaled_probe(struct platform_device *pdev)
-{
-        int ret;
-
-        ret = led_classdev_register(&pdev->dev, &tosa_amber_led);
-        if (ret < 0)
-                return ret;
-
-        ret = led_classdev_register(&pdev->dev, &tosa_green_led);
-        if (ret < 0)
-                led_classdev_unregister(&tosa_amber_led);
-
-        return ret;
-}
-
-static int tosaled_remove(struct platform_device *pdev)
-{
-        led_classdev_unregister(&tosa_amber_led);
-        led_classdev_unregister(&tosa_green_led);
-
-        return 0;
-}
-
-static struct platform_driver tosaled_driver = {
-        .probe          = tosaled_probe,
-        .remove         = tosaled_remove,
-        .suspend        = tosaled_suspend,
-        .resume         = tosaled_resume,
-        .driver         = {
-                .name           = "tosa-led",
-                .owner          = THIS_MODULE,
-        },
-};
-
-static int __init tosaled_init(void)
-{
-        return platform_driver_register(&tosaled_driver);
-}
-
-static void __exit tosaled_exit(void)
-{
-        platform_driver_unregister(&tosaled_driver);
-}
-
-module_init(tosaled_init);
-module_exit(tosaled_exit);
-
-MODULE_AUTHOR("Dirk Opfer <Dirk@Opfer-Online.de>");
-MODULE_DESCRIPTION("Tosa LED driver");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:tosa-led");
diff --git a/drivers/lguest/lg.h b/drivers/lguest/lg.h
index 2337e1a06f02..005bd045d2eb 100644
--- a/drivers/lguest/lg.h
+++ b/drivers/lguest/lg.h
@@ -10,7 +10,6 @@
 #include <linux/wait.h>
 #include <linux/hrtimer.h>
 #include <linux/err.h>
-#include <asm/semaphore.h>
 
 #include <asm/lguest.h>
 
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 28958101061f..20978205cd02 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -37,9 +37,9 @@
 #include <linux/device.h>
 #include <linux/kthread.h>
 #include <linux/platform_device.h>
+#include <linux/semaphore.h>
 
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 #ifdef CONFIG_PPC
 #include <asm/prom.h>
 #include <asm/machdep.h>
diff --git a/drivers/macintosh/windfarm_smu_sat.c b/drivers/macintosh/windfarm_smu_sat.c
index f449d775cdf4..797918d0e59c 100644
--- a/drivers/macintosh/windfarm_smu_sat.c
+++ b/drivers/macintosh/windfarm_smu_sat.c
@@ -13,7 +13,7 @@
 #include <linux/init.h>
 #include <linux/wait.h>
 #include <linux/i2c.h>
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 #include <asm/prom.h>
 #include <asm/smu.h>
 #include <asm/pmac_low_i2c.h>
diff --git a/drivers/media/radio/radio-aimslab.c b/drivers/media/radio/radio-aimslab.c
index f0a67e93d7fd..c69bde39a233 100644
--- a/drivers/media/radio/radio-aimslab.c
+++ b/drivers/media/radio/radio-aimslab.c
@@ -36,7 +36,6 @@
 #include <asm/uaccess.h>        /* copy to/from user            */
 #include <linux/videodev2.h>    /* kernel radio structs         */
 #include <media/v4l2-common.h>
-#include <asm/semaphore.h>      /* Lock for the I/O             */
 
 #include <linux/version.h>      /* for KERNEL_VERSION MACRO     */
 #define RADIO_VERSION KERNEL_VERSION(0,0,2)
diff --git a/drivers/media/video/ir-kbd-i2c.c b/drivers/media/video/ir-kbd-i2c.c
index 9851987b95fb..dabafdf71e60 100644
--- a/drivers/media/video/ir-kbd-i2c.c
+++ b/drivers/media/video/ir-kbd-i2c.c
@@ -40,7 +40,6 @@
 #include <linux/i2c.h>
 #include <linux/i2c-id.h>
 #include <linux/workqueue.h>
-#include <asm/semaphore.h>
 
 #include <media/ir-common.h>
 #include <media/ir-kbd-i2c.h>
diff --git a/drivers/media/video/ov511.c b/drivers/media/video/ov511.c
index d55d5800efb4..6590058e8ff0 100644
--- a/drivers/media/video/ov511.c
+++ b/drivers/media/video/ov511.c
@@ -41,7 +41,6 @@
 #include <linux/slab.h>
 #include <linux/ctype.h>
 #include <linux/pagemap.h>
-#include <asm/semaphore.h>
 #include <asm/processor.h>
 #include <linux/mm.h>
 #include <linux/device.h>
diff --git a/drivers/media/video/pvrusb2/pvrusb2-context.c b/drivers/media/video/pvrusb2/pvrusb2-context.c
index 9d94aed2e12d..160437b21e6d 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-context.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-context.c
@@ -26,7 +26,6 @@
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/slab.h>
-#include <asm/semaphore.h>
 
 
 static void pvr2_context_destroy(struct pvr2_context *mp)
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.c b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
index d6955fa39598..2404053a4d85 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
@@ -25,7 +25,6 @@
 #include <linux/firmware.h>
 #include <linux/videodev2.h>
 #include <media/v4l2-common.h>
-#include <asm/semaphore.h>
 #include "pvrusb2.h"
 #include "pvrusb2-std.h"
 #include "pvrusb2-util.h"
diff --git a/drivers/media/video/pvrusb2/pvrusb2-sysfs.c b/drivers/media/video/pvrusb2/pvrusb2-sysfs.c
index 7a1cd878e31a..07f4eae18433 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-sysfs.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-sysfs.c
@@ -21,7 +21,6 @@
 
 #include <linux/string.h>
 #include <linux/slab.h>
-#include <asm/semaphore.h>
 #include "pvrusb2-sysfs.h"
 #include "pvrusb2-hdw.h"
 #include "pvrusb2-debug.h"
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 0c886c882385..2566479937c9 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -22,6 +22,22 @@ config MFD_ASIC3
           This driver supports the ASIC3 multifunction chip found on many
           PDAs (mainly iPAQ and HTC based ones)
 
+config HTC_EGPIO
+        bool "HTC EGPIO support"
+        depends on GENERIC_HARDIRQS && HAVE_GPIO_LIB
+        help
+            This driver supports the CPLD egpio chip present on
+            several HTC phones.  It provides basic support for input
+            pins, output pins, and irqs.
+
+config HTC_PASIC3
+        tristate "HTC PASIC3 LED/DS1WM chip support"
+        help
+          This core driver provides register access for the LED/DS1WM
+          chips labeled "AIC2" and "AIC3", found on HTC Blueangel and
+          HTC Magician devices, respectively. Actual functionality is
+          handled by the leds-pasic3 and ds1wm drivers.
+
 endmenu
 
 menu "Multimedia Capabilities Port drivers"
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 521cd5cb68af..eef4e26807df 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -5,6 +5,9 @@
 obj-$(CONFIG_MFD_SM501)         += sm501.o
 obj-$(CONFIG_MFD_ASIC3)         += asic3.o
 
+obj-$(CONFIG_HTC_EGPIO)         += htc-egpio.o
+obj-$(CONFIG_HTC_PASIC3)        += htc-pasic3.o
+
 obj-$(CONFIG_MCP)               += mcp-core.o
 obj-$(CONFIG_MCP_SA11X0)        += mcp-sa11x0.o
 obj-$(CONFIG_MCP_UCB1200)       += ucb1x00-core.o
diff --git a/drivers/mfd/htc-egpio.c b/drivers/mfd/htc-egpio.c
new file mode 100644
index 000000000000..8872cc077519
--- /dev/null
+++ b/drivers/mfd/htc-egpio.c
@@ -0,0 +1,440 @@
+/*
+ * Support for the GPIO/IRQ expander chips present on several HTC phones.
+ * These are implemented in CPLD chips present on the board.
+ *
+ * Copyright (c) 2007 Kevin O'Connor <kevin@koconnor.net>
+ * Copyright (c) 2007 Philipp Zabel <philipp.zabel@gmail.com>
+ *
+ * This file may be distributed under the terms of the GNU GPL license.
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/io.h>
+#include <linux/spinlock.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/mfd/htc-egpio.h>
+
+struct egpio_chip {
+        int              reg_start;
+        int              cached_values;
+        unsigned long    is_out;
+        struct device    *dev;
+        struct gpio_chip chip;
+};
+
+struct egpio_info {
+        spinlock_t        lock;
+
+        /* iomem info */
+        void __iomem      *base_addr;
+        int               bus_shift;    /* byte shift */
+        int               reg_shift;    /* bit shift */
+        int               reg_mask;
+
+        /* irq info */
+        int               ack_register;
+        int               ack_write;
+        u16               irqs_enabled;
+        uint              irq_start;
+        int               nirqs;
+        uint              chained_irq;
+
+        /* egpio info */
+        struct egpio_chip *chip;
+        int               nchips;
+};
+
+static inline void egpio_writew(u16 value, struct egpio_info *ei, int reg)
+{
+        writew(value, ei->base_addr + (reg << ei->bus_shift));
+}
+
+static inline u16 egpio_readw(struct egpio_info *ei, int reg)
+{
+        return readw(ei->base_addr + (reg << ei->bus_shift));
+}
+
+/*
+ * IRQs
+ */
+
+static inline void ack_irqs(struct egpio_info *ei)
+{
+        egpio_writew(ei->ack_write, ei, ei->ack_register);
+        pr_debug("EGPIO ack - write %x to base+%x\n",
+                        ei->ack_write, ei->ack_register << ei->bus_shift);
+}
+
+static void egpio_ack(unsigned int irq)
+{
+}
+
+/* There does not appear to be a way to proactively mask interrupts
+ * on the egpio chip itself.  So, we simply ignore interrupts that
+ * aren't desired. */
+static void egpio_mask(unsigned int irq)
+{
+        struct egpio_info *ei = get_irq_chip_data(irq);
+        ei->irqs_enabled &= ~(1 << (irq - ei->irq_start));
+        pr_debug("EGPIO mask %d %04x\n", irq, ei->irqs_enabled);
+}
+static void egpio_unmask(unsigned int irq)
+{
+        struct egpio_info *ei = get_irq_chip_data(irq);
+        ei->irqs_enabled |= 1 << (irq - ei->irq_start);
+        pr_debug("EGPIO unmask %d %04x\n", irq, ei->irqs_enabled);
+}
+
+static struct irq_chip egpio_muxed_chip = {
+        .name   = "htc-egpio",
+        .ack    = egpio_ack,
+        .mask   = egpio_mask,
+        .unmask = egpio_unmask,
+};
+
+static void egpio_handler(unsigned int irq, struct irq_desc *desc)
+{
+        struct egpio_info *ei = get_irq_data(irq);
+        int irqpin;
+
+        /* Read current pins. */
+        unsigned long readval = egpio_readw(ei, ei->ack_register);
+        pr_debug("IRQ reg: %x\n", (unsigned int)readval);
+        /* Ack/unmask interrupts. */
+        ack_irqs(ei);
+        /* Process all set pins. */
+        readval &= ei->irqs_enabled;
+        for_each_bit(irqpin, &readval, ei->nirqs) {
+                /* Run irq handler */
+                pr_debug("got IRQ %d\n", irqpin);
+                irq = ei->irq_start + irqpin;
+                desc = &irq_desc[irq];
+                desc->handle_irq(irq, desc);
+        }
+}
+
+int htc_egpio_get_wakeup_irq(struct device *dev)
+{
+        struct egpio_info *ei = dev_get_drvdata(dev);
+
+        /* Read current pins. */
+        u16 readval = egpio_readw(ei, ei->ack_register);
+        /* Ack/unmask interrupts. */
+        ack_irqs(ei);
+        /* Return first set pin. */
+        readval &= ei->irqs_enabled;
+        return ei->irq_start + ffs(readval) - 1;
+}
+EXPORT_SYMBOL(htc_egpio_get_wakeup_irq);
+
+static inline int egpio_pos(struct egpio_info *ei, int bit)
+{
+        return bit >> ei->reg_shift;
+}
+
+static inline int egpio_bit(struct egpio_info *ei, int bit)
+{
+        return 1 << (bit & ((1 << ei->reg_shift)-1));
+}
+
+/*
+ * Input pins
+ */
+
+static int egpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct egpio_chip *egpio;
+        struct egpio_info *ei;
+        unsigned           bit;
+        int                reg;
+        int                value;
+
+        pr_debug("egpio_get_value(%d)\n", chip->base + offset);
+
+        egpio = container_of(chip, struct egpio_chip, chip);
+        ei    = dev_get_drvdata(egpio->dev);
+        bit   = egpio_bit(ei, offset);
+        reg   = egpio->reg_start + egpio_pos(ei, offset);
+
+        value = egpio_readw(ei, reg);
+        pr_debug("readw(%p + %x) = %x\n",
+                        ei->base_addr, reg << ei->bus_shift, value);
+        return value & bit;
+}
+
+static int egpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        struct egpio_chip *egpio;
+
+        egpio = container_of(chip, struct egpio_chip, chip);
+        return test_bit(offset, &egpio->is_out) ? -EINVAL : 0;
+}
+
+
+/*
+ * Output pins
+ */
+
+static void egpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        unsigned long     flag;
+        struct egpio_chip *egpio;
+        struct egpio_info *ei;
+        unsigned          bit;
+        int               pos;
+        int               reg;
+        int               shift;
+
+        pr_debug("egpio_set(%s, %d(%d), %d)\n",
+                        chip->label, offset, offset+chip->base, value);
+
+        egpio = container_of(chip, struct egpio_chip, chip);
+        ei    = dev_get_drvdata(egpio->dev);
+        bit   = egpio_bit(ei, offset);
+        pos   = egpio_pos(ei, offset);
+        reg   = egpio->reg_start + pos;
+        shift = pos << ei->reg_shift;
+
+        pr_debug("egpio %s: reg %d = 0x%04x\n", value ? "set" : "clear",
+                        reg, (egpio->cached_values >> shift) & ei->reg_mask);
+
+        spin_lock_irqsave(&ei->lock, flag);
+        if (value)
+                egpio->cached_values |= (1 << offset);
+        else
+                egpio->cached_values &= ~(1 << offset);
+        egpio_writew((egpio->cached_values >> shift) & ei->reg_mask, ei, reg);
+        spin_unlock_irqrestore(&ei->lock, flag);
+}
+
+static int egpio_direction_output(struct gpio_chip *chip,
+                                        unsigned offset, int value)
+{
+        struct egpio_chip *egpio;
+
+        egpio = container_of(chip, struct egpio_chip, chip);
+        if (test_bit(offset, &egpio->is_out)) {
+                egpio_set(chip, offset, value);
+                return 0;
+        } else {
+                return -EINVAL;
+        }
+}
+
+static void egpio_write_cache(struct egpio_info *ei)
+{
+        int               i;
+        struct egpio_chip *egpio;
+        int               shift;
+
+        for (i = 0; i < ei->nchips; i++) {
+                egpio = &(ei->chip[i]);
+                if (!egpio->is_out)
+                        continue;
+
+                for (shift = 0; shift < egpio->chip.ngpio;
+                                shift += (1<<ei->reg_shift)) {
+
+                        int reg = egpio->reg_start + egpio_pos(ei, shift);
+
+                        if (!((egpio->is_out >> shift) & ei->reg_mask))
+                                continue;
+
+                        pr_debug("EGPIO: setting %x to %x, was %x\n", reg,
+                                (egpio->cached_values >> shift) & ei->reg_mask,
+                                egpio_readw(ei, reg));
+
+                        egpio_writew((egpio->cached_values >> shift)
+                                        & ei->reg_mask, ei, reg);
+                }
+        }
+}
+
+
+/*
+ * Setup
+ */
+
+static int __init egpio_probe(struct platform_device *pdev)
+{
+        struct htc_egpio_platform_data *pdata = pdev->dev.platform_data;
+        struct resource   *res;
+        struct egpio_info *ei;
+        struct gpio_chip  *chip;
+        unsigned int      irq, irq_end;
+        int               i;
+        int               ret;
+
+        /* Initialize ei data structure. */
+        ei = kzalloc(sizeof(*ei), GFP_KERNEL);
+        if (!ei)
+                return -ENOMEM;
+
+        spin_lock_init(&ei->lock);
+
+        /* Find chained irq */
+        ret = -EINVAL;
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (res)
+                ei->chained_irq = res->start;
+
+        /* Map egpio chip into virtual address space. */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                goto fail;
+        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);
+
+        if ((pdata->bus_width != 16) && (pdata->bus_width != 32))
+                goto fail;
+        ei->bus_shift = fls(pdata->bus_width - 1) - 3;
+        pr_debug("bus_shift = %d\n", ei->bus_shift);
+
+        if ((pdata->reg_width != 8) && (pdata->reg_width != 16))
+                goto fail;
+        ei->reg_shift = fls(pdata->reg_width - 1);
+        pr_debug("reg_shift = %d\n", ei->reg_shift);
+
+        ei->reg_mask = (1 << pdata->reg_width) - 1;
+
+        platform_set_drvdata(pdev, ei);
+
+        ei->nchips = pdata->num_chips;
+        ei->chip = kzalloc(sizeof(struct egpio_chip) * ei->nchips, GFP_KERNEL);
+        if (!ei) {
+                ret = -ENOMEM;
+                goto fail;
+        }
+        for (i = 0; i < ei->nchips; i++) {
+                ei->chip[i].reg_start = pdata->chip[i].reg_start;
+                ei->chip[i].cached_values = pdata->chip[i].initial_values;
+                ei->chip[i].is_out = pdata->chip[i].direction;
+                ei->chip[i].dev = &(pdev->dev);
+                chip = &(ei->chip[i].chip);
+                chip->label           = "htc-egpio";
+                chip->get             = egpio_get;
+                chip->set             = egpio_set;
+                chip->direction_input = egpio_direction_input;
+                chip->direction_output = egpio_direction_output;
+                chip->base            = pdata->chip[i].gpio_base;
+                chip->ngpio           = pdata->chip[i].num_gpios;
+
+                gpiochip_add(chip);
+        }
+
+        /* Set initial pin values */
+        egpio_write_cache(ei);
+
+        ei->irq_start = pdata->irq_base;
+        ei->nirqs = pdata->num_irqs;
+        ei->ack_register = pdata->ack_register;
+
+        if (ei->chained_irq) {
+                /* Setup irq handlers */
+                ei->ack_write = 0xFFFF;
+                if (pdata->invert_acks)
+                        ei->ack_write = 0;
+                irq_end = ei->irq_start + ei->nirqs;
+                for (irq = ei->irq_start; irq < irq_end; irq++) {
+                        set_irq_chip(irq, &egpio_muxed_chip);
+                        set_irq_chip_data(irq, ei);
+                        set_irq_handler(irq, handle_simple_irq);
+                        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
+                }
+                set_irq_type(ei->chained_irq, IRQ_TYPE_EDGE_RISING);
+                set_irq_data(ei->chained_irq, ei);
+                set_irq_chained_handler(ei->chained_irq, egpio_handler);
+                ack_irqs(ei);
+
+                device_init_wakeup(&pdev->dev, 1);
+        }
+
+        return 0;
+
+fail:
+        printk(KERN_ERR "EGPIO failed to setup\n");
+        kfree(ei);
+        return ret;
+}
+
+static int __exit egpio_remove(struct platform_device *pdev)
+{
+        struct egpio_info *ei = platform_get_drvdata(pdev);
+        unsigned int      irq, irq_end;
+
+        if (ei->chained_irq) {
+                irq_end = ei->irq_start + ei->nirqs;
+                for (irq = ei->irq_start; irq < irq_end; irq++) {
+                        set_irq_chip(irq, NULL);
+                        set_irq_handler(irq, NULL);
+                        set_irq_flags(irq, 0);
+                }
+                set_irq_chained_handler(ei->chained_irq, NULL);
+                device_init_wakeup(&pdev->dev, 0);
+        }
+        iounmap(ei->base_addr);
+        kfree(ei->chip);
+        kfree(ei);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int egpio_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct egpio_info *ei = platform_get_drvdata(pdev);
+
+        if (ei->chained_irq && device_may_wakeup(&pdev->dev))
+                enable_irq_wake(ei->chained_irq);
+        return 0;
+}
+
+static int egpio_resume(struct platform_device *pdev)
+{
+        struct egpio_info *ei = platform_get_drvdata(pdev);
+
+        if (ei->chained_irq && device_may_wakeup(&pdev->dev))
+                disable_irq_wake(ei->chained_irq);
+
+        /* Update registers from the cache, in case
+           the CPLD was powered off during suspend */
+        egpio_write_cache(ei);
+        return 0;
+}
+#else
+#define egpio_suspend NULL
+#define egpio_resume NULL
+#endif
+
+
+static struct platform_driver egpio_driver = {
+        .driver = {
+                .name = "htc-egpio",
+        },
+        .remove       = __exit_p(egpio_remove),
+        .suspend      = egpio_suspend,
+        .resume       = egpio_resume,
+};
+
+static int __init egpio_init(void)
+{
+        return platform_driver_probe(&egpio_driver, egpio_probe);
+}
+
+static void __exit egpio_exit(void)
+{
+        platform_driver_unregister(&egpio_driver);
+}
+
+/* start early for dependencies */
+subsys_initcall(egpio_init);
+module_exit(egpio_exit)
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Kevin O'Connor <kevin@koconnor.net>");
diff --git a/drivers/mfd/htc-pasic3.c b/drivers/mfd/htc-pasic3.c
new file mode 100644
index 000000000000..af66f4f28300
--- /dev/null
+++ b/drivers/mfd/htc-pasic3.c
@@ -0,0 +1,265 @@
+/*
+ * Core driver for HTC PASIC3 LED/DS1WM chip.
+ *
+ * Copyright (C) 2006 Philipp Zabel <philipp.zabel@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+#include <linux/ds1wm.h>
+#include <linux/gpio.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/htc-pasic3.h>
+
+#include <asm/arch/pxa-regs.h>
+
+struct pasic3_data {
+        void __iomem *mapping;
+        unsigned int bus_shift;
+        struct platform_device *ds1wm_pdev;
+        struct platform_device *led_pdev;
+};
+
+#define REG_ADDR  5
+#define REG_DATA  6
+#define NUM_REGS  7
+
+#define READ_MODE 0x80
+
+/*
+ * write to a secondary register on the PASIC3
+ */
+void pasic3_write_register(struct device *dev, u32 reg, u8 val)
+{
+        struct pasic3_data *asic = dev->driver_data;
+        int bus_shift = asic->bus_shift;
+        void __iomem *addr = asic->mapping + (REG_ADDR << bus_shift);
+        void __iomem *data = asic->mapping + (REG_DATA << bus_shift);
+
+        __raw_writeb(~READ_MODE & reg, addr);
+        __raw_writeb(val, data);
+}
+EXPORT_SYMBOL(pasic3_write_register); /* for leds-pasic3 */
+
+/*
+ * read from a secondary register on the PASIC3
+ */
+u8 pasic3_read_register(struct device *dev, u32 reg)
+{
+        struct pasic3_data *asic = dev->driver_data;
+        int bus_shift = asic->bus_shift;
+        void __iomem *addr = asic->mapping + (REG_ADDR << bus_shift);
+        void __iomem *data = asic->mapping + (REG_DATA << bus_shift);
+
+        __raw_writeb(READ_MODE | reg, addr);
+        return __raw_readb(data);
+}
+EXPORT_SYMBOL(pasic3_read_register); /* for leds-pasic3 */
+
+/*
+ * LEDs
+ */
+
+static int led_device_add(struct device *pasic3_dev,
+                                const struct pasic3_leds_machinfo *pdata)
+{
+        struct pasic3_data *asic = pasic3_dev->driver_data;
+        struct platform_device *pdev;
+        int ret;
+
+        pdev = platform_device_alloc("pasic3-led", -1);
+        if (!pdev) {
+                dev_dbg(pasic3_dev, "failed to allocate LED platform device\n");
+                return -ENOMEM;
+        }
+
+        ret = platform_device_add_data(pdev, pdata,
+                                        sizeof(struct pasic3_leds_machinfo));
+        if (ret < 0) {
+                dev_dbg(pasic3_dev, "failed to add LED platform data\n");
+                goto exit_pdev_put;
+        }
+
+        pdev->dev.parent = pasic3_dev;
+        ret = platform_device_add(pdev);
+        if (ret < 0) {
+                dev_dbg(pasic3_dev, "failed to add LED platform device\n");
+                goto exit_pdev_put;
+        }
+
+        asic->led_pdev = pdev;
+        return 0;
+
+exit_pdev_put:
+        platform_device_put(pdev);
+        return ret;
+}
+
+/*
+ * DS1WM
+ */
+
+static void ds1wm_enable(struct platform_device *pdev)
+{
+        struct device *dev = pdev->dev.parent;
+        int c;
+
+        c = pasic3_read_register(dev, 0x28);
+        pasic3_write_register(dev, 0x28, c & 0x7f);
+
+        dev_dbg(dev, "DS1WM OWM_EN low (active) %02x\n", c & 0x7f);
+}
+
+static void ds1wm_disable(struct platform_device *pdev)
+{
+        struct device *dev = pdev->dev.parent;
+        int c;
+
+        c = pasic3_read_register(dev, 0x28);
+        pasic3_write_register(dev, 0x28, c | 0x80);
+
+        dev_dbg(dev, "DS1WM OWM_EN high (inactive) %02x\n", c | 0x80);
+}
+
+static struct ds1wm_platform_data ds1wm_pdata = {
+        .bus_shift = 2,
+        .enable    = ds1wm_enable,
+        .disable   = ds1wm_disable,
+};
+
+static int ds1wm_device_add(struct device *pasic3_dev, int bus_shift)
+{
+        struct pasic3_data *asic = pasic3_dev->driver_data;
+        struct platform_device *pdev;
+        int ret;
+
+        pdev = platform_device_alloc("ds1wm", -1);
+        if (!pdev) {
+                dev_dbg(pasic3_dev, "failed to allocate DS1WM platform device\n");
+                return -ENOMEM;
+        }
+
+        ret = platform_device_add_resources(pdev, pdev->resource,
+                                                pdev->num_resources);
+        if (ret < 0) {
+                dev_dbg(pasic3_dev, "failed to add DS1WM resources\n");
+                goto exit_pdev_put;
+        }
+
+        ds1wm_pdata.bus_shift = asic->bus_shift;
+        ret = platform_device_add_data(pdev, &ds1wm_pdata,
+                                        sizeof(struct ds1wm_platform_data));
+        if (ret < 0) {
+                dev_dbg(pasic3_dev, "failed to add DS1WM platform data\n");
+                goto exit_pdev_put;
+        }
+
+        pdev->dev.parent = pasic3_dev;
+        ret = platform_device_add(pdev);
+        if (ret < 0) {
+                dev_dbg(pasic3_dev, "failed to add DS1WM platform device\n");
+                goto exit_pdev_put;
+        }
+
+        asic->ds1wm_pdev = pdev;
+        return 0;
+
+exit_pdev_put:
+        platform_device_put(pdev);
+        return ret;
+}
+
+static int __init pasic3_probe(struct platform_device *pdev)
+{
+        struct pasic3_platform_data *pdata = pdev->dev.platform_data;
+        struct device *dev = &pdev->dev;
+        struct pasic3_data *asic;
+        struct resource *r;
+        int ret;
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!r)
+                return -ENXIO;
+
+        if (!request_mem_region(r->start, r->end - r->start + 1, "pasic3"))
+                return -EBUSY;
+
+        asic = kzalloc(sizeof(struct pasic3_data), GFP_KERNEL);
+        if (!asic)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, asic);
+
+        if (pdata && pdata->bus_shift)
+                asic->bus_shift = pdata->bus_shift;
+        else
+                asic->bus_shift = 2;
+
+        asic->mapping = ioremap(r->start, r->end - r->start + 1);
+        if (!asic->mapping) {
+                dev_err(dev, "couldn't ioremap PASIC3\n");
+                kfree(asic);
+                return -ENOMEM;
+        }
+
+        ret = ds1wm_device_add(dev, asic->bus_shift);
+        if (ret < 0)
+                dev_warn(dev, "failed to register DS1WM\n");
+
+        if (pdata->led_pdata) {
+                ret = led_device_add(dev, pdata->led_pdata);
+                if (ret < 0)
+                        dev_warn(dev, "failed to register LED device\n");
+        }
+
+        return 0;
+}
+
+static int pasic3_remove(struct platform_device *pdev)
+{
+        struct pasic3_data *asic = platform_get_drvdata(pdev);
+        struct resource *r;
+
+        if (asic->led_pdev)
+                platform_device_unregister(asic->led_pdev);
+        if (asic->ds1wm_pdev)
+                platform_device_unregister(asic->ds1wm_pdev);
+
+        iounmap(asic->mapping);
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(r->start, r->end - r->start + 1);
+        kfree(asic);
+        return 0;
+}
+
+static struct platform_driver pasic3_driver = {
+        .driver         = {
+                .name   = "pasic3",
+        },
+        .remove         = pasic3_remove,
+};
+
+static int __init pasic3_base_init(void)
+{
+        return platform_driver_probe(&pasic3_driver, pasic3_probe);
+}
+
+static void __exit pasic3_base_exit(void)
+{
+        platform_driver_unregister(&pasic3_driver);
+}
+
+module_init(pasic3_base_init);
+module_exit(pasic3_base_exit);
+
+MODULE_AUTHOR("Philipp Zabel <philipp.zabel@gmail.com>");
+MODULE_DESCRIPTION("Core driver for HTC PASIC3");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/ucb1x00-ts.c b/drivers/mfd/ucb1x00-ts.c
index fdbaa776f249..5e859486eaf8 100644
--- a/drivers/mfd/ucb1x00-ts.c
+++ b/drivers/mfd/ucb1x00-ts.c
@@ -32,7 +32,6 @@
 #include <linux/kthread.h>
 
 #include <asm/dma.h>
-#include <asm/semaphore.h>
 #include <asm/arch/collie.h>
 #include <asm/mach-types.h>
 
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 962817e49fba..bb94ce78a6d0 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -22,6 +22,39 @@ config ATMEL_PWM
           purposes including software controlled power-efficent backlights
           on LCD displays, motor control, and waveform generation.
 
+config ATMEL_TCLIB
+        bool "Atmel AT32/AT91 Timer/Counter Library"
+        depends on (AVR32 || ARCH_AT91)
+        help
+          Select this if you want a library to allocate the Timer/Counter
+          blocks found on many Atmel processors.  This facilitates using
+          these blocks by different drivers despite processor differences.
+
+config ATMEL_TCB_CLKSRC
+        bool "TC Block Clocksource"
+        depends on ATMEL_TCLIB && GENERIC_TIME
+        default y
+        help
+          Select this to get a high precision clocksource based on a
+          TC block with a 5+ MHz base clock rate.  Two timer channels
+          are combined to make a single 32-bit timer.
+
+          When GENERIC_CLOCKEVENTS is defined, the third timer channel
+          may be used as a clock event device supporting oneshot mode
+          (delays of up to two seconds) based on the 32 KiHz clock.
+
+config ATMEL_TCB_CLKSRC_BLOCK
+        int
+        depends on ATMEL_TCB_CLKSRC
+        prompt "TC Block" if ARCH_AT91RM9200 || ARCH_AT91SAM9260 || CPU_AT32AP700X
+        default 0
+        range 0 1
+        help
+          Some chips provide more than one TC block, so you have the
+          choice of which one to use for the clock framework.  The other
+          TC can be used for other purposes, such as PWM generation and
+          interval timing.
+
 config IBM_ASM
         tristate "Device driver for IBM RSA service processor"
         depends on X86 && PCI && INPUT && EXPERIMENTAL
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index bbc69fdd1b9d..4581b2533111 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_ACER_WMI)     += acer-wmi.o
 obj-$(CONFIG_ASUS_LAPTOP)     += asus-laptop.o
 obj-$(CONFIG_ATMEL_PWM)         += atmel_pwm.o
 obj-$(CONFIG_ATMEL_SSC)         += atmel-ssc.o
+obj-$(CONFIG_ATMEL_TCLIB)       += atmel_tclib.o
 obj-$(CONFIG_TC1100_WMI)        += tc1100-wmi.o
 obj-$(CONFIG_LKDTM)             += lkdtm.o
 obj-$(CONFIG_TIFM_CORE)         += tifm_core.o
diff --git a/drivers/misc/atmel_tclib.c b/drivers/misc/atmel_tclib.c
new file mode 100644
index 000000000000..05dc8a31f280
--- /dev/null
+++ b/drivers/misc/atmel_tclib.c
@@ -0,0 +1,161 @@
+#include <linux/atmel_tc.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+
+/* Number of bytes to reserve for the iomem resource */
+#define ATMEL_TC_IOMEM_SIZE     256
+
+
+/*
+ * This is a thin library to solve the problem of how to portably allocate
+ * one of the TC blocks.  For simplicity, it doesn't currently expect to
+ * share individual timers between different drivers.
+ */
+
+#if defined(CONFIG_AVR32)
+/* AVR32 has these divide PBB */
+const u8 atmel_tc_divisors[5] = { 0, 4, 8, 16, 32, };
+EXPORT_SYMBOL(atmel_tc_divisors);
+
+#elif defined(CONFIG_ARCH_AT91)
+/* AT91 has these divide MCK */
+const u8 atmel_tc_divisors[5] = { 2, 8, 32, 128, 0, };
+EXPORT_SYMBOL(atmel_tc_divisors);
+
+#endif
+
+static DEFINE_SPINLOCK(tc_list_lock);
+static LIST_HEAD(tc_list);
+
+/**
+ * atmel_tc_alloc - allocate a specified TC block
+ * @block: which block to allocate
+ * @name: name to be associated with the iomem resource
+ *
+ * Caller allocates a block.  If it is available, a pointer to a
+ * pre-initialized struct atmel_tc is returned. The caller can access
+ * the registers directly through the "regs" field.
+ */
+struct atmel_tc *atmel_tc_alloc(unsigned block, const char *name)
+{
+        struct atmel_tc         *tc;
+        struct platform_device  *pdev = NULL;
+        struct resource         *r;
+
+        spin_lock(&tc_list_lock);
+        list_for_each_entry(tc, &tc_list, node) {
+                if (tc->pdev->id == block) {
+                        pdev = tc->pdev;
+                        break;
+                }
+        }
+
+        if (!pdev || tc->iomem)
+                goto fail;
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        r = request_mem_region(r->start, ATMEL_TC_IOMEM_SIZE, name);
+        if (!r)
+                goto fail;
+
+        tc->regs = ioremap(r->start, ATMEL_TC_IOMEM_SIZE);
+        if (!tc->regs)
+                goto fail_ioremap;
+
+        tc->iomem = r;
+
+out:
+        spin_unlock(&tc_list_lock);
+        return tc;
+
+fail_ioremap:
+        release_resource(r);
+fail:
+        tc = NULL;
+        goto out;
+}
+EXPORT_SYMBOL_GPL(atmel_tc_alloc);
+
+/**
+ * atmel_tc_free - release a specified TC block
+ * @tc: Timer/counter block that was returned by atmel_tc_alloc()
+ *
+ * This reverses the effect of atmel_tc_alloc(), unmapping the I/O
+ * registers, invalidating the resource returned by that routine and
+ * making the TC available to other drivers.
+ */
+void atmel_tc_free(struct atmel_tc *tc)
+{
+        spin_lock(&tc_list_lock);
+        if (tc->regs) {
+                iounmap(tc->regs);
+                release_resource(tc->iomem);
+                tc->regs = NULL;
+                tc->iomem = NULL;
+        }
+        spin_unlock(&tc_list_lock);
+}
+EXPORT_SYMBOL_GPL(atmel_tc_free);
+
+static int __init tc_probe(struct platform_device *pdev)
+{
+        struct atmel_tc *tc;
+        struct clk      *clk;
+        int             irq;
+
+        if (!platform_get_resource(pdev, IORESOURCE_MEM, 0))
+                return -EINVAL;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return -EINVAL;
+
+        tc = kzalloc(sizeof(struct atmel_tc), GFP_KERNEL);
+        if (!tc)
+                return -ENOMEM;
+
+        tc->pdev = pdev;
+
+        clk = clk_get(&pdev->dev, "t0_clk");
+        if (IS_ERR(clk)) {
+                kfree(tc);
+                return -EINVAL;
+        }
+
+        tc->clk[0] = clk;
+        tc->clk[1] = clk_get(&pdev->dev, "t1_clk");
+        if (IS_ERR(tc->clk[1]))
+                tc->clk[1] = clk;
+        tc->clk[2] = clk_get(&pdev->dev, "t2_clk");
+        if (IS_ERR(tc->clk[2]))
+                tc->clk[2] = clk;
+
+        tc->irq[0] = irq;
+        tc->irq[1] = platform_get_irq(pdev, 1);
+        if (tc->irq[1] < 0)
+                tc->irq[1] = irq;
+        tc->irq[2] = platform_get_irq(pdev, 2);
+        if (tc->irq[2] < 0)
+                tc->irq[2] = irq;
+
+        spin_lock(&tc_list_lock);
+        list_add_tail(&tc->node, &tc_list);
+        spin_unlock(&tc_list_lock);
+
+        return 0;
+}
+
+static struct platform_driver tc_driver = {
+        .driver.name    = "atmel_tcb",
+};
+
+static int __init tc_init(void)
+{
+        return platform_driver_probe(&tc_driver, tc_probe);
+}
+arch_initcall(tc_init);
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index 4a3c6759492b..959fb86cda01 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -314,7 +314,7 @@ config MTD_ALAUDA
 
 config MTD_NAND_ORION
         tristate "NAND Flash support for Marvell Orion SoC"
-        depends on ARCH_ORION && MTD_NAND
+        depends on PLAT_ORION && MTD_NAND
         help
           This enables the NAND flash controller on Orion machines.
 
diff --git a/drivers/mtd/nand/orion_nand.c b/drivers/mtd/nand/orion_nand.c
index 9162cca0182b..ec5ad28b237e 100644
--- a/drivers/mtd/nand/orion_nand.c
+++ b/drivers/mtd/nand/orion_nand.c
@@ -18,8 +18,8 @@
 #include <linux/mtd/partitions.h>
 #include <asm/io.h>
 #include <asm/sizes.h>
-#include <asm/arch/platform.h>
 #include <asm/arch/hardware.h>
+#include <asm/plat-orion/orion_nand.h>
 
 #ifdef CONFIG_MTD_CMDLINE_PARTS
 static const char *part_probes[] = { "cmdlinepart", NULL };
diff --git a/drivers/net/3c527.c b/drivers/net/3c527.c
index b72b89d53ec8..fae295b6809c 100644
--- a/drivers/net/3c527.c
+++ b/drivers/net/3c527.c
@@ -103,8 +103,8 @@ DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " Richard Procter <rnp@paradise.net.
 #include <linux/ethtool.h>
 #include <linux/completion.h>
 #include <linux/bitops.h>
+#include <linux/semaphore.h>
 
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/io.h>
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 45c3a208d93f..2399a3796f6e 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2335,7 +2335,7 @@ config UGETH_TX_ON_DEMAND
 
 config MV643XX_ETH
         tristate "Marvell Discovery (643XX) and Orion ethernet support"
-        depends on MV64360 || MV64X60 || (PPC_MULTIPLATFORM && PPC32) || ARCH_ORION
+        depends on MV64360 || MV64X60 || (PPC_MULTIPLATFORM && PPC32) || PLAT_ORION
         select MII
         help
           This driver supports the gigabit ethernet MACs in the
diff --git a/drivers/net/appletalk/cops.c b/drivers/net/appletalk/cops.c
index 65b901ebfd62..82e9a5bd0dd2 100644
--- a/drivers/net/appletalk/cops.c
+++ b/drivers/net/appletalk/cops.c
@@ -69,6 +69,7 @@ static const char *version =
 #include <linux/atalk.h>
 #include <linux/spinlock.h>
 #include <linux/bitops.h>
+#include <linux/jiffies.h>
 
 #include <asm/system.h>
 #include <asm/io.h>
@@ -503,7 +504,7 @@ static void cops_reset(struct net_device *dev, int sleep)
                         long snap=jiffies;
 
                         /* Let card finish initializing, about 1/3 second */
-                        while(jiffies-snap<HZ/3)
+                        while (time_before(jiffies, snap + HZ/3))
                                 schedule();
                 }
                 else
diff --git a/drivers/net/arm/at91_ether.c b/drivers/net/arm/at91_ether.c
index 0ae0d83e5d22..978e20a1791b 100644
--- a/drivers/net/arm/at91_ether.c
+++ b/drivers/net/arm/at91_ether.c
@@ -1043,7 +1043,9 @@ static int __init at91ether_setup(unsigned long phy_type, unsigned short phy_add
         } else if (machine_is_csb337()) {
                 /* mix link activity status into LED2 link state */
                 write_phy(phy_address, MII_LEDCTRL_REG, 0x0d22);
-        }
+        } else if (machine_is_ecbat91())
+                write_phy(phy_address, MII_LEDCTRL_REG, 0x156A);
+
         disable_mdi();
         spin_unlock_irq(&lp->lock);
 
diff --git a/drivers/net/cxgb3/adapter.h b/drivers/net/cxgb3/adapter.h
index eb305a0895fc..4fdb13f8447b 100644
--- a/drivers/net/cxgb3/adapter.h
+++ b/drivers/net/cxgb3/adapter.h
@@ -43,7 +43,6 @@
 #include <linux/mutex.h>
 #include <linux/bitops.h>
 #include "t3cdev.h"
-#include <asm/semaphore.h>
 #include <asm/io.h>
 
 struct vlan_group;
diff --git a/drivers/net/cxgb3/t3cdev.h b/drivers/net/cxgb3/t3cdev.h
index 77fcc1a4984e..a18c8a140424 100644
--- a/drivers/net/cxgb3/t3cdev.h
+++ b/drivers/net/cxgb3/t3cdev.h
@@ -34,7 +34,6 @@
 
 #include <linux/list.h>
 #include <asm/atomic.h>
-#include <asm/semaphore.h>
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/skbuff.h>
diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 0a9b75139e0f..1da55dd2a5a0 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -33,7 +33,7 @@
 #include <linux/init.h>
 #include <linux/ip.h>
 #include <linux/tcp.h>
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 #include <asm/atomic.h>
 
 #define SIXPACK_VERSION    "Revision: 0.3.0"
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index bb31e09899fc..ce4fc2ec2fe4 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -49,7 +49,6 @@
 #include <linux/in.h>
 #include <linux/ip.h>
 #include <net/net_namespace.h>
-#include <asm/semaphore.h>
 #include <asm/hvcall.h>
 #include <asm/atomic.h>
 #include <asm/vio.h>
diff --git a/drivers/net/irda/pxaficp_ir.c b/drivers/net/irda/pxaficp_ir.c
index 8c09344f58dc..8db71ab20456 100644
--- a/drivers/net/irda/pxaficp_ir.c
+++ b/drivers/net/irda/pxaficp_ir.c
@@ -36,6 +36,7 @@
 #include <asm/hardware.h>
 #include <asm/arch/irda.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-gpio.h>
 
 #ifdef CONFIG_MACH_MAINSTONE
 #include <asm/arch/mainstone.h>
@@ -831,6 +832,11 @@ static int pxa_irda_probe(struct platform_device *pdev)
         if (err)
                 goto err_mem_5;
 
+        if (si->pdata->startup)
+                err = si->pdata->startup(si->dev);
+        if (err)
+                goto err_startup;
+
         dev->hard_start_xmit    = pxa_irda_hard_xmit;
         dev->open               = pxa_irda_start;
         dev->stop               = pxa_irda_stop;
@@ -856,6 +862,9 @@ static int pxa_irda_probe(struct platform_device *pdev)
                 dev_set_drvdata(&pdev->dev, dev);
 
         if (err) {
+                if (si->pdata->shutdown)
+                        si->pdata->shutdown(si->dev);
+err_startup:
                 kfree(si->tx_buff.head);
 err_mem_5:
                 kfree(si->rx_buff.head);
@@ -881,6 +890,8 @@ static int pxa_irda_remove(struct platform_device *_dev)
         if (dev) {
                 struct pxa_irda *si = netdev_priv(dev);
                 unregister_netdev(dev);
+                if (si->pdata->shutdown)
+                        si->pdata->shutdown(si->dev);
                 kfree(si->tx_buff.head);
                 kfree(si->rx_buff.head);
                 clk_put(si->fir_clk);
diff --git a/drivers/net/netxen/netxen_nic_hdr.h b/drivers/net/netxen/netxen_nic_hdr.h
index 160f605e58db..24d027e29c45 100644
--- a/drivers/net/netxen/netxen_nic_hdr.h
+++ b/drivers/net/netxen/netxen_nic_hdr.h
@@ -34,7 +34,6 @@
 #include <linux/kernel.h>
 #include <linux/version.h>
 
-#include <asm/semaphore.h>
 #include <linux/spinlock.h>
 #include <asm/irq.h>
 #include <linux/init.h>
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 96043c5746d0..bc4c62b8e81a 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -64,8 +64,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.90"
-#define DRV_MODULE_RELDATE      "April 12, 2008"
+#define DRV_MODULE_VERSION      "3.91"
+#define DRV_MODULE_RELDATE      "April 18, 2008"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -4135,11 +4135,21 @@ static int tigon3_dma_hwbug_workaround(struct tg3 *tp, struct sk_buff *skb,
                                        u32 last_plus_one, u32 *start,
                                        u32 base_flags, u32 mss)
 {
-        struct sk_buff *new_skb = skb_copy(skb, GFP_ATOMIC);
+        struct sk_buff *new_skb;
         dma_addr_t new_addr = 0;
         u32 entry = *start;
         int i, ret = 0;
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701)
+                new_skb = skb_copy(skb, GFP_ATOMIC);
+        else {
+                int more_headroom = 4 - ((unsigned long)skb->data & 3);
+
+                new_skb = skb_copy_expand(skb,
+                                          skb_headroom(skb) + more_headroom,
+                                          skb_tailroom(skb), GFP_ATOMIC);
+        }
+
         if (!new_skb) {
                 ret = -1;
         } else {
@@ -4462,7 +4472,9 @@ static int tg3_start_xmit_dma_bug(struct sk_buff *skb, struct net_device *dev)
 
         would_hit_hwbug = 0;
 
-        if (tg3_4g_overflow_test(mapping, len))
+        if (tp->tg3_flags3 & TG3_FLG3_5701_DMA_BUG)
+                would_hit_hwbug = 1;
+        else if (tg3_4g_overflow_test(mapping, len))
                 would_hit_hwbug = 1;
 
         tg3_set_txd(tp, entry, mapping, len, base_flags,
@@ -11339,6 +11351,38 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                 }
         }
 
+        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)) {
+                static struct tg3_dev_id {
+                        u32     vendor;
+                        u32     device;
+                } bridge_chipsets[] = {
+                        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PXH_0 },
+                        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_PXH_1 },
+                        { },
+                };
+                struct tg3_dev_id *pci_id = &bridge_chipsets[0];
+                struct pci_dev *bridge = NULL;
+
+                while (pci_id->vendor != 0) {
+                        bridge = pci_get_device(pci_id->vendor,
+                                                pci_id->device,
+                                                bridge);
+                        if (!bridge) {
+                                pci_id++;
+                                continue;
+                        }
+                        if (bridge->subordinate &&
+                            (bridge->subordinate->number <=
+                             tp->pdev->bus->number) &&
+                            (bridge->subordinate->subordinate >=
+                             tp->pdev->bus->number)) {
+                                tp->tg3_flags3 |= TG3_FLG3_5701_DMA_BUG;
+                                pci_dev_put(bridge);
+                                break;
+                        }
+                }
+        }
+
         /* The EPB bridge inside 5714, 5715, and 5780 cannot support
          * DMA addresses > 40-bit. This bridge may have other additional
          * 57xx devices behind it in some 4-port NIC designs for example.
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index c1075a73d66c..c688c3ac5035 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -2476,6 +2476,7 @@ struct tg3 {
 #define TG3_FLG3_NO_NVRAM_ADDR_TRANS    0x00000001
 #define TG3_FLG3_ENABLE_APE             0x00000002
 #define TG3_FLG3_5761_5784_AX_FIXES     0x00000004
+#define TG3_FLG3_5701_DMA_BUG           0x00000008
 
         struct timer_list               timer;
         u16                             timer_counter;
diff --git a/drivers/net/usb/kaweth.c b/drivers/net/usb/kaweth.c
index 569ad8bfd383..0dcfc0310264 100644
--- a/drivers/net/usb/kaweth.c
+++ b/drivers/net/usb/kaweth.c
@@ -58,7 +58,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/wait.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 #include <asm/byteorder.h>
 
 #undef DEBUG
diff --git a/drivers/net/wireless/iwlwifi/iwl-debugfs.c b/drivers/net/wireless/iwlwifi/iwl-debugfs.c
index 0f16f2606f29..9a30e1df311d 100644
--- a/drivers/net/wireless/iwlwifi/iwl-debugfs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-debugfs.c
@@ -239,28 +239,34 @@ static ssize_t iwl_dbgfs_stations_read(struct file *file, char __user *user_buf,
                                         "ps_status: %u\n", station->ps_status);
                         pos += scnprintf(buf + pos, bufsz - pos, "tid data:\n");
                         pos += scnprintf(buf + pos, bufsz - pos,
-                                        "seq_num\t\ttxq_id\t");
+                                        "seq_num\t\ttxq_id");
+#ifdef CONFIG_IWL4965_HT
                         pos += scnprintf(buf + pos, bufsz - pos,
-                                        "frame_count\twait_for_ba\t");
+                                        "\tframe_count\twait_for_ba\t");
                         pos += scnprintf(buf + pos, bufsz - pos,
                                         "start_idx\tbitmap0\t");
                         pos += scnprintf(buf + pos, bufsz - pos,
-                                        "bitmap1\trate_n_flags\n");
+                                        "bitmap1\trate_n_flags");
+#endif
+                        pos += scnprintf(buf + pos, bufsz - pos, "\n");
 
                         for (j = 0; j < MAX_TID_COUNT; j++) {
                                 pos += scnprintf(buf + pos, bufsz - pos,
-                                                "[%d]:\t\t%u\t", j,
+                                                "[%d]:\t\t%u", j,
                                                 station->tid[j].seq_number);
+#ifdef CONFIG_IWL4965_HT
                                 pos += scnprintf(buf + pos, bufsz - pos,
-                                                "%u\t\t%u\t\t%u\t\t",
+                                                "\t%u\t\t%u\t\t%u\t\t",
                                                 station->tid[j].agg.txq_id,
                                                 station->tid[j].agg.frame_count,
                                                 station->tid[j].agg.wait_for_ba);
                                 pos += scnprintf(buf + pos, bufsz - pos,
-                                                "%u\t%llu\t%u\n",
+                                                "%u\t%llu\t%u",
                                                 station->tid[j].agg.start_idx,
                                                 (unsigned long long)station->tid[j].agg.bitmap,
                                                 station->tid[j].agg.rate_n_flags);
+#endif
+                                pos += scnprintf(buf + pos, bufsz - pos, "\n");
                         }
                         pos += scnprintf(buf + pos, bufsz - pos, "\n");
                 }
diff --git a/drivers/parport/Kconfig b/drivers/parport/Kconfig
index b7bcdcc5c724..209b4a464bcf 100644
--- a/drivers/parport/Kconfig
+++ b/drivers/parport/Kconfig
@@ -36,7 +36,7 @@ if PARPORT
 config PARPORT_PC
         tristate "PC-style hardware"
         depends on (!SPARC64 || PCI) && !SPARC32 && !M32R && !FRV && \
-                (!M68K || ISA) && !MN10300
+                (!M68K || ISA) && !MN10300 && !AVR32
         ---help---
           You should say Y here if you have a PC-style parallel port. All
           IBM PC compatible computers and some Alphas have PC-style
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index e571c72e6753..e8d94fafc280 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -182,15 +182,18 @@ static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
         struct mempolicy *oldpol;
         cpumask_t oldmask = current->cpus_allowed;
         int node = pcibus_to_node(dev->bus);
-        if (node >= 0 && node_online(node))
-            set_cpus_allowed(current, node_to_cpumask(node));
+
+        if (node >= 0) {
+                node_to_cpumask_ptr(nodecpumask, node);
+                set_cpus_allowed_ptr(current, nodecpumask);
+        }
         /* And set default memory allocation policy */
         oldpol = current->mempolicy;
         current->mempolicy = NULL;      /* fall back to system default policy */
 #endif
         error = drv->probe(dev, id);
 #ifdef CONFIG_NUMA
-        set_cpus_allowed(current, oldmask);
+        set_cpus_allowed_ptr(current, &oldmask);
         current->mempolicy = oldpol;
 #endif
         return error;
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 8dcf1458aa2f..8d9d648daeba 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -73,8 +73,23 @@ static ssize_t local_cpus_show(struct device *dev,
 
         mask = pcibus_to_cpumask(to_pci_dev(dev)->bus);
         len = cpumask_scnprintf(buf, PAGE_SIZE-2, mask);
-        strcat(buf,"\n"); 
-        return 1+len;
+        buf[len++] = '\n';
+        buf[len] = '\0';
+        return len;
+}
+
+
+static ssize_t local_cpulist_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        cpumask_t mask;
+        int len;
+
+        mask = pcibus_to_cpumask(to_pci_dev(dev)->bus);
+        len = cpulist_scnprintf(buf, PAGE_SIZE-2, mask);
+        buf[len++] = '\n';
+        buf[len] = '\0';
+        return len;
 }
 
 /* show resources */
@@ -201,6 +216,7 @@ struct device_attribute pci_dev_attrs[] = {
         __ATTR_RO(class),
         __ATTR_RO(irq),
         __ATTR_RO(local_cpus),
+        __ATTR_RO(local_cpulist),
         __ATTR_RO(modalias),
 #ifdef CONFIG_NUMA
         __ATTR_RO(numa_node),
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 2db2e4bb0d1e..4b3011a23eff 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -82,6 +82,7 @@ void pci_remove_legacy_files(struct pci_bus *bus) { return; }
  * PCI Bus Class Devices
  */
 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
+                                        int type,
                                         struct device_attribute *attr,
                                         char *buf)
 {
@@ -89,12 +90,30 @@ static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
         cpumask_t cpumask;
 
         cpumask = pcibus_to_cpumask(to_pci_bus(dev));
-        ret = cpumask_scnprintf(buf, PAGE_SIZE, cpumask);
-        if (ret < PAGE_SIZE)
-                buf[ret++] = '\n';
+        ret = type?
+                cpulist_scnprintf(buf, PAGE_SIZE-2, cpumask):
+                cpumask_scnprintf(buf, PAGE_SIZE-2, cpumask);
+        buf[ret++] = '\n';
+        buf[ret] = '\0';
         return ret;
 }
-DEVICE_ATTR(cpuaffinity, S_IRUGO, pci_bus_show_cpuaffinity, NULL);
+
+static ssize_t inline pci_bus_show_cpumaskaffinity(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+        return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
+}
+
+static ssize_t inline pci_bus_show_cpulistaffinity(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+        return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
+}
+
+DEVICE_ATTR(cpuaffinity,     S_IRUGO, pci_bus_show_cpumaskaffinity, NULL);
+DEVICE_ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL);
 
 /*
  * PCI Bus Class
diff --git a/drivers/pcmcia/Kconfig b/drivers/pcmcia/Kconfig
index 8b22281b087f..ed8c06904807 100644
--- a/drivers/pcmcia/Kconfig
+++ b/drivers/pcmcia/Kconfig
@@ -200,6 +200,7 @@ config PCMCIA_AU1X00
 config PCMCIA_SA1100
         tristate "SA1100 support"
         depends on ARM && ARCH_SA1100 && PCMCIA
+        depends on ARCH_LUBBOCK || MACH_MAINSTONE || PXA_SHARPSL || MACH_ARMCORE
         help
           Say Y here to include support for SA11x0-based PCMCIA or CF
           sockets, found on HP iPAQs, Yopy, and other StrongARM(R)/
diff --git a/drivers/pcmcia/pxa2xx_cm_x270.c b/drivers/pcmcia/pxa2xx_cm_x270.c
index fbf2f3a6984c..e7ab060ff118 100644
--- a/drivers/pcmcia/pxa2xx_cm_x270.c
+++ b/drivers/pcmcia/pxa2xx_cm_x270.c
@@ -20,6 +20,7 @@
 #include <asm/hardware.h>
 
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-gpio.h>
 #include <asm/arch/cm-x270.h>
 
 #include "soc_common.h"
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index 9e9caa5d7f5f..c594b34c6767 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -1,8 +1,9 @@
 /*
  * SuperH On-Chip RTC Support
  *
- * Copyright (C) 2006, 2007  Paul Mundt
+ * Copyright (C) 2006, 2007, 2008  Paul Mundt
  * Copyright (C) 2006  Jamie Lenehan
+ * Copyright (C) 2008  Angelo Castello
  *
  * Based on the old arch/sh/kernel/cpu/rtc.c by:
  *
@@ -26,7 +27,7 @@
 #include <asm/rtc.h>
 
 #define DRV_NAME        "sh-rtc"
-#define DRV_VERSION     "0.1.6"
+#define DRV_VERSION     "0.2.0"
 
 #define RTC_REG(r)      ((r) * rtc_reg_size)
 
@@ -63,6 +64,13 @@
 /* ALARM Bits - or with BCD encoded value */
 #define AR_ENB          0x80    /* Enable for alarm cmp   */
 
+/* Period Bits */
+#define PF_HP           0x100   /* Enable Half Period to support 8,32,128Hz */
+#define PF_COUNT        0x200   /* Half periodic counter */
+#define PF_OXS          0x400   /* Periodic One x Second */
+#define PF_KOU          0x800   /* Kernel or User periodic request 1=kernel */
+#define PF_MASK         0xf00
+
 /* RCR1 Bits */
 #define RCR1_CF         0x80    /* Carry Flag             */
 #define RCR1_CIE        0x10    /* Carry Interrupt Enable */
@@ -84,33 +92,24 @@ struct sh_rtc {
         unsigned int alarm_irq, periodic_irq, carry_irq;
         struct rtc_device *rtc_dev;
         spinlock_t lock;
-        int rearm_aie;
         unsigned long capabilities;     /* See asm-sh/rtc.h for cap bits */
+        unsigned short periodic_freq;
 };
 
 static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
 {
-        struct platform_device *pdev = to_platform_device(dev_id);
-        struct sh_rtc *rtc = platform_get_drvdata(pdev);
-        unsigned int tmp, events = 0;
+        struct sh_rtc *rtc = dev_id;
+        unsigned int tmp;
 
         spin_lock(&rtc->lock);
 
         tmp = readb(rtc->regbase + RCR1);
         tmp &= ~RCR1_CF;
-
-        if (rtc->rearm_aie) {
-                if (tmp & RCR1_AF)
-                        tmp &= ~RCR1_AF;        /* try to clear AF again */
-                else {
-                        tmp |= RCR1_AIE;        /* AF has cleared, rearm IRQ */
-                        rtc->rearm_aie = 0;
-                }
-        }
-
         writeb(tmp, rtc->regbase + RCR1);
 
-        rtc_update_irq(rtc->rtc_dev, 1, events);
+        /* Users have requested One x Second IRQ */
+        if (rtc->periodic_freq & PF_OXS)
+                rtc_update_irq(rtc->rtc_dev, 1, RTC_UF | RTC_IRQF);
 
         spin_unlock(&rtc->lock);
 
@@ -119,47 +118,48 @@ static irqreturn_t sh_rtc_interrupt(int irq, void *dev_id)
 
 static irqreturn_t sh_rtc_alarm(int irq, void *dev_id)
 {
-        struct platform_device *pdev = to_platform_device(dev_id);
-        struct sh_rtc *rtc = platform_get_drvdata(pdev);
-        unsigned int tmp, events = 0;
+        struct sh_rtc *rtc = dev_id;
+        unsigned int tmp;
 
         spin_lock(&rtc->lock);
 
         tmp = readb(rtc->regbase + RCR1);
-
-        /*
-         * If AF is set then the alarm has triggered. If we clear AF while
-         * the alarm time still matches the RTC time then AF will
-         * immediately be set again, and if AIE is enabled then the alarm
-         * interrupt will immediately be retrigger. So we clear AIE here
-         * and use rtc->rearm_aie so that the carry interrupt will keep
-         * trying to clear AF and once it stays cleared it'll re-enable
-         * AIE.
-         */
-        if (tmp & RCR1_AF) {
-                events |= RTC_AF | RTC_IRQF;
-
-                tmp &= ~(RCR1_AF|RCR1_AIE);
-
+        tmp &= ~(RCR1_AF | RCR1_AIE);
                 writeb(tmp, rtc->regbase + RCR1);
 
-                rtc->rearm_aie = 1;
-
-                rtc_update_irq(rtc->rtc_dev, 1, events);
-        }
+        rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
 
         spin_unlock(&rtc->lock);
+
         return IRQ_HANDLED;
 }
 
 static irqreturn_t sh_rtc_periodic(int irq, void *dev_id)
 {
-        struct platform_device *pdev = to_platform_device(dev_id);
-        struct sh_rtc *rtc = platform_get_drvdata(pdev);
+        struct sh_rtc *rtc = dev_id;
+        struct rtc_device *rtc_dev = rtc->rtc_dev;
+        unsigned int tmp;
 
         spin_lock(&rtc->lock);
 
-        rtc_update_irq(rtc->rtc_dev, 1, RTC_PF | RTC_IRQF);
+        tmp = readb(rtc->regbase + RCR2);
+        tmp &= ~RCR2_PEF;
+        writeb(tmp, rtc->regbase + RCR2);
+
+        /* Half period enabled than one skipped and the next notified */
+        if ((rtc->periodic_freq & PF_HP) && (rtc->periodic_freq & PF_COUNT))
+                rtc->periodic_freq &= ~PF_COUNT;
+        else {
+                if (rtc->periodic_freq & PF_HP)
+                        rtc->periodic_freq |= PF_COUNT;
+                if (rtc->periodic_freq & PF_KOU) {
+                        spin_lock(&rtc_dev->irq_task_lock);
+                        if (rtc_dev->irq_task)
+                                rtc_dev->irq_task->func(rtc_dev->irq_task->private_data);
+                        spin_unlock(&rtc_dev->irq_task_lock);
+                } else
+                        rtc_update_irq(rtc->rtc_dev, 1, RTC_PF | RTC_IRQF);
+        }
 
         spin_unlock(&rtc->lock);
 
@@ -176,8 +176,8 @@ static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
         tmp = readb(rtc->regbase + RCR2);
 
         if (enable) {
-                tmp &= ~RCR2_PESMASK;
-                tmp |= RCR2_PEF | (2 << 4);
+                tmp &= ~RCR2_PEF;       /* Clear PES bit */
+                tmp |= (rtc->periodic_freq & ~PF_HP);   /* Set PES2-0 */
         } else
                 tmp &= ~(RCR2_PESMASK | RCR2_PEF);
 
@@ -186,82 +186,81 @@ static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
         spin_unlock_irq(&rtc->lock);
 }
 
-static inline void sh_rtc_setaie(struct device *dev, unsigned int enable)
+static inline int sh_rtc_setfreq(struct device *dev, unsigned int freq)
 {
         struct sh_rtc *rtc = dev_get_drvdata(dev);
-        unsigned int tmp;
+        int tmp, ret = 0;
 
         spin_lock_irq(&rtc->lock);
+        tmp = rtc->periodic_freq & PF_MASK;
 
-        tmp = readb(rtc->regbase + RCR1);
-
-        if (!enable) {
-                tmp &= ~RCR1_AIE;
-                rtc->rearm_aie = 0;
-        } else if (rtc->rearm_aie == 0)
-                tmp |= RCR1_AIE;
+        switch (freq) {
+        case 0:
+                rtc->periodic_freq = 0x00;
+                break;
+        case 1:
+                rtc->periodic_freq = 0x60;
+                break;
+        case 2:
+                rtc->periodic_freq = 0x50;
+                break;
+        case 4:
+                rtc->periodic_freq = 0x40;
+                break;
+        case 8:
+                rtc->periodic_freq = 0x30 | PF_HP;
+                break;
+        case 16:
+                rtc->periodic_freq = 0x30;
+                break;
+        case 32:
+                rtc->periodic_freq = 0x20 | PF_HP;
+                break;
+        case 64:
+                rtc->periodic_freq = 0x20;
+                break;
+        case 128:
+                rtc->periodic_freq = 0x10 | PF_HP;
+                break;
+        case 256:
+                rtc->periodic_freq = 0x10;
+                break;
+        default:
+                ret = -ENOTSUPP;
+        }
 
-        writeb(tmp, rtc->regbase + RCR1);
+        if (ret == 0) {
+                rtc->periodic_freq |= tmp;
+                rtc->rtc_dev->irq_freq = freq;
+        }
 
         spin_unlock_irq(&rtc->lock);
+        return ret;
 }
 
-static int sh_rtc_open(struct device *dev)
+static inline void sh_rtc_setaie(struct device *dev, unsigned int enable)
 {
         struct sh_rtc *rtc = dev_get_drvdata(dev);
         unsigned int tmp;
-        int ret;
-
-        tmp = readb(rtc->regbase + RCR1);
-        tmp &= ~RCR1_CF;
-        tmp |= RCR1_CIE;
-        writeb(tmp, rtc->regbase + RCR1);
 
-        ret = request_irq(rtc->periodic_irq, sh_rtc_periodic, IRQF_DISABLED,
-                          "sh-rtc period", dev);
-        if (unlikely(ret)) {
-                dev_err(dev, "request period IRQ failed with %d, IRQ %d\n",
-                        ret, rtc->periodic_irq);
-                return ret;
-        }
-
-        ret = request_irq(rtc->carry_irq, sh_rtc_interrupt, IRQF_DISABLED,
-                          "sh-rtc carry", dev);
-        if (unlikely(ret)) {
-                dev_err(dev, "request carry IRQ failed with %d, IRQ %d\n",
-                        ret, rtc->carry_irq);
-                free_irq(rtc->periodic_irq, dev);
-                goto err_bad_carry;
-        }
+        spin_lock_irq(&rtc->lock);
 
-        ret = request_irq(rtc->alarm_irq, sh_rtc_alarm, IRQF_DISABLED,
-                          "sh-rtc alarm", dev);
-        if (unlikely(ret)) {
-                dev_err(dev, "request alarm IRQ failed with %d, IRQ %d\n",
-                        ret, rtc->alarm_irq);
-                goto err_bad_alarm;
-        }
+        tmp = readb(rtc->regbase + RCR1);
 
-        return 0;
+        if (!enable)
+                tmp &= ~RCR1_AIE;
+        else
+                tmp |= RCR1_AIE;
 
-err_bad_alarm:
-        free_irq(rtc->carry_irq, dev);
-err_bad_carry:
-        free_irq(rtc->periodic_irq, dev);
+        writeb(tmp, rtc->regbase + RCR1);
 
-        return ret;
+        spin_unlock_irq(&rtc->lock);
 }
 
 static void sh_rtc_release(struct device *dev)
 {
-        struct sh_rtc *rtc = dev_get_drvdata(dev);
-
         sh_rtc_setpie(dev, 0);
         sh_rtc_setaie(dev, 0);
-
-        free_irq(rtc->periodic_irq, dev);
-        free_irq(rtc->carry_irq, dev);
-        free_irq(rtc->alarm_irq, dev);
 }
 
 static int sh_rtc_proc(struct device *dev, struct seq_file *seq)
@@ -270,31 +269,44 @@ static int sh_rtc_proc(struct device *dev, struct seq_file *seq)
         unsigned int tmp;
 
         tmp = readb(rtc->regbase + RCR1);
-        seq_printf(seq, "carry_IRQ\t: %s\n",
-                   (tmp & RCR1_CIE) ? "yes" : "no");
+        seq_printf(seq, "carry_IRQ\t: %s\n", (tmp & RCR1_CIE) ? "yes" : "no");
 
         tmp = readb(rtc->regbase + RCR2);
         seq_printf(seq, "periodic_IRQ\t: %s\n",
-                   (tmp & RCR2_PEF) ? "yes" : "no");
+                   (tmp & RCR2_PESMASK) ? "yes" : "no");
 
         return 0;
 }
 
 static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 {
-        unsigned int ret = -ENOIOCTLCMD;
+        struct sh_rtc *rtc = dev_get_drvdata(dev);
+        unsigned int ret = 0;
 
         switch (cmd) {
         case RTC_PIE_OFF:
         case RTC_PIE_ON:
                 sh_rtc_setpie(dev, cmd == RTC_PIE_ON);
-                ret = 0;
                 break;
         case RTC_AIE_OFF:
         case RTC_AIE_ON:
                 sh_rtc_setaie(dev, cmd == RTC_AIE_ON);
-                ret = 0;
                 break;
+        case RTC_UIE_OFF:
+                rtc->periodic_freq &= ~PF_OXS;
+                break;
+        case RTC_UIE_ON:
+                rtc->periodic_freq |= PF_OXS;
+                break;
+        case RTC_IRQP_READ:
+                ret = put_user(rtc->rtc_dev->irq_freq,
+                               (unsigned long __user *)arg);
+                break;
+        case RTC_IRQP_SET:
+                ret = sh_rtc_setfreq(dev, arg);
+                break;
+        default:
+                ret = -ENOIOCTLCMD;
         }
 
         return ret;
@@ -421,7 +433,7 @@ static int sh_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct sh_rtc *rtc = platform_get_drvdata(pdev);
-        struct rtc_time* tm = &wkalrm->time;
+        struct rtc_time *tm = &wkalrm->time;
 
         spin_lock_irq(&rtc->lock);
 
@@ -452,7 +464,7 @@ static inline void sh_rtc_write_alarm_value(struct sh_rtc *rtc,
                 writeb(BIN2BCD(value) | AR_ENB,  rtc->regbase + reg_off);
 }
 
-static int sh_rtc_check_alarm(struct rtc_time* tm)
+static int sh_rtc_check_alarm(struct rtc_time *tm)
 {
         /*
          * The original rtc says anything > 0xc0 is "don't care" or "match
@@ -503,11 +515,9 @@ static int sh_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
 
         /* disable alarm interrupt and clear the alarm flag */
         rcr1 = readb(rtc->regbase + RCR1);
-        rcr1 &= ~(RCR1_AF|RCR1_AIE);
+        rcr1 &= ~(RCR1_AF | RCR1_AIE);
         writeb(rcr1, rtc->regbase + RCR1);
 
-        rtc->rearm_aie = 0;
-
         /* set alarm time */
         sh_rtc_write_alarm_value(rtc, tm->tm_sec,  RSECAR);
         sh_rtc_write_alarm_value(rtc, tm->tm_min,  RMINAR);
@@ -529,14 +539,34 @@ static int sh_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
         return 0;
 }
 
+static int sh_rtc_irq_set_state(struct device *dev, int enabled)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_rtc *rtc = platform_get_drvdata(pdev);
+
+        if (enabled) {
+                rtc->periodic_freq |= PF_KOU;
+                return sh_rtc_ioctl(dev, RTC_PIE_ON, 0);
+        } else {
+                rtc->periodic_freq &= ~PF_KOU;
+                return sh_rtc_ioctl(dev, RTC_PIE_OFF, 0);
+        }
+}
+
+static int sh_rtc_irq_set_freq(struct device *dev, int freq)
+{
+        return sh_rtc_ioctl(dev, RTC_IRQP_SET, freq);
+}
+
 static struct rtc_class_ops sh_rtc_ops = {
-        .open           = sh_rtc_open,
         .release        = sh_rtc_release,
         .ioctl          = sh_rtc_ioctl,
         .read_time      = sh_rtc_read_time,
         .set_time       = sh_rtc_set_time,
         .read_alarm     = sh_rtc_read_alarm,
         .set_alarm      = sh_rtc_set_alarm,
+        .irq_set_state  = sh_rtc_irq_set_state,
+        .irq_set_freq   = sh_rtc_irq_set_freq,
         .proc           = sh_rtc_proc,
 };
 
@@ -544,6 +574,7 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
 {
         struct sh_rtc *rtc;
         struct resource *res;
+        unsigned int tmp;
         int ret = -ENOENT;
 
         rtc = kzalloc(sizeof(struct sh_rtc), GFP_KERNEL);
@@ -552,6 +583,7 @@ 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)) {
                 dev_err(&pdev->dev, "No IRQ for period\n");
@@ -608,8 +640,48 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
                 rtc->capabilities |= pinfo->capabilities;
         }
 
+        rtc->rtc_dev->max_user_freq = 256;
+        rtc->rtc_dev->irq_freq = 1;
+        rtc->periodic_freq = 0x60;
+
         platform_set_drvdata(pdev, rtc);
 
+        /* register periodic/carry/alarm irqs */
+        ret = request_irq(rtc->periodic_irq, sh_rtc_periodic, IRQF_DISABLED,
+                          "sh-rtc period", rtc);
+        if (unlikely(ret)) {
+                dev_err(&pdev->dev,
+                        "request period IRQ failed with %d, IRQ %d\n", ret,
+                        rtc->periodic_irq);
+                goto err_badmap;
+        }
+
+        ret = request_irq(rtc->carry_irq, sh_rtc_interrupt, IRQF_DISABLED,
+                          "sh-rtc carry", rtc);
+        if (unlikely(ret)) {
+                dev_err(&pdev->dev,
+                        "request carry IRQ failed with %d, IRQ %d\n", ret,
+                        rtc->carry_irq);
+                free_irq(rtc->periodic_irq, rtc);
+                goto err_badmap;
+        }
+
+        ret = request_irq(rtc->alarm_irq, sh_rtc_alarm, IRQF_DISABLED,
+                          "sh-rtc alarm", rtc);
+        if (unlikely(ret)) {
+                dev_err(&pdev->dev,
+                        "request alarm IRQ failed with %d, IRQ %d\n", ret,
+                        rtc->alarm_irq);
+                free_irq(rtc->carry_irq, rtc);
+                free_irq(rtc->periodic_irq, rtc);
+                goto err_badmap;
+        }
+
+        tmp = readb(rtc->regbase + RCR1);
+        tmp &= ~RCR1_CF;
+        tmp |= RCR1_CIE;
+        writeb(tmp, rtc->regbase + RCR1);
+
         return 0;
 
 err_badmap:
@@ -630,6 +702,10 @@ static int __devexit sh_rtc_remove(struct platform_device *pdev)
         sh_rtc_setpie(&pdev->dev, 0);
         sh_rtc_setaie(&pdev->dev, 0);
 
+        free_irq(rtc->carry_irq, rtc);
+        free_irq(rtc->periodic_irq, rtc);
+        free_irq(rtc->alarm_irq, rtc);
+
         release_resource(rtc->res);
 
         platform_set_drvdata(pdev, NULL);
@@ -662,6 +738,8 @@ module_exit(sh_rtc_exit);
 
 MODULE_DESCRIPTION("SuperH on-chip RTC driver");
 MODULE_VERSION(DRV_VERSION);
-MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>, Jamie Lenehan <lenehan@twibble.org>");
+MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>, "
+              "Jamie Lenehan <lenehan@twibble.org>, "
+              "Angelo Castello <angelo.castello@st.com>");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index 03914fa81174..fe1ad1722158 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -16,7 +16,6 @@
 #include <linux/ctype.h>
 #include <linux/dcache.h>
 
-#include <asm/semaphore.h>
 #include <asm/ccwdev.h>
 #include <asm/ccwgroup.h>
 
diff --git a/drivers/s390/cio/qdio.c b/drivers/s390/cio/qdio.c
index c359386708e9..10aa1e780801 100644
--- a/drivers/s390/cio/qdio.c
+++ b/drivers/s390/cio/qdio.c
@@ -38,11 +38,11 @@
 #include <linux/proc_fs.h>
 #include <linux/timer.h>
 #include <linux/mempool.h>
+#include <linux/semaphore.h>
 
 #include <asm/ccwdev.h>
 #include <asm/io.h>
 #include <asm/atomic.h>
-#include <asm/semaphore.h>
 #include <asm/timex.h>
 
 #include <asm/debug.h>
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 439fd8146657..460d4024c46c 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -31,7 +31,6 @@
 #include <linux/slab.h>
 #include <linux/completion.h>
 #include <linux/blkdev.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 #include <linux/highmem.h> /* For flush_kernel_dcache_page */
 
diff --git a/drivers/scsi/aacraid/commctrl.c b/drivers/scsi/aacraid/commctrl.c
index abef05146d75..5fd83deab36c 100644
--- a/drivers/scsi/aacraid/commctrl.c
+++ b/drivers/scsi/aacraid/commctrl.c
@@ -39,7 +39,7 @@
 #include <linux/blkdev.h>
 #include <linux/delay.h> /* ssleep prototype */
 #include <linux/kthread.h>
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 #include <asm/uaccess.h>
 
 #include "aacraid.h"
diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
index 89cc8b7b42a2..294a802450be 100644
--- a/drivers/scsi/aacraid/comminit.c
+++ b/drivers/scsi/aacraid/comminit.c
@@ -39,7 +39,6 @@
 #include <linux/completion.h>
 #include <linux/mm.h>
 #include <scsi/scsi_host.h>
-#include <asm/semaphore.h>
 
 #include "aacraid.h"
 
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 23a8e9f8dcb4..ef67816a6fe5 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -41,11 +41,11 @@
 #include <linux/delay.h>
 #include <linux/kthread.h>
 #include <linux/interrupt.h>
+#include <linux/semaphore.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
-#include <asm/semaphore.h>
 
 #include "aacraid.h"
 
diff --git a/drivers/scsi/aacraid/dpcsup.c b/drivers/scsi/aacraid/dpcsup.c
index d1163ded132b..933f208eedba 100644
--- a/drivers/scsi/aacraid/dpcsup.c
+++ b/drivers/scsi/aacraid/dpcsup.c
@@ -36,7 +36,7 @@
 #include <linux/slab.h>
 #include <linux/completion.h>
 #include <linux/blkdev.h>
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 
 #include "aacraid.h"
 
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index c6391838b2cd..c109f63f8279 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -42,7 +42,6 @@
 #include <linux/syscalls.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
-#include <asm/semaphore.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
diff --git a/drivers/scsi/aacraid/rx.c b/drivers/scsi/aacraid/rx.c
index 1f18b83e1e02..073208b0f622 100644
--- a/drivers/scsi/aacraid/rx.c
+++ b/drivers/scsi/aacraid/rx.c
@@ -39,7 +39,6 @@
 #include <linux/completion.h>
 #include <linux/time.h>
 #include <linux/interrupt.h>
-#include <asm/semaphore.h>
 
 #include <scsi/scsi_host.h>
 
diff --git a/drivers/scsi/aacraid/sa.c b/drivers/scsi/aacraid/sa.c
index cfc3410ec073..fc1a55796a89 100644
--- a/drivers/scsi/aacraid/sa.c
+++ b/drivers/scsi/aacraid/sa.c
@@ -39,7 +39,6 @@
 #include <linux/completion.h>
 #include <linux/time.h>
 #include <linux/interrupt.h>
-#include <asm/semaphore.h>
 
 #include <scsi/scsi_host.h>
 
diff --git a/drivers/scsi/dpt/dpti_i2o.h b/drivers/scsi/dpt/dpti_i2o.h
index 100b49baca7f..19406cea6d6a 100644
--- a/drivers/scsi/dpt/dpti_i2o.h
+++ b/drivers/scsi/dpt/dpti_i2o.h
@@ -21,7 +21,6 @@
 
 #include <linux/i2o-dev.h>
 
-#include <asm/semaphore.h> /* Needed for MUTEX init macros */
 #include <linux/version.h>
 #include <linux/notifier.h>
 #include <asm/atomic.h>
diff --git a/drivers/scsi/megaraid/mega_common.h b/drivers/scsi/megaraid/mega_common.h
index fef9ac958754..f62ed468ada0 100644
--- a/drivers/scsi/megaraid/mega_common.h
+++ b/drivers/scsi/megaraid/mega_common.h
@@ -28,7 +28,6 @@
 #include <linux/list.h>
 #include <linux/moduleparam.h>
 #include <linux/dma-mapping.h>
-#include <asm/semaphore.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
diff --git a/drivers/scsi/megaraid/megaraid_ioctl.h b/drivers/scsi/megaraid/megaraid_ioctl.h
index 706fa05a187a..05f6e4ec3453 100644
--- a/drivers/scsi/megaraid/megaraid_ioctl.h
+++ b/drivers/scsi/megaraid/megaraid_ioctl.h
@@ -18,7 +18,7 @@
 #define _MEGARAID_IOCTL_H_
 
 #include <linux/types.h>
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 
 #include "mbox_defs.h"
 
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 094d95f0764c..299eccf6cabd 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -25,7 +25,7 @@
 #include <linux/firmware.h>
 #include <linux/aer.h>
 #include <linux/mutex.h>
-#include <asm/semaphore.h>
+#include <linux/semaphore.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 16ba9ac7a566..5a375bf0ebf4 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -166,15 +166,6 @@
 #define SERIAL_IMX_MAJOR        204
 #define MINOR_START             41
 
-#define NR_PORTS                2
-
-#define IMX_ISR_PASS_LIMIT      256
-
-/*
- * This is the size of our serial port register set.
- */
-#define UART_PORT_SIZE  0x100
-
 /*
  * This determines how often we check the modem status signals
  * for any change.  They generally aren't connected to an IRQ
@@ -358,66 +349,60 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
         struct tty_struct *tty = sport->port.info->tty;
         unsigned long flags, temp;
 
-        rx = readl(sport->port.membase + URXD0);
         spin_lock_irqsave(&sport->port.lock,flags);
 
-        do {
+        while (readl(sport->port.membase + USR2) & USR2_RDR) {
                 flg = TTY_NORMAL;
                 sport->port.icount.rx++;
 
+                rx = readl(sport->port.membase + URXD0);
+
                 temp = readl(sport->port.membase + USR2);
-                if( temp & USR2_BRCD ) {
+                if (temp & USR2_BRCD) {
                         writel(temp | USR2_BRCD, sport->port.membase + USR2);
-                        if(uart_handle_break(&sport->port))
-                                goto ignore_char;
+                        if (uart_handle_break(&sport->port))
+                                continue;
                 }
 
                 if (uart_handle_sysrq_char
                             (&sport->port, (unsigned char)rx))
-                        goto ignore_char;
+                        continue;
+
+                if (rx & (URXD_PRERR | URXD_OVRRUN | URXD_FRMERR) ) {
+                        if (rx & URXD_PRERR)
+                                sport->port.icount.parity++;
+                        else if (rx & URXD_FRMERR)
+                                sport->port.icount.frame++;
+                        if (rx & URXD_OVRRUN)
+                                sport->port.icount.overrun++;
+
+                        if (rx & sport->port.ignore_status_mask) {
+                                if (++ignored > 100)
+                                        goto out;
+                                continue;
+                        }
+
+                        rx &= sport->port.read_status_mask;
+
+                        if (rx & URXD_PRERR)
+                                flg = TTY_PARITY;
+                        else if (rx & URXD_FRMERR)
+                                flg = TTY_FRAME;
+                        if (rx & URXD_OVRRUN)
+                                flg = TTY_OVERRUN;
 
-                if( rx & (URXD_PRERR | URXD_OVRRUN | URXD_FRMERR) )
-                        goto handle_error;
+#ifdef SUPPORT_SYSRQ
+                        sport->port.sysrq = 0;
+#endif
+                }
 
-        error_return:
                 tty_insert_flip_char(tty, rx, flg);
-
-        ignore_char:
-                rx = readl(sport->port.membase + URXD0);
-        } while(rx & URXD_CHARRDY);
+        }
 
 out:
         spin_unlock_irqrestore(&sport->port.lock,flags);
         tty_flip_buffer_push(tty);
         return IRQ_HANDLED;
-
-handle_error:
-        if (rx & URXD_PRERR)
-                sport->port.icount.parity++;
-        else if (rx & URXD_FRMERR)
-                sport->port.icount.frame++;
-        if (rx & URXD_OVRRUN)
-                sport->port.icount.overrun++;
-
-        if (rx & sport->port.ignore_status_mask) {
-                if (++ignored > 100)
-                        goto out;
-                goto ignore_char;
-        }
-
-        rx &= sport->port.read_status_mask;
-
-        if (rx & URXD_PRERR)
-                flg = TTY_PARITY;
-        else if (rx & URXD_FRMERR)
-                flg = TTY_FRAME;
-        if (rx & URXD_OVRRUN)
-                flg = TTY_OVERRUN;
-
-#ifdef SUPPORT_SYSRQ
-        sport->port.sysrq = 0;
-#endif
-        goto error_return;
 }
 
 /*
@@ -546,7 +531,7 @@ static int imx_startup(struct uart_port *port)
         writel(USR1_RTSD, sport->port.membase + USR1);
 
         temp = readl(sport->port.membase + UCR1);
-        temp |= (UCR1_TXMPTYEN | UCR1_RRDYEN | UCR1_RTSDEN | UCR1_UARTEN);
+        temp |= UCR1_RRDYEN | UCR1_RTSDEN | UCR1_UARTEN;
         writel(temp, sport->port.membase + UCR1);
 
         temp = readl(sport->port.membase + UCR2);
@@ -731,9 +716,11 @@ static const char *imx_type(struct uart_port *port)
  */
 static void imx_release_port(struct uart_port *port)
 {
-        struct imx_port *sport = (struct imx_port *)port;
+        struct platform_device *pdev = to_platform_device(port->dev);
+        struct resource *mmres;
 
-        release_mem_region(sport->port.mapbase, UART_PORT_SIZE);
+        mmres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(mmres->start, mmres->end - mmres->start + 1);
 }
 
 /*
@@ -741,10 +728,18 @@ static void imx_release_port(struct uart_port *port)
  */
 static int imx_request_port(struct uart_port *port)
 {
-        struct imx_port *sport = (struct imx_port *)port;
+        struct platform_device *pdev = to_platform_device(port->dev);
+        struct resource *mmres;
+        void *ret;
+
+        mmres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mmres)
+                return -ENODEV;
+
+        ret = request_mem_region(mmres->start, mmres->end - mmres->start + 1,
+                        "imx-uart");
 
-        return request_mem_region(sport->port.mapbase, UART_PORT_SIZE,
-                        "imx-uart") != NULL ? 0 : -EBUSY;
+        return  ret ? 0 : -EBUSY;
 }
 
 /*
@@ -815,7 +810,7 @@ static struct imx_port imx_ports[] = {
                 .type           = PORT_IMX,
                 .iotype         = UPIO_MEM,
                 .membase        = (void *)IMX_UART1_BASE,
-                .mapbase        = IMX_UART1_BASE, /* FIXME */
+                .mapbase        = 0x00206000,
                 .irq            = UART1_MINT_RX,
                 .uartclk        = 16000000,
                 .fifosize       = 32,
@@ -831,7 +826,7 @@ static struct imx_port imx_ports[] = {
                 .type           = PORT_IMX,
                 .iotype         = UPIO_MEM,
                 .membase        = (void *)IMX_UART2_BASE,
-                .mapbase        = IMX_UART2_BASE, /* FIXME */
+                .mapbase        = 0x00207000,
                 .irq            = UART2_MINT_RX,
                 .uartclk        = 16000000,
                 .fifosize       = 32,
diff --git a/drivers/serial/mcfserial.c b/drivers/serial/mcfserial.c
index 99af084c7cec..ddd3aa50d4ad 100644
--- a/drivers/serial/mcfserial.c
+++ b/drivers/serial/mcfserial.c
@@ -40,7 +40,6 @@
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/system.h>
-#include <asm/semaphore.h>
 #include <asm/delay.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index eff593080d4f..c2ea5d4df44a 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -333,7 +333,6 @@ static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
         }
         sci_out(port, SCFCR, fcr_val);
 }
-
 #elif defined(CONFIG_CPU_SH3)
 /* For SH7705, SH7706, SH7707, SH7709, SH7709A, SH7729 */
 static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
@@ -384,6 +383,12 @@ static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
 
         sci_out(port, SCFCR, fcr_val);
 }
+#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
+static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
+{
+        /* Nothing to do here.. */
+        sci_out(port, SCFCR, 0);
+}
 #else
 /* For SH7750 */
 static void sci_init_pins_scif(struct uart_port *port, unsigned int cflag)
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index 01a9dd715f5d..fa8700a968fc 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -1,20 +1,5 @@
-/* $Id: sh-sci.h,v 1.4 2004/02/19 16:43:56 lethal Exp $
- *
- *  linux/drivers/serial/sh-sci.h
- *
- *  SuperH on-chip serial module support.  (SCI with no FIFO / with FIFO)
- *  Copyright (C) 1999, 2000  Niibe Yutaka
- *  Copyright (C) 2000  Greg Banks
- *  Copyright (C) 2002, 2003  Paul Mundt
- *  Modified to support multiple serial ports. Stuart Menefy (May 2000).
- *  Modified to support SH7300(SH-Mobile) SCIF. Takashi Kusuda (Jun 2003).
- *  Modified to support H8/300 Series Yoshinori Sato (Feb 2004).
- *  Removed SH7300 support (Jul 2007).
- *  Modified to support SH7720 SCIF. Markus Brunner, Mark Jonas (Aug 2007).
- */
 #include <linux/serial_core.h>
 #include <asm/io.h>
-
 #include <asm/gpio.h>
 
 #if defined(CONFIG_H83007) || defined(CONFIG_H83068)
@@ -102,6 +87,15 @@
 # define SCSPTR0                SCPDR0
 # define SCIF_ORER              0x0001  /* overrun error bit */
 # define SCSCR_INIT(port)       0x0038  /* TIE=0,RIE=0,TE=1,RE=1,REIE=1 */
+#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
+# define SCSPTR0                0xa4050160
+# define SCSPTR1                0xa405013e
+# define SCSPTR2                0xa4050160
+# define SCSPTR3                0xa405013e
+# define SCSPTR4                0xa4050128
+# define SCSPTR5                0xa4050128
+# define SCIF_ORER              0x0001  /* overrun error bit */
+# define SCSCR_INIT(port)       0x0038  /* TIE=0,RIE=0,TE=1,RE=1,REIE=1 */
 # define SCIF_ONLY
 #elif defined(CONFIG_CPU_SUBTYPE_SH4_202)
 # define SCSPTR2 0xffe80020 /* 16 bit SCIF */
@@ -395,6 +389,11 @@
                  h8_sci_offset, h8_sci_size) \
   CPU_SCI_FNS(name, h8_sci_offset, h8_sci_size)
 #define SCIF_FNS(name, sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
+        #define SCIx_FNS(name, sh4_scifa_offset, sh4_scifa_size, sh4_scif_offset, sh4_scif_size) \
+                CPU_SCIx_FNS(name, sh4_scifa_offset, sh4_scifa_size, sh4_scif_offset, sh4_scif_size)
+        #define SCIF_FNS(name, sh4_scif_offset, sh4_scif_size) \
+                CPU_SCIF_FNS(name, sh4_scif_offset, sh4_scif_size)
 #else
 #define SCIx_FNS(name, sh3_sci_offset, sh3_sci_size, sh4_sci_offset, sh4_sci_size, \
                  sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size, \
@@ -419,6 +418,18 @@ SCIF_FNS(SCFDR,  0x1c, 16)
 SCIF_FNS(SCxTDR, 0x20,  8)
 SCIF_FNS(SCxRDR, 0x24,  8)
 SCIF_FNS(SCLSR,  0x24, 16)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
+SCIx_FNS(SCSMR,  0x00, 16, 0x00, 16)
+SCIx_FNS(SCBRR,  0x04,  8, 0x04,  8)
+SCIx_FNS(SCSCR,  0x08, 16, 0x08, 16)
+SCIx_FNS(SCxTDR, 0x20,  8, 0x0c,  8)
+SCIx_FNS(SCxSR,  0x14, 16, 0x10, 16)
+SCIx_FNS(SCxRDR, 0x24,  8, 0x14,  8)
+SCIF_FNS(SCTDSR, 0x0c,  8)
+SCIF_FNS(SCFER,  0x10, 16)
+SCIF_FNS(SCFCR,  0x18, 16)
+SCIF_FNS(SCFDR,  0x1c, 16)
+SCIF_FNS(SCLSR,  0x24, 16)
 #else
 /*      reg      SCI/SH3   SCI/SH4  SCIF/SH3   SCIF/SH4  SCI/H8*/
 /*      name     off  sz   off  sz   off  sz   off  sz   off  sz*/
@@ -589,6 +600,23 @@ static inline int sci_rxd_in(struct uart_port *port)
                 return ctrl_inb(SCPDR0) & 0x0001 ? 1 : 0; /* SCIF0 */
         return 1;
 }
+#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
+static inline int sci_rxd_in(struct uart_port *port)
+{
+        if (port->mapbase == 0xffe00000)
+                return ctrl_inb(SCSPTR0) & 0x0008 ? 1 : 0; /* SCIF0 */
+        if (port->mapbase == 0xffe10000)
+                return ctrl_inb(SCSPTR1) & 0x0020 ? 1 : 0; /* SCIF1 */
+        if (port->mapbase == 0xffe20000)
+                return ctrl_inb(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF2 */
+        if (port->mapbase == 0xa4e30000)
+                return ctrl_inb(SCSPTR3) & 0x0001 ? 1 : 0; /* SCIF3 */
+        if (port->mapbase == 0xa4e40000)
+                return ctrl_inb(SCSPTR4) & 0x0001 ? 1 : 0; /* SCIF4 */
+        if (port->mapbase == 0xa4e50000)
+                return ctrl_inb(SCSPTR5) & 0x0008 ? 1 : 0; /* SCIF5 */
+        return 1;
+}
 #elif defined(CONFIG_CPU_SUBTYPE_SH5_101) || defined(CONFIG_CPU_SUBTYPE_SH5_103)
 static inline int sci_rxd_in(struct uart_port *port)
 {
@@ -727,6 +755,8 @@ static inline int sci_rxd_in(struct uart_port *port)
       defined(CONFIG_CPU_SUBTYPE_SH7720) || \
       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)
 #elif defined(__H8300H__) || defined(__H8300S__)
 #define SCBRR_VALUE(bps) (((CONFIG_CPU_CLOCK*1000/32)/bps)-1)
 #elif defined(CONFIG_SUPERH64)
diff --git a/drivers/usb/atm/usbatm.h b/drivers/usb/atm/usbatm.h
index ff8551e93372..fc6c2be5999c 100644
--- a/drivers/usb/atm/usbatm.h
+++ b/drivers/usb/atm/usbatm.h
@@ -24,7 +24,6 @@
 #ifndef _USBATM_H_
 #define _USBATM_H_
 
-#include <asm/semaphore.h>
 #include <linux/atm.h>
 #include <linux/atmdev.h>
 #include <linux/completion.h>
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 68fc5219ca15..57aeca160f38 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -23,7 +23,6 @@
 #include <linux/mutex.h>
 #include <linux/freezer.h>
 
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
 
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 6f45dd669b33..d681bb27fa58 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -118,10 +118,10 @@ config USB_AMD5536UDC
 config USB_GADGET_ATMEL_USBA
         boolean "Atmel USBA"
         select USB_GADGET_DUALSPEED
-        depends on AVR32
+        depends on AVR32 || ARCH_AT91CAP9
         help
           USBA is the integrated high-speed USB Device controller on
-          the AT32AP700x processors from Atmel.
+          the AT32AP700x and AT91CAP9 processors from Atmel.
 
 config USB_ATMEL_USBA
         tristate
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index b0db4c31d018..e756023362c2 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -18,6 +18,7 @@
 #include <linux/platform_device.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/atmel_usba_udc.h>
 #include <linux/delay.h>
 
 #include <asm/gpio.h>
@@ -27,6 +28,7 @@
 
 
 static struct usba_udc the_udc;
+static struct usba_ep *usba_ep;
 
 #ifdef CONFIG_USB_GADGET_DEBUG_FS
 #include <linux/debugfs.h>
@@ -324,53 +326,28 @@ static int vbus_is_present(struct usba_udc *udc)
         return 1;
 }
 
-static void copy_to_fifo(void __iomem *fifo, const void *buf, int len)
+#if defined(CONFIG_AVR32)
+
+static void toggle_bias(int is_on)
 {
-        unsigned long tmp;
-
-        DBG(DBG_FIFO, "copy to FIFO (len %d):\n", len);
-        for (; len > 0; len -= 4, buf += 4, fifo += 4) {
-                tmp = *(unsigned long *)buf;
-                if (len >= 4) {
-                        DBG(DBG_FIFO, "  -> %08lx\n", tmp);
-                        __raw_writel(tmp, fifo);
-                } else {
-                        do {
-                                DBG(DBG_FIFO, "  -> %02lx\n", tmp >> 24);
-                                __raw_writeb(tmp >> 24, fifo);
-                                fifo++;
-                                tmp <<= 8;
-                        } while (--len);
-                        break;
-                }
-        }
 }
 
-static void copy_from_fifo(void *buf, void __iomem *fifo, int len)
+#elif defined(CONFIG_ARCH_AT91)
+
+#include <asm/arch/at91_pmc.h>
+
+static void toggle_bias(int is_on)
 {
-        union {
-                unsigned long *w;
-                unsigned char *b;
-        } p;
-        unsigned long tmp;
-
-        DBG(DBG_FIFO, "copy from FIFO (len %d):\n", len);
-        for (p.w = buf; len > 0; len -= 4, p.w++, fifo += 4) {
-                if (len >= 4) {
-                        tmp = __raw_readl(fifo);
-                        *p.w = tmp;
-                        DBG(DBG_FIFO, "  -> %08lx\n", tmp);
-                } else {
-                        do {
-                                tmp = __raw_readb(fifo);
-                                *p.b = tmp;
-                                DBG(DBG_FIFO, " -> %02lx\n", tmp);
-                                fifo++, p.b++;
-                        } while (--len);
-                }
-        }
+        unsigned int uckr = at91_sys_read(AT91_CKGR_UCKR);
+
+        if (is_on)
+                at91_sys_write(AT91_CKGR_UCKR, uckr | AT91_PMC_BIASEN);
+        else
+                at91_sys_write(AT91_CKGR_UCKR, uckr & ~(AT91_PMC_BIASEN));
 }
 
+#endif /* CONFIG_ARCH_AT91 */
+
 static void next_fifo_transaction(struct usba_ep *ep, struct usba_request *req)
 {
         unsigned int transaction_len;
@@ -387,7 +364,7 @@ static void next_fifo_transaction(struct usba_ep *ep, struct usba_request *req)
                 ep->ep.name, req, transaction_len,
                 req->last_transaction ? ", done" : "");
 
-        copy_to_fifo(ep->fifo, req->req.buf + req->req.actual, transaction_len);
+        memcpy_toio(ep->fifo, req->req.buf + req->req.actual, transaction_len);
         usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
         req->req.actual += transaction_len;
 }
@@ -476,7 +453,7 @@ static void receive_data(struct usba_ep *ep)
                         bytecount = req->req.length - req->req.actual;
                 }
 
-                copy_from_fifo(req->req.buf + req->req.actual,
+                memcpy_fromio(req->req.buf + req->req.actual,
                                 ep->fifo, bytecount);
                 req->req.actual += bytecount;
 
@@ -1029,33 +1006,6 @@ static const struct usb_gadget_ops usba_udc_ops = {
         .set_selfpowered        = usba_udc_set_selfpowered,
 };
 
-#define EP(nam, idx, maxpkt, maxbk, dma, isoc)                  \
-{                                                               \
-        .ep     = {                                             \
-                .ops            = &usba_ep_ops,                 \
-                .name           = nam,                          \
-                .maxpacket      = maxpkt,                       \
-        },                                                      \
-        .udc            = &the_udc,                             \
-        .queue          = LIST_HEAD_INIT(usba_ep[idx].queue),   \
-        .fifo_size      = maxpkt,                               \
-        .nr_banks       = maxbk,                                \
-        .index          = idx,                                  \
-        .can_dma        = dma,                                  \
-        .can_isoc       = isoc,                                 \
-}
-
-static struct usba_ep usba_ep[] = {
-        EP("ep0", 0, 64, 1, 0, 0),
-        EP("ep1in-bulk", 1, 512, 2, 1, 1),
-        EP("ep2out-bulk", 2, 512, 2, 1, 1),
-        EP("ep3in-int", 3, 64, 3, 1, 0),
-        EP("ep4out-int", 4, 64, 3, 1, 0),
-        EP("ep5in-iso", 5, 1024, 3, 1, 1),
-        EP("ep6out-iso", 6, 1024, 3, 1, 1),
-};
-#undef EP
-
 static struct usb_endpoint_descriptor usba_ep0_desc = {
         .bLength = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType = USB_DT_ENDPOINT,
@@ -1074,7 +1024,6 @@ static void nop_release(struct device *dev)
 static struct usba_udc the_udc = {
         .gadget = {
                 .ops            = &usba_udc_ops,
-                .ep0            = &usba_ep[0].ep,
                 .ep_list        = LIST_HEAD_INIT(the_udc.gadget.ep_list),
                 .is_dualspeed   = 1,
                 .name           = "atmel_usba_udc",
@@ -1231,7 +1180,7 @@ static int do_test_mode(struct usba_udc *udc)
                 } else {
                         usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE);
                         usba_writel(udc, TST, USBA_TST_PKT_MODE);
-                        copy_to_fifo(ep->fifo, test_packet_buffer,
+                        memcpy_toio(ep->fifo, test_packet_buffer,
                                         sizeof(test_packet_buffer));
                         usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY);
                         dev_info(dev, "Entering Test_Packet mode...\n");
@@ -1530,13 +1479,13 @@ restart:
                 DBG(DBG_HW, "Packet length: %u\n", pkt_len);
                 if (pkt_len != sizeof(crq)) {
                         pr_warning("udc: Invalid packet length %u "
-                                "(expected %lu)\n", pkt_len, sizeof(crq));
+                                "(expected %zu)\n", pkt_len, sizeof(crq));
                         set_protocol_stall(udc, ep);
                         return;
                 }
 
                 DBG(DBG_FIFO, "Copying ctrl request from 0x%p:\n", ep->fifo);
-                copy_from_fifo(crq.data, ep->fifo, sizeof(crq));
+                memcpy_fromio(crq.data, ep->fifo, sizeof(crq));
 
                 /* Free up one bank in the FIFO so that we can
                  * generate or receive a reply right away. */
@@ -1688,6 +1637,7 @@ static irqreturn_t usba_udc_irq(int irq, void *devid)
         DBG(DBG_INT, "irq, status=%#08x\n", status);
 
         if (status & USBA_DET_SUSPEND) {
+                toggle_bias(0);
                 usba_writel(udc, INT_CLR, USBA_DET_SUSPEND);
                 DBG(DBG_BUS, "Suspend detected\n");
                 if (udc->gadget.speed != USB_SPEED_UNKNOWN
@@ -1699,6 +1649,7 @@ static irqreturn_t usba_udc_irq(int irq, void *devid)
         }
 
         if (status & USBA_WAKE_UP) {
+                toggle_bias(1);
                 usba_writel(udc, INT_CLR, USBA_WAKE_UP);
                 DBG(DBG_BUS, "Wake Up CPU detected\n");
         }
@@ -1792,12 +1743,14 @@ static irqreturn_t usba_vbus_irq(int irq, void *devid)
         vbus = gpio_get_value(udc->vbus_pin);
         if (vbus != udc->vbus_prev) {
                 if (vbus) {
-                        usba_writel(udc, CTRL, USBA_EN_USBA);
+                        toggle_bias(1);
+                        usba_writel(udc, CTRL, USBA_ENABLE_MASK);
                         usba_writel(udc, INT_ENB, USBA_END_OF_RESET);
                 } else {
                         udc->gadget.speed = USB_SPEED_UNKNOWN;
                         reset_all_endpoints(udc);
-                        usba_writel(udc, CTRL, 0);
+                        toggle_bias(0);
+                        usba_writel(udc, CTRL, USBA_DISABLE_MASK);
                         spin_unlock(&udc->lock);
                         udc->driver->disconnect(&udc->gadget);
                         spin_lock(&udc->lock);
@@ -1850,7 +1803,8 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         /* If Vbus is present, enable the controller and wait for reset */
         spin_lock_irqsave(&udc->lock, flags);
         if (vbus_is_present(udc) && udc->vbus_prev == 0) {
-                usba_writel(udc, CTRL, USBA_EN_USBA);
+                toggle_bias(1);
+                usba_writel(udc, CTRL, USBA_ENABLE_MASK);
                 usba_writel(udc, INT_ENB, USBA_END_OF_RESET);
         }
         spin_unlock_irqrestore(&udc->lock, flags);
@@ -1883,7 +1837,8 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         spin_unlock_irqrestore(&udc->lock, flags);
 
         /* This will also disable the DP pullup */
-        usba_writel(udc, CTRL, 0);
+        toggle_bias(0);
+        usba_writel(udc, CTRL, USBA_DISABLE_MASK);
 
         driver->unbind(&udc->gadget);
         udc->gadget.dev.driver = NULL;
@@ -1908,7 +1863,7 @@ static int __init usba_udc_probe(struct platform_device *pdev)
 
         regs = platform_get_resource(pdev, IORESOURCE_MEM, CTRL_IOMEM_ID);
         fifo = platform_get_resource(pdev, IORESOURCE_MEM, FIFO_IOMEM_ID);
-        if (!regs || !fifo)
+        if (!regs || !fifo || !pdata)
                 return -ENXIO;
 
         irq = platform_get_irq(pdev, 0);
@@ -1953,19 +1908,48 @@ static int __init usba_udc_probe(struct platform_device *pdev)
 
         /* Make sure we start from a clean slate */
         clk_enable(pclk);
-        usba_writel(udc, CTRL, 0);
+        toggle_bias(0);
+        usba_writel(udc, CTRL, USBA_DISABLE_MASK);
         clk_disable(pclk);
 
+        usba_ep = kmalloc(sizeof(struct usba_ep) * pdata->num_ep,
+                          GFP_KERNEL);
+        if (!usba_ep)
+                goto err_alloc_ep;
+
+        the_udc.gadget.ep0 = &usba_ep[0].ep;
+
         INIT_LIST_HEAD(&usba_ep[0].ep.ep_list);
         usba_ep[0].ep_regs = udc->regs + USBA_EPT_BASE(0);
         usba_ep[0].dma_regs = udc->regs + USBA_DMA_BASE(0);
         usba_ep[0].fifo = udc->fifo + USBA_FIFO_BASE(0);
-        for (i = 1; i < ARRAY_SIZE(usba_ep); i++) {
+        usba_ep[0].ep.ops = &usba_ep_ops;
+        usba_ep[0].ep.name = pdata->ep[0].name;
+        usba_ep[0].ep.maxpacket = pdata->ep[0].fifo_size;
+        usba_ep[0].udc = &the_udc;
+        INIT_LIST_HEAD(&usba_ep[0].queue);
+        usba_ep[0].fifo_size = pdata->ep[0].fifo_size;
+        usba_ep[0].nr_banks = pdata->ep[0].nr_banks;
+        usba_ep[0].index = pdata->ep[0].index;
+        usba_ep[0].can_dma = pdata->ep[0].can_dma;
+        usba_ep[0].can_isoc = pdata->ep[0].can_isoc;
+
+        for (i = 1; i < pdata->num_ep; i++) {
                 struct usba_ep *ep = &usba_ep[i];
 
                 ep->ep_regs = udc->regs + USBA_EPT_BASE(i);
                 ep->dma_regs = udc->regs + USBA_DMA_BASE(i);
                 ep->fifo = udc->fifo + USBA_FIFO_BASE(i);
+                ep->ep.ops = &usba_ep_ops;
+                ep->ep.name = pdata->ep[i].name;
+                ep->ep.maxpacket = pdata->ep[i].fifo_size;
+                ep->udc = &the_udc;
+                INIT_LIST_HEAD(&ep->queue);
+                ep->fifo_size = pdata->ep[i].fifo_size;
+                ep->nr_banks = pdata->ep[i].nr_banks;
+                ep->index = pdata->ep[i].index;
+                ep->can_dma = pdata->ep[i].can_dma;
+                ep->can_isoc = pdata->ep[i].can_isoc;
 
                 list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
         }
@@ -1984,7 +1968,7 @@ static int __init usba_udc_probe(struct platform_device *pdev)
                 goto err_device_add;
         }
 
-        if (pdata && pdata->vbus_pin != GPIO_PIN_NONE) {
+        if (pdata->vbus_pin >= 0) {
                 if (!gpio_request(pdata->vbus_pin, "atmel_usba_udc")) {
                         udc->vbus_pin = pdata->vbus_pin;
 
@@ -2004,7 +1988,7 @@ static int __init usba_udc_probe(struct platform_device *pdev)
         }
 
         usba_init_debugfs(udc);
-        for (i = 1; i < ARRAY_SIZE(usba_ep); i++)
+        for (i = 1; i < pdata->num_ep; i++)
                 usba_ep_init_debugfs(udc, &usba_ep[i]);
 
         return 0;
@@ -2012,6 +1996,8 @@ static int __init usba_udc_probe(struct platform_device *pdev)
 err_device_add:
         free_irq(irq, udc);
 err_request_irq:
+        kfree(usba_ep);
+err_alloc_ep:
         iounmap(udc->fifo);
 err_map_fifo:
         iounmap(udc->regs);
@@ -2029,10 +2015,11 @@ static int __exit usba_udc_remove(struct platform_device *pdev)
 {
         struct usba_udc *udc;
         int i;
+        struct usba_platform_data *pdata = pdev->dev.platform_data;
 
         udc = platform_get_drvdata(pdev);
 
-        for (i = 1; i < ARRAY_SIZE(usba_ep); i++)
+        for (i = 1; i < pdata->num_ep; i++)
                 usba_ep_cleanup_debugfs(&usba_ep[i]);
         usba_cleanup_debugfs(udc);
 
@@ -2040,6 +2027,7 @@ static int __exit usba_udc_remove(struct platform_device *pdev)
                 gpio_free(udc->vbus_pin);
 
         free_irq(udc->irq, udc);
+        kfree(usba_ep);
         iounmap(udc->fifo);
         iounmap(udc->regs);
         clk_put(udc->hclk);
diff --git a/drivers/usb/gadget/atmel_usba_udc.h b/drivers/usb/gadget/atmel_usba_udc.h
index 08bf6f9aaf7e..f7baea307f0d 100644
--- a/drivers/usb/gadget/atmel_usba_udc.h
+++ b/drivers/usb/gadget/atmel_usba_udc.h
@@ -41,6 +41,15 @@
 #define USBA_EN_USBA                            (1 <<  8)
 #define USBA_DETACH                             (1 <<  9)
 #define USBA_REMOTE_WAKE_UP                     (1 << 10)
+#define USBA_PULLD_DIS                          (1 << 11)
+
+#if defined(CONFIG_AVR32)
+#define USBA_ENABLE_MASK                        USBA_EN_USBA
+#define USBA_DISABLE_MASK                       0
+#elif defined(CONFIG_ARCH_AT91)
+#define USBA_ENABLE_MASK                        (USBA_EN_USBA | USBA_PULLD_DIS)
+#define USBA_DISABLE_MASK                       USBA_DETACH
+#endif /* CONFIG_ARCH_AT91 */
 
 /* Bitfields in FNUM */
 #define USBA_MICRO_FRAME_NUM_OFFSET             0
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 46ee7f4c0912..85074cb36f38 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -1033,7 +1033,7 @@ MODULE_LICENSE ("GPL");
 #define OF_PLATFORM_DRIVER      ehci_hcd_ppc_of_driver
 #endif
 
-#ifdef CONFIG_ARCH_ORION
+#ifdef CONFIG_PLAT_ORION
 #include "ehci-orion.c"
 #define PLATFORM_DRIVER         ehci_orion_driver
 #endif
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index e129981f139f..d187d0313742 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -11,15 +11,18 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
-#include <asm/arch/orion.h>
+#include <linux/mbus.h>
+#include <asm/plat-orion/ehci-orion.h>
 
 #define rdl(off)        __raw_readl(hcd->regs + (off))
 #define wrl(off, val)   __raw_writel((val), hcd->regs + (off))
 
-#define USB_CAUSE               0x310
-#define USB_MASK                0x314
 #define USB_CMD                 0x140
 #define USB_MODE                0x1a8
+#define USB_CAUSE               0x310
+#define USB_MASK                0x314
+#define USB_WINDOW_CTRL(i)      (0x320 + ((i) << 4))
+#define USB_WINDOW_BASE(i)      (0x324 + ((i) << 4))
 #define USB_IPG                 0x360
 #define USB_PHY_PWR_CTRL        0x400
 #define USB_PHY_TX_CTRL         0x420
@@ -162,8 +165,30 @@ static const struct hc_driver ehci_orion_hc_driver = {
         .bus_resume = ehci_bus_resume,
 };
 
+static void __init
+ehci_orion_conf_mbus_windows(struct usb_hcd *hcd,
+                                struct mbus_dram_target_info *dram)
+{
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                wrl(USB_WINDOW_CTRL(i), 0);
+                wrl(USB_WINDOW_BASE(i), 0);
+        }
+
+        for (i = 0; i < dram->num_cs; i++) {
+                struct mbus_dram_window *cs = dram->cs + i;
+
+                wrl(USB_WINDOW_CTRL(i), ((cs->size - 1) & 0xffff0000) |
+                                        (cs->mbus_attr << 8) |
+                                        (dram->mbus_dram_target_id << 4) | 1);
+                wrl(USB_WINDOW_BASE(i), cs->base);
+        }
+}
+
 static int __init ehci_orion_drv_probe(struct platform_device *pdev)
 {
+        struct orion_ehci_data *pd = pdev->dev.platform_data;
         struct resource *res;
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
@@ -227,6 +252,12 @@ static int __init ehci_orion_drv_probe(struct platform_device *pdev)
         ehci->sbrn = 0x20;
 
         /*
+         * (Re-)program MBUS remapping windows if we are asked to.
+         */
+        if (pd != NULL && pd->dram != NULL)
+                ehci_orion_conf_mbus_windows(hcd, pd->dram);
+
+        /*
          * setup Orion USB controller
          */
         orion_usb_setup(hcd);
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index 1cb56f2d5c84..a5e4c3545c72 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -29,7 +29,6 @@
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <asm/atomic.h>
-#include <asm/semaphore.h>
 
 #define APPLE_VENDOR_ID         0x05AC
 
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index cd3405953f74..e5ea5ef6335d 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -38,7 +38,6 @@
 #include <linux/serial.h>
 #include <linux/ioctl.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index e3d241f67afc..3a3776677339 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -82,7 +82,6 @@
 #include <linux/circ_buf.h>
 #include <linux/mutex.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
diff --git a/drivers/video/pxafb.c b/drivers/video/pxafb.c
index 97facb121c73..757651954e6c 100644
--- a/drivers/video/pxafb.c
+++ b/drivers/video/pxafb.c
@@ -45,6 +45,7 @@
 #include <asm/irq.h>
 #include <asm/div64.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-gpio.h>
 #include <asm/arch/bitfield.h>
 #include <asm/arch/pxafb.h>
 
diff --git a/drivers/watchdog/sc1200wdt.c b/drivers/watchdog/sc1200wdt.c
index 32ccd7c89c7d..35cddff7020f 100644
--- a/drivers/watchdog/sc1200wdt.c
+++ b/drivers/watchdog/sc1200wdt.c
@@ -38,8 +38,8 @@
 #include <linux/init.h>
 #include <linux/pnp.h>
 #include <linux/fs.h>
+#include <linux/semaphore.h>
 
-#include <asm/semaphore.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>