134 files changed, 4741 insertions, 1342 deletions

diff --git a/drivers/atm/eni.c b/drivers/atm/eni.c
index 2059ee460b0c..81e44f7b0ab6 100644
--- a/drivers/atm/eni.c
+++ b/drivers/atm/eni.c
@@ -1567,7 +1567,7 @@ tx_complete++;
 /*--------------------------------- entries ---------------------------------*/
 
 
-static const char *media_name[] __devinitdata = {
+static char * const media_name[] __devinitconst = {
     "MMF", "SMF", "MMF", "03?", /*  0- 3 */
     "UTP", "05?", "06?", "07?", /*  4- 7 */
     "TAXI","09?", "10?", "11?", /*  8-11 */
diff --git a/drivers/block/aoe/aoe.h b/drivers/block/aoe/aoe.h
index db195abad698..d2ed7f18d1ac 100644
--- a/drivers/block/aoe/aoe.h
+++ b/drivers/block/aoe/aoe.h
@@ -1,5 +1,5 @@
-/* Copyright (c) 2007 Coraid, Inc.  See COPYING for GPL terms. */
-#define VERSION "47"
+/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
+#define VERSION "50"
 #define AOE_MAJOR 152
 #define DEVICE_NAME "aoe"
 
@@ -10,9 +10,6 @@
 #define AOE_PARTITIONS (16)
 #endif
 
-#define SYSMINOR(aoemajor, aoeminor) ((aoemajor) * NPERSHELF + (aoeminor))
-#define AOEMAJOR(sysminor) ((sysminor) / NPERSHELF)
-#define AOEMINOR(sysminor) ((sysminor) % NPERSHELF)
 #define WHITESPACE " \t\v\f\n"
 
 enum {
@@ -75,72 +72,67 @@ enum {
         DEVFL_UP = 1,   /* device is installed in system and ready for AoE->ATA commands */
         DEVFL_TKILL = (1<<1),   /* flag for timer to know when to kill self */
         DEVFL_EXT = (1<<2),     /* device accepts lba48 commands */
-        DEVFL_CLOSEWAIT = (1<<3), /* device is waiting for all closes to revalidate */
-        DEVFL_GDALLOC = (1<<4), /* need to alloc gendisk */
-        DEVFL_KICKME = (1<<5),  /* slow polling network card catch */
-        DEVFL_NEWSIZE = (1<<6), /* need to update dev size in block layer */
-
-        BUFFL_FAIL = 1,
+        DEVFL_GDALLOC = (1<<3), /* need to alloc gendisk */
+        DEVFL_KICKME = (1<<4),  /* slow polling network card catch */
+        DEVFL_NEWSIZE = (1<<5), /* need to update dev size in block layer */
 };
 
 enum {
         DEFAULTBCNT = 2 * 512,  /* 2 sectors */
-        NPERSHELF = 16,         /* number of slots per shelf address */
-        FREETAG = -1,
         MIN_BUFS = 16,
         NTARGETS = 8,
         NAOEIFS = 8,
-        NSKBPOOLMAX = 128,
+        NSKBPOOLMAX = 256,
+        NFACTIVE = 61,
 
         TIMERTICK = HZ / 10,
         MINTIMER = HZ >> 2,
         MAXTIMER = HZ << 1,
-        HELPWAIT = 20,
 };
 
 struct buf {
-        struct list_head bufs;
-        ulong stime;    /* for disk stats */
-        ulong flags;
         ulong nframesout;
         ulong resid;
         ulong bv_resid;
-        ulong bv_off;
         sector_t sector;
         struct bio *bio;
         struct bio_vec *bv;
+        struct request *rq;
 };
 
 struct frame {
-        int tag;
+        struct list_head head;
+        u32 tag;
         ulong waited;
+        struct aoetgt *t;               /* parent target I belong to */
+        sector_t lba;
+        struct sk_buff *skb;            /* command skb freed on module exit */
+        struct sk_buff *r_skb;          /* response skb for async processing */
         struct buf *buf;
-        char *bufaddr;
+        struct bio_vec *bv;
         ulong bcnt;
-        sector_t lba;
-        struct sk_buff *skb;
+        ulong bv_off;
 };
 
 struct aoeif {
         struct net_device *nd;
-        unsigned char lost;
-        unsigned char lostjumbo;
-        ushort maxbcnt;
+        ulong lost;
+        int bcnt;
 };
 
 struct aoetgt {
         unsigned char addr[6];
         ushort nframes;
-        struct frame *frames;
+        struct aoedev *d;                       /* parent device I belong to */
+        struct list_head ffree;                 /* list of free frames */
         struct aoeif ifs[NAOEIFS];
         struct aoeif *ifp;      /* current aoeif in use */
         ushort nout;
         ushort maxout;
-        u16 lasttag;            /* last tag sent */
-        u16 useme;
+        ulong falloc;
         ulong lastwadj;         /* last window adjustment */
+        int minbcnt;
         int wpkts, rpkts;
-        int dataref;
 };
 
 struct aoedev {
@@ -153,6 +145,9 @@ struct aoedev {
         u16 rttavg;             /* round trip average of requests/responses */
         u16 mintimer;
         u16 fw_ver;             /* version of blade's firmware */
+        u16 lasttag;            /* last tag sent */
+        u16 useme;
+        ulong ref;
         struct work_struct work;/* disk create work struct */
         struct gendisk *gd;
         struct request_queue *blkq;
@@ -160,16 +155,31 @@ struct aoedev {
         sector_t ssize;
         struct timer_list timer;
         spinlock_t lock;
-        struct sk_buff_head sendq;
         struct sk_buff_head skbpool;
         mempool_t *bufpool;     /* for deadlock-free Buf allocation */
-        struct list_head bufq;  /* queue of bios to work on */
-        struct buf *inprocess;  /* the one we're currently working on */
+        struct {                /* pointers to work in progress */
+                struct buf *buf;
+                struct bio *nxbio;
+                struct request *rq;
+        } ip;
+        ulong maxbcnt;
+        struct list_head factive[NFACTIVE];     /* hash of active frames */
         struct aoetgt *targets[NTARGETS];
         struct aoetgt **tgt;    /* target in use when working */
-        struct aoetgt **htgt;   /* target needing rexmit assistance */
+        struct aoetgt *htgt;    /* target needing rexmit assistance */
+        ulong ntargets;
+        ulong kicked;
 };
 
+/* kthread tracking */
+struct ktstate {
+        struct completion rendez;
+        struct task_struct *task;
+        wait_queue_head_t *waitq;
+        int (*fn) (void);
+        char *name;
+        spinlock_t *lock;
+};
 
 int aoeblk_init(void);
 void aoeblk_exit(void);
@@ -182,22 +192,29 @@ void aoechr_error(char *);
 
 void aoecmd_work(struct aoedev *d);
 void aoecmd_cfg(ushort aoemajor, unsigned char aoeminor);
-void aoecmd_ata_rsp(struct sk_buff *);
+struct sk_buff *aoecmd_ata_rsp(struct sk_buff *);
 void aoecmd_cfg_rsp(struct sk_buff *);
 void aoecmd_sleepwork(struct work_struct *);
 void aoecmd_cleanslate(struct aoedev *);
+void aoecmd_exit(void);
+int aoecmd_init(void);
 struct sk_buff *aoecmd_ata_id(struct aoedev *);
+void aoe_freetframe(struct frame *);
+void aoe_flush_iocq(void);
+void aoe_end_request(struct aoedev *, struct request *, int);
+int aoe_ktstart(struct ktstate *k);
+void aoe_ktstop(struct ktstate *k);
 
 int aoedev_init(void);
 void aoedev_exit(void);
-struct aoedev *aoedev_by_aoeaddr(int maj, int min);
-struct aoedev *aoedev_by_sysminor_m(ulong sysminor);
+struct aoedev *aoedev_by_aoeaddr(ulong maj, int min, int do_alloc);
 void aoedev_downdev(struct aoedev *d);
 int aoedev_flush(const char __user *str, size_t size);
+void aoe_failbuf(struct aoedev *, struct buf *);
+void aoedev_put(struct aoedev *);
 
 int aoenet_init(void);
 void aoenet_exit(void);
 void aoenet_xmit(struct sk_buff_head *);
 int is_aoe_netif(struct net_device *ifp);
 int set_aoe_iflist(const char __user *str, size_t size);
-
diff --git a/drivers/block/aoe/aoeblk.c b/drivers/block/aoe/aoeblk.c
index 321de7b6c442..00dfc5008ad4 100644
--- a/drivers/block/aoe/aoeblk.c
+++ b/drivers/block/aoe/aoeblk.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007 Coraid, Inc.  See COPYING for GPL terms. */
+/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
 /*
  * aoeblk.c
  * block device routines
@@ -161,68 +161,22 @@ aoeblk_release(struct gendisk *disk, fmode_t mode)
 }
 
 static void
-aoeblk_make_request(struct request_queue *q, struct bio *bio)
+aoeblk_request(struct request_queue *q)
 {
-        struct sk_buff_head queue;
         struct aoedev *d;
-        struct buf *buf;
-        ulong flags;
-
-        blk_queue_bounce(q, &bio);
-
-        if (bio == NULL) {
-                printk(KERN_ERR "aoe: bio is NULL\n");
-                BUG();
-                return;
-        }
-        d = bio->bi_bdev->bd_disk->private_data;
-        if (d == NULL) {
-                printk(KERN_ERR "aoe: bd_disk->private_data is NULL\n");
-                BUG();
-                bio_endio(bio, -ENXIO);
-                return;
-        } else if (bio->bi_io_vec == NULL) {
-                printk(KERN_ERR "aoe: bi_io_vec is NULL\n");
-                BUG();
-                bio_endio(bio, -ENXIO);
-                return;
-        }
-        buf = mempool_alloc(d->bufpool, GFP_NOIO);
-        if (buf == NULL) {
-                printk(KERN_INFO "aoe: buf allocation failure\n");
-                bio_endio(bio, -ENOMEM);
-                return;
-        }
-        memset(buf, 0, sizeof(*buf));
-        INIT_LIST_HEAD(&buf->bufs);
-        buf->stime = jiffies;
-        buf->bio = bio;
-        buf->resid = bio->bi_size;
-        buf->sector = bio->bi_sector;
-        buf->bv = &bio->bi_io_vec[bio->bi_idx];
-        buf->bv_resid = buf->bv->bv_len;
-        WARN_ON(buf->bv_resid == 0);
-        buf->bv_off = buf->bv->bv_offset;
-
-        spin_lock_irqsave(&d->lock, flags);
+        struct request *rq;
 
+        d = q->queuedata;
         if ((d->flags & DEVFL_UP) == 0) {
                 pr_info_ratelimited("aoe: device %ld.%d is not up\n",
                         d->aoemajor, d->aoeminor);
-                spin_unlock_irqrestore(&d->lock, flags);
-                mempool_free(buf, d->bufpool);
-                bio_endio(bio, -ENXIO);
+                while ((rq = blk_peek_request(q))) {
+                        blk_start_request(rq);
+                        aoe_end_request(d, rq, 1);
+                }
                 return;
         }
-
-        list_add_tail(&buf->bufs, &d->bufq);
-
         aoecmd_work(d);
-        __skb_queue_head_init(&queue);
-        skb_queue_splice_init(&d->sendq, &queue);
-
-        spin_unlock_irqrestore(&d->lock, flags);
-        aoenet_xmit(&queue);
 }
 
 static int
@@ -254,41 +208,54 @@ aoeblk_gdalloc(void *vp)
 {
         struct aoedev *d = vp;
         struct gendisk *gd;
+        mempool_t *mp;
+        struct request_queue *q;
+        enum { KB = 1024, MB = KB * KB, READ_AHEAD = 2 * MB, };
         ulong flags;
 
         gd = alloc_disk(AOE_PARTITIONS);
         if (gd == NULL) {
-                printk(KERN_ERR
-                        "aoe: cannot allocate disk structure for %ld.%d\n",
+                pr_err("aoe: cannot allocate disk structure for %ld.%d\n",
                         d->aoemajor, d->aoeminor);
                 goto err;
         }
 
-        d->bufpool = mempool_create_slab_pool(MIN_BUFS, buf_pool_cache);
-        if (d->bufpool == NULL) {
+        mp = mempool_create(MIN_BUFS, mempool_alloc_slab, mempool_free_slab,
+                buf_pool_cache);
+        if (mp == NULL) {
                 printk(KERN_ERR "aoe: cannot allocate bufpool for %ld.%d\n",
                         d->aoemajor, d->aoeminor);
                 goto err_disk;
         }
+        q = blk_init_queue(aoeblk_request, &d->lock);
+        if (q == NULL) {
+                pr_err("aoe: cannot allocate block queue for %ld.%d\n",
+                        d->aoemajor, d->aoeminor);
+                mempool_destroy(mp);
+                goto err_disk;
+        }
 
         d->blkq = blk_alloc_queue(GFP_KERNEL);
         if (!d->blkq)
                 goto err_mempool;
-        blk_queue_make_request(d->blkq, aoeblk_make_request);
         d->blkq->backing_dev_info.name = "aoe";
         if (bdi_init(&d->blkq->backing_dev_info))
                 goto err_blkq;
         spin_lock_irqsave(&d->lock, flags);
+        blk_queue_max_hw_sectors(d->blkq, BLK_DEF_MAX_SECTORS);
+        q->backing_dev_info.ra_pages = READ_AHEAD / PAGE_CACHE_SIZE;
+        d->bufpool = mp;
+        d->blkq = gd->queue = q;
+        q->queuedata = d;
+        d->gd = gd;
         gd->major = AOE_MAJOR;
-        gd->first_minor = d->sysminor * AOE_PARTITIONS;
+        gd->first_minor = d->sysminor;
         gd->fops = &aoe_bdops;
         gd->private_data = d;
         set_capacity(gd, d->ssize);
         snprintf(gd->disk_name, sizeof gd->disk_name, "etherd/e%ld.%d",
                 d->aoemajor, d->aoeminor);
 
-        gd->queue = d->blkq;
-        d->gd = gd;
         d->flags &= ~DEVFL_GDALLOC;
         d->flags |= DEVFL_UP;
 
diff --git a/drivers/block/aoe/aoechr.c b/drivers/block/aoe/aoechr.c
index e86d2062a164..ed57a890c643 100644
--- a/drivers/block/aoe/aoechr.c
+++ b/drivers/block/aoe/aoechr.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007 Coraid, Inc.  See COPYING for GPL terms. */
+/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
 /*
  * aoechr.c
  * AoE character device driver
@@ -86,34 +86,34 @@ revalidate(const char __user *str, size_t size)
         if (copy_from_user(buf, str, size))
                 return -EFAULT;
 
-        /* should be e%d.%d format */
         n = sscanf(buf, "e%d.%d", &major, &minor);
         if (n != 2) {
-                printk(KERN_ERR "aoe: invalid device specification\n");
+                pr_err("aoe: invalid device specification %s\n", buf);
                 return -EINVAL;
         }
-        d = aoedev_by_aoeaddr(major, minor);
+        d = aoedev_by_aoeaddr(major, minor, 0);
         if (!d)
                 return -EINVAL;
         spin_lock_irqsave(&d->lock, flags);
         aoecmd_cleanslate(d);
+        aoecmd_cfg(major, minor);
 loop:
         skb = aoecmd_ata_id(d);
         spin_unlock_irqrestore(&d->lock, flags);
         /* try again if we are able to sleep a bit,
          * otherwise give up this revalidation
          */
-        if (!skb && !msleep_interruptible(200)) {
+        if (!skb && !msleep_interruptible(250)) {
                 spin_lock_irqsave(&d->lock, flags);
                 goto loop;
         }
+        aoedev_put(d);
         if (skb) {
                 struct sk_buff_head queue;
                 __skb_queue_head_init(&queue);
                 __skb_queue_tail(&queue, skb);
                 aoenet_xmit(&queue);
         }
-        aoecmd_cfg(major, minor);
         return 0;
 }
 
@@ -174,6 +174,7 @@ aoechr_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offp
                 break;
         case MINOR_FLUSH:
                 ret = aoedev_flush(buf, cnt);
+                break;
         }
         if (ret == 0)
                 ret = cnt;
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index 887f68f6d79a..3804a0af3ef1 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007 Coraid, Inc.  See COPYING for GPL terms. */
+/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
 /*
  * aoecmd.c
  * Filesystem request handling methods
@@ -12,10 +12,19 @@
 #include <linux/netdevice.h>
 #include <linux/genhd.h>
 #include <linux/moduleparam.h>
+#include <linux/workqueue.h>
+#include <linux/kthread.h>
 #include <net/net_namespace.h>
 #include <asm/unaligned.h>
+#include <linux/uio.h>
 #include "aoe.h"
 
+#define MAXIOC (8192)   /* default meant to avoid most soft lockups */
+
+static void ktcomplete(struct frame *, struct sk_buff *);
+
+static struct buf *nextbuf(struct aoedev *);
+
 static int aoe_deadsecs = 60 * 3;
 module_param(aoe_deadsecs, int, 0644);
 MODULE_PARM_DESC(aoe_deadsecs, "After aoe_deadsecs seconds, give up and fail dev.");
@@ -25,6 +34,15 @@ module_param(aoe_maxout, int, 0644);
 MODULE_PARM_DESC(aoe_maxout,
         "Only aoe_maxout outstanding packets for every MAC on eX.Y.");
 
+static wait_queue_head_t ktiowq;
+static struct ktstate kts;
+
+/* io completion queue */
+static struct {
+        struct list_head head;
+        spinlock_t lock;
+} iocq;
+
 static struct sk_buff *
 new_skb(ulong len)
 {
@@ -41,15 +59,21 @@ new_skb(ulong len)
 }
 
 static struct frame *
-getframe(struct aoetgt *t, int tag)
+getframe(struct aoedev *d, u32 tag)
 {
-        struct frame *f, *e;
+        struct frame *f;
+        struct list_head *head, *pos, *nx;
+        u32 n;
 
-        f = t->frames;
-        e = f + t->nframes;
-        for (; f<e; f++)
-                if (f->tag == tag)
+        n = tag % NFACTIVE;
+        head = &d->factive[n];
+        list_for_each_safe(pos, nx, head) {
+                f = list_entry(pos, struct frame, head);
+                if (f->tag == tag) {
+                        list_del(pos);
                         return f;
+                }
+        }
         return NULL;
 }
 
@@ -59,18 +83,18 @@ getframe(struct aoetgt *t, int tag)
  * This driver reserves tag -1 to mean "unused frame."
  */
 static int
-newtag(struct aoetgt *t)
+newtag(struct aoedev *d)
 {
         register ulong n;
 
         n = jiffies & 0xffff;
-        return n |= (++t->lasttag & 0x7fff) << 16;
+        return n |= (++d->lasttag & 0x7fff) << 16;
 }
 
-static int
+static u32
 aoehdr_atainit(struct aoedev *d, struct aoetgt *t, struct aoe_hdr *h)
 {
-        u32 host_tag = newtag(t);
+        u32 host_tag = newtag(d);
 
         memcpy(h->src, t->ifp->nd->dev_addr, sizeof h->src);
         memcpy(h->dst, t->addr, sizeof h->dst);
@@ -95,16 +119,18 @@ put_lba(struct aoe_atahdr *ah, sector_t lba)
         ah->lba5 = lba >>= 8;
 }
 
-static void
+static struct aoeif *
 ifrotate(struct aoetgt *t)
 {
-        t->ifp++;
-        if (t->ifp >= &t->ifs[NAOEIFS] || t->ifp->nd == NULL)
-                t->ifp = t->ifs;
-        if (t->ifp->nd == NULL) {
-                printk(KERN_INFO "aoe: no interface to rotate to\n");
-                BUG();
-        }
+        struct aoeif *ifp;
+
+        ifp = t->ifp;
+        ifp++;
+        if (ifp >= &t->ifs[NAOEIFS] || ifp->nd == NULL)
+                ifp = t->ifs;
+        if (ifp->nd == NULL)
+                return NULL;
+        return t->ifp = ifp;
 }
 
 static void
@@ -129,78 +155,128 @@ skb_pool_get(struct aoedev *d)
         return NULL;
 }
 
-/* freeframe is where we do our load balancing so it's a little hairy. */
+void
+aoe_freetframe(struct frame *f)
+{
+        struct aoetgt *t;
+
+        t = f->t;
+        f->buf = NULL;
+        f->bv = NULL;
+        f->r_skb = NULL;
+        list_add(&f->head, &t->ffree);
+}
+
 static struct frame *
-freeframe(struct aoedev *d)
+newtframe(struct aoedev *d, struct aoetgt *t)
 {
-        struct frame *f, *e, *rf;
-        struct aoetgt **t;
+        struct frame *f;
         struct sk_buff *skb;
+        struct list_head *pos;
+
+        if (list_empty(&t->ffree)) {
+                if (t->falloc >= NSKBPOOLMAX*2)
+                        return NULL;
+                f = kcalloc(1, sizeof(*f), GFP_ATOMIC);
+                if (f == NULL)
+                        return NULL;
+                t->falloc++;
+                f->t = t;
+        } else {
+                pos = t->ffree.next;
+                list_del(pos);
+                f = list_entry(pos, struct frame, head);
+        }
+
+        skb = f->skb;
+        if (skb == NULL) {
+                f->skb = skb = new_skb(ETH_ZLEN);
+                if (!skb) {
+bail:                   aoe_freetframe(f);
+                        return NULL;
+                }
+        }
+
+        if (atomic_read(&skb_shinfo(skb)->dataref) != 1) {
+                skb = skb_pool_get(d);
+                if (skb == NULL)
+                        goto bail;
+                skb_pool_put(d, f->skb);
+                f->skb = skb;
+        }
+
+        skb->truesize -= skb->data_len;
+        skb_shinfo(skb)->nr_frags = skb->data_len = 0;
+        skb_trim(skb, 0);
+        return f;
+}
+
+static struct frame *
+newframe(struct aoedev *d)
+{
+        struct frame *f;
+        struct aoetgt *t, **tt;
+        int totout = 0;
 
         if (d->targets[0] == NULL) {    /* shouldn't happen, but I'm paranoid */
                 printk(KERN_ERR "aoe: NULL TARGETS!\n");
                 return NULL;
         }
-        t = d->tgt;
-        t++;
-        if (t >= &d->targets[NTARGETS] || !*t)
-                t = d->targets;
+        tt = d->tgt;    /* last used target */
         for (;;) {
-                if ((*t)->nout < (*t)->maxout
+                tt++;
+                if (tt >= &d->targets[NTARGETS] || !*tt)
+                        tt = d->targets;
+                t = *tt;
+                totout += t->nout;
+                if (t->nout < t->maxout
                 && t != d->htgt
-                && (*t)->ifp->nd) {
-                        rf = NULL;
-                        f = (*t)->frames;
-                        e = f + (*t)->nframes;
-                        for (; f < e; f++) {
-                                if (f->tag != FREETAG)
-                                        continue;
-                                skb = f->skb;
-                                if (!skb
-                                && !(f->skb = skb = new_skb(ETH_ZLEN)))
-                                        continue;
-                                if (atomic_read(&skb_shinfo(skb)->dataref)
-                                        != 1) {
-                                        if (!rf)
-                                                rf = f;
-                                        continue;
-                                }
-gotone:                         skb_shinfo(skb)->nr_frags = skb->data_len = 0;
-                                skb_trim(skb, 0);
-                                d->tgt = t;
-                                ifrotate(*t);
+                && t->ifp->nd) {
+                        f = newtframe(d, t);
+                        if (f) {
+                                ifrotate(t);
+                                d->tgt = tt;
                                 return f;
                         }
-                        /* Work can be done, but the network layer is
-                           holding our precious packets.  Try to grab
-                           one from the pool. */
-                        f = rf;
-                        if (f == NULL) {        /* more paranoia */
-                                printk(KERN_ERR
-                                        "aoe: freeframe: %s.\n",
-                                        "unexpected null rf");
-                                d->flags |= DEVFL_KICKME;
-                                return NULL;
-                        }
-                        skb = skb_pool_get(d);
-                        if (skb) {
-                                skb_pool_put(d, f->skb);
-                                f->skb = skb;
-                                goto gotone;
-                        }
-                        (*t)->dataref++;
-                        if ((*t)->nout == 0)
-                                d->flags |= DEVFL_KICKME;
                 }
-                if (t == d->tgt)        /* we've looped and found nada */
+                if (tt == d->tgt)       /* we've looped and found nada */
                         break;
-                t++;
-                if (t >= &d->targets[NTARGETS] || !*t)
-                        t = d->targets;
+        }
+        if (totout == 0) {
+                d->kicked++;
+                d->flags |= DEVFL_KICKME;
         }
         return NULL;
 }
 
+static void
+skb_fillup(struct sk_buff *skb, struct bio_vec *bv, ulong off, ulong cnt)
+{
+        int frag = 0;
+        ulong fcnt;
+loop:
+        fcnt = bv->bv_len - (off - bv->bv_offset);
+        if (fcnt > cnt)
+                fcnt = cnt;
+        skb_fill_page_desc(skb, frag++, bv->bv_page, off, fcnt);
+        cnt -= fcnt;
+        if (cnt <= 0)
+                return;
+        bv++;
+        off = bv->bv_offset;
+        goto loop;
+}
+
+static void
+fhash(struct frame *f)
+{
+        struct aoedev *d = f->t->d;
+        u32 n;
+
+        n = f->tag % NFACTIVE;
+        list_add_tail(&f->head, &d->factive[n]);
+}
+
 static int
 aoecmd_ata_rw(struct aoedev *d)
 {
@@ -208,26 +284,47 @@ aoecmd_ata_rw(struct aoedev *d)
         struct aoe_hdr *h;
         struct aoe_atahdr *ah;
         struct buf *buf;
-        struct bio_vec *bv;
         struct aoetgt *t;
         struct sk_buff *skb;
-        ulong bcnt;
+        struct sk_buff_head queue;
+        ulong bcnt, fbcnt;
         char writebit, extbit;
 
         writebit = 0x10;
         extbit = 0x4;
 
-        f = freeframe(d);
+        buf = nextbuf(d);
+        if (buf == NULL)
+                return 0;
+        f = newframe(d);
         if (f == NULL)
                 return 0;
         t = *d->tgt;
-        buf = d->inprocess;
-        bv = buf->bv;
-        bcnt = t->ifp->maxbcnt;
+        bcnt = d->maxbcnt;
         if (bcnt == 0)
                 bcnt = DEFAULTBCNT;
-        if (bcnt > buf->bv_resid)
-                bcnt = buf->bv_resid;
+        if (bcnt > buf->resid)
+                bcnt = buf->resid;
+        fbcnt = bcnt;
+        f->bv = buf->bv;
+        f->bv_off = f->bv->bv_offset + (f->bv->bv_len - buf->bv_resid);
+        do {
+                if (fbcnt < buf->bv_resid) {
+                        buf->bv_resid -= fbcnt;
+                        buf->resid -= fbcnt;
+                        break;
+                }
+                fbcnt -= buf->bv_resid;
+                buf->resid -= buf->bv_resid;
+                if (buf->resid == 0) {
+                        d->ip.buf = NULL;
+                        break;
+                }
+                buf->bv++;
+                buf->bv_resid = buf->bv->bv_len;
+                WARN_ON(buf->bv_resid == 0);
+        } while (fbcnt);
+
         /* initialize the headers & frame */
         skb = f->skb;
         h = (struct aoe_hdr *) skb_mac_header(skb);
@@ -235,10 +332,10 @@ aoecmd_ata_rw(struct aoedev *d)
         skb_put(skb, sizeof *h + sizeof *ah);
         memset(h, 0, skb->len);
         f->tag = aoehdr_atainit(d, t, h);
+        fhash(f);
         t->nout++;
         f->waited = 0;
         f->buf = buf;
-        f->bufaddr = page_address(bv->bv_page) + buf->bv_off;
         f->bcnt = bcnt;
         f->lba = buf->sector;
 
@@ -253,10 +350,11 @@ aoecmd_ata_rw(struct aoedev *d)
                 ah->lba3 |= 0xe0;       /* LBA bit + obsolete 0xa0 */
         }
         if (bio_data_dir(buf->bio) == WRITE) {
-                skb_fill_page_desc(skb, 0, bv->bv_page, buf->bv_off, bcnt);
+                skb_fillup(skb, f->bv, f->bv_off, bcnt);
                 ah->aflags |= AOEAFL_WRITE;
                 skb->len += bcnt;
                 skb->data_len = bcnt;
+                skb->truesize += bcnt;
                 t->wpkts++;
         } else {
                 t->rpkts++;
@@ -267,23 +365,15 @@ aoecmd_ata_rw(struct aoedev *d)
 
         /* mark all tracking fields and load out */
         buf->nframesout += 1;
-        buf->bv_off += bcnt;
-        buf->bv_resid -= bcnt;
-        buf->resid -= bcnt;
         buf->sector += bcnt >> 9;
-        if (buf->resid == 0) {
-                d->inprocess = NULL;
-        } else if (buf->bv_resid == 0) {
-                buf->bv = ++bv;
-                buf->bv_resid = bv->bv_len;
-                WARN_ON(buf->bv_resid == 0);
-                buf->bv_off = bv->bv_offset;
-        }
 
         skb->dev = t->ifp->nd;
         skb = skb_clone(skb, GFP_ATOMIC);
-        if (skb)
-                __skb_queue_tail(&d->sendq, skb);
+        if (skb) {
+                __skb_queue_head_init(&queue);
+                __skb_queue_tail(&queue, skb);
+                aoenet_xmit(&queue);
+        }
         return 1;
 }
 
@@ -330,17 +420,25 @@ cont:
 }
 
 static void
-resend(struct aoedev *d, struct aoetgt *t, struct frame *f)
+resend(struct aoedev *d, struct frame *f)
 {
         struct sk_buff *skb;
+        struct sk_buff_head queue;
         struct aoe_hdr *h;
         struct aoe_atahdr *ah;
+        struct aoetgt *t;
         char buf[128];
         u32 n;
 
-        ifrotate(t);
-        n = newtag(t);
+        t = f->t;
+        n = newtag(d);
         skb = f->skb;
+        if (ifrotate(t) == NULL) {
+                /* probably can't happen, but set it up to fail anyway */
+                pr_info("aoe: resend: no interfaces to rotate to.\n");
+                ktcomplete(f, NULL);
+                return;
+        }
         h = (struct aoe_hdr *) skb_mac_header(skb);
         ah = (struct aoe_atahdr *) (h+1);
 
@@ -351,39 +449,22 @@ resend(struct aoedev *d, struct aoetgt *t, struct frame *f)
         aoechr_error(buf);
 
         f->tag = n;
+        fhash(f);
         h->tag = cpu_to_be32(n);
         memcpy(h->dst, t->addr, sizeof h->dst);
         memcpy(h->src, t->ifp->nd->dev_addr, sizeof h->src);
 
-        switch (ah->cmdstat) {
-        default:
-                break;
-        case ATA_CMD_PIO_READ:
-        case ATA_CMD_PIO_READ_EXT:
-        case ATA_CMD_PIO_WRITE:
-        case ATA_CMD_PIO_WRITE_EXT:
-                put_lba(ah, f->lba);
-
-                n = f->bcnt;
-                if (n > DEFAULTBCNT)
-                        n = DEFAULTBCNT;
-                ah->scnt = n >> 9;
-                if (ah->aflags & AOEAFL_WRITE) {
-                        skb_fill_page_desc(skb, 0, virt_to_page(f->bufaddr),
-                                offset_in_page(f->bufaddr), n);
-                        skb->len = sizeof *h + sizeof *ah + n;
-                        skb->data_len = n;
-                }
-        }
         skb->dev = t->ifp->nd;
         skb = skb_clone(skb, GFP_ATOMIC);
         if (skb == NULL)
                 return;
-        __skb_queue_tail(&d->sendq, skb);
+        __skb_queue_head_init(&queue);
+        __skb_queue_tail(&queue, skb);
+        aoenet_xmit(&queue);
 }
 
 static int
-tsince(int tag)
+tsince(u32 tag)
 {
         int n;
 
@@ -407,58 +488,65 @@ getif(struct aoetgt *t, struct net_device *nd)
         return NULL;
 }
 
-static struct aoeif *
-addif(struct aoetgt *t, struct net_device *nd)
-{
-        struct aoeif *p;
-
-        p = getif(t, NULL);
-        if (!p)
-                return NULL;
-        p->nd = nd;
-        p->maxbcnt = DEFAULTBCNT;
-        p->lost = 0;
-        p->lostjumbo = 0;
-        return p;
-}
-
 static void
 ejectif(struct aoetgt *t, struct aoeif *ifp)
 {
         struct aoeif *e;
+        struct net_device *nd;
         ulong n;
 
+        nd = ifp->nd;
         e = t->ifs + NAOEIFS - 1;
         n = (e - ifp) * sizeof *ifp;
         memmove(ifp, ifp+1, n);
         e->nd = NULL;
+        dev_put(nd);
 }
 
 static int
 sthtith(struct aoedev *d)
 {
-        struct frame *f, *e, *nf;
+        struct frame *f, *nf;
+        struct list_head *nx, *pos, *head;
         struct sk_buff *skb;
-        struct aoetgt *ht = *d->htgt;
-
-        f = ht->frames;
-        e = f + ht->nframes;
-        for (; f < e; f++) {
-                if (f->tag == FREETAG)
-                        continue;
-                nf = freeframe(d);
-                if (!nf)
-                        return 0;
-                skb = nf->skb;
-                *nf = *f;
-                f->skb = skb;
-                f->tag = FREETAG;
-                nf->waited = 0;
-                ht->nout--;
-                (*d->tgt)->nout++;
-                resend(d, *d->tgt, nf);
+        struct aoetgt *ht = d->htgt;
+        int i;
+
+        for (i = 0; i < NFACTIVE; i++) {
+                head = &d->factive[i];
+                list_for_each_safe(pos, nx, head) {
+                        f = list_entry(pos, struct frame, head);
+                        if (f->t != ht)
+                                continue;
+
+                        nf = newframe(d);
+                        if (!nf)
+                                return 0;
+
+                        /* remove frame from active list */
+                        list_del(pos);
+
+                        /* reassign all pertinent bits to new outbound frame */
+                        skb = nf->skb;
+                        nf->skb = f->skb;
+                        nf->buf = f->buf;
+                        nf->bcnt = f->bcnt;
+                        nf->lba = f->lba;
+                        nf->bv = f->bv;
+                        nf->bv_off = f->bv_off;
+                        nf->waited = 0;
+                        f->skb = skb;
+                        aoe_freetframe(f);
+                        ht->nout--;
+                        nf->t->nout++;
+                        resend(d, nf);
+                }
         }
-        /* he's clean, he's useless.  take away his interfaces */
+        /* We've cleaned up the outstanding so take away his
+         * interfaces so he won't be used.  We should remove him from
+         * the target array here, but cleaning up a target is
+         * involved.  PUNT!
+         */
         memset(ht->ifs, 0, sizeof ht->ifs);
         d->htgt = NULL;
         return 1;
@@ -477,13 +565,15 @@ ata_scnt(unsigned char *packet) {
 static void
 rexmit_timer(ulong vp)
 {
-        struct sk_buff_head queue;
         struct aoedev *d;
         struct aoetgt *t, **tt, **te;
         struct aoeif *ifp;
-        struct frame *f, *e;
+        struct frame *f;
+        struct list_head *head, *pos, *nx;
+        LIST_HEAD(flist);
         register long timeout;
         ulong flags, n;
+        int i;
 
         d = (struct aoedev *) vp;
 
@@ -497,58 +587,22 @@ rexmit_timer(ulong vp)
                 spin_unlock_irqrestore(&d->lock, flags);
                 return;
         }
-        tt = d->targets;
-        te = tt + NTARGETS;
-        for (; tt < te && *tt; tt++) {
-                t = *tt;
-                f = t->frames;
-                e = f + t->nframes;
-                for (; f < e; f++) {
-                        if (f->tag == FREETAG
-                        || tsince(f->tag) < timeout)
-                                continue;
-                        n = f->waited += timeout;
-                        n /= HZ;
-                        if (n > aoe_deadsecs) {
-                                /* waited too long.  device failure. */
-                                aoedev_downdev(d);
-                                break;
-                        }
-
-                        if (n > HELPWAIT /* see if another target can help */
-                        && (tt != d->targets || d->targets[1]))
-                                d->htgt = tt;
-
-                        if (t->nout == t->maxout) {
-                                if (t->maxout > 1)
-                                        t->maxout--;
-                                t->lastwadj = jiffies;
-                        }
-
-                        ifp = getif(t, f->skb->dev);
-                        if (ifp && ++ifp->lost > (t->nframes << 1)
-                        && (ifp != t->ifs || t->ifs[1].nd)) {
-                                ejectif(t, ifp);
-                                ifp = NULL;
-                        }
 
-                        if (ata_scnt(skb_mac_header(f->skb)) > DEFAULTBCNT / 512
-                        && ifp && ++ifp->lostjumbo > (t->nframes << 1)
-                        && ifp->maxbcnt != DEFAULTBCNT) {
-                                printk(KERN_INFO
-                                        "aoe: e%ld.%d: "
-                                        "too many lost jumbo on "
-                                        "%s:%pm - "
-                                        "falling back to %d frames.\n",
-                                        d->aoemajor, d->aoeminor,
-                                        ifp->nd->name, t->addr,
-                                        DEFAULTBCNT);
-                                ifp->maxbcnt = 0;
-                        }
-                        resend(d, t, f);
+        /* collect all frames to rexmit into flist */
+        for (i = 0; i < NFACTIVE; i++) {
+                head = &d->factive[i];
+                list_for_each_safe(pos, nx, head) {
+                        f = list_entry(pos, struct frame, head);
+                        if (tsince(f->tag) < timeout)
+                                break;  /* end of expired frames */
+                        /* move to flist for later processing */
+                        list_move_tail(pos, &flist);
                 }
-
-                /* window check */
+        }
+        /* window check */
+        tt = d->targets;
+        te = tt + d->ntargets;
+        for (; tt < te && (t = *tt); tt++) {
                 if (t->nout == t->maxout
                 && t->maxout < t->nframes
                 && (jiffies - t->lastwadj)/HZ > 10) {
@@ -557,45 +611,173 @@ rexmit_timer(ulong vp)
                 }
         }
 
-        if (!skb_queue_empty(&d->sendq)) {
+        if (!list_empty(&flist)) {      /* retransmissions necessary */
                 n = d->rttavg <<= 1;
                 if (n > MAXTIMER)
                         d->rttavg = MAXTIMER;
         }
 
-        if (d->flags & DEVFL_KICKME || d->htgt) {
-                d->flags &= ~DEVFL_KICKME;
-                aoecmd_work(d);
+        /* process expired frames */
+        while (!list_empty(&flist)) {
+                pos = flist.next;
+                f = list_entry(pos, struct frame, head);
+                n = f->waited += timeout;
+                n /= HZ;
+                if (n > aoe_deadsecs) {
+                        /* Waited too long.  Device failure.
+                         * Hang all frames on first hash bucket for downdev
+                         * to clean up.
+                         */
+                        list_splice(&flist, &d->factive[0]);
+                        aoedev_downdev(d);
+                        break;
+                }
+                list_del(pos);
+
+                t = f->t;
+                if (n > aoe_deadsecs/2)
+                        d->htgt = t; /* see if another target can help */
+
+                if (t->nout == t->maxout) {
+                        if (t->maxout > 1)
+                                t->maxout--;
+                        t->lastwadj = jiffies;
+                }
+
+                ifp = getif(t, f->skb->dev);
+                if (ifp && ++ifp->lost > (t->nframes << 1)
+                && (ifp != t->ifs || t->ifs[1].nd)) {
+                        ejectif(t, ifp);
+                        ifp = NULL;
+                }
+                resend(d, f);
         }
 
-        __skb_queue_head_init(&queue);
-        skb_queue_splice_init(&d->sendq, &queue);
+        if ((d->flags & DEVFL_KICKME || d->htgt) && d->blkq) {
+                d->flags &= ~DEVFL_KICKME;
+                d->blkq->request_fn(d->blkq);
+        }
 
         d->timer.expires = jiffies + TIMERTICK;
         add_timer(&d->timer);
 
         spin_unlock_irqrestore(&d->lock, flags);
+}
 
-        aoenet_xmit(&queue);
+static unsigned long
+rqbiocnt(struct request *r)
+{
+        struct bio *bio;
+        unsigned long n = 0;
+
+        __rq_for_each_bio(bio, r)
+                n++;
+        return n;
+}
+
+/* This can be removed if we are certain that no users of the block
+ * layer will ever use zero-count pages in bios.  Otherwise we have to
+ * protect against the put_page sometimes done by the network layer.
+ *
+ * See http://oss.sgi.com/archives/xfs/2007-01/msg00594.html for
+ * discussion.
+ *
+ * We cannot use get_page in the workaround, because it insists on a
+ * positive page count as a precondition.  So we use _count directly.
+ */
+static void
+bio_pageinc(struct bio *bio)
+{
+        struct bio_vec *bv;
+        struct page *page;
+        int i;
+
+        bio_for_each_segment(bv, bio, i) {
+                page = bv->bv_page;
+                /* Non-zero page count for non-head members of
+                 * compound pages is no longer allowed by the kernel,
+                 * but this has never been seen here.
+                 */
+                if (unlikely(PageCompound(page)))
+                        if (compound_trans_head(page) != page) {
+                                pr_crit("page tail used for block I/O\n");
+                                BUG();
+                        }
+                atomic_inc(&page->_count);
+        }
+}
+
+static void
+bio_pagedec(struct bio *bio)
+{
+        struct bio_vec *bv;
+        int i;
+
+        bio_for_each_segment(bv, bio, i)
+                atomic_dec(&bv->bv_page->_count);
+}
+
+static void
+bufinit(struct buf *buf, struct request *rq, struct bio *bio)
+{
+        struct bio_vec *bv;
+
+        memset(buf, 0, sizeof(*buf));
+        buf->rq = rq;
+        buf->bio = bio;
+        buf->resid = bio->bi_size;
+        buf->sector = bio->bi_sector;
+        bio_pageinc(bio);
+        buf->bv = bv = &bio->bi_io_vec[bio->bi_idx];
+        buf->bv_resid = bv->bv_len;
+        WARN_ON(buf->bv_resid == 0);
+}
+
+static struct buf *
+nextbuf(struct aoedev *d)
+{
+        struct request *rq;
+        struct request_queue *q;
+        struct buf *buf;
+        struct bio *bio;
+
+        q = d->blkq;
+        if (q == NULL)
+                return NULL;    /* initializing */
+        if (d->ip.buf)
+                return d->ip.buf;
+        rq = d->ip.rq;
+        if (rq == NULL) {
+                rq = blk_peek_request(q);
+                if (rq == NULL)
+                        return NULL;
+                blk_start_request(rq);
+                d->ip.rq = rq;
+                d->ip.nxbio = rq->bio;
+                rq->special = (void *) rqbiocnt(rq);
+        }
+        buf = mempool_alloc(d->bufpool, GFP_ATOMIC);
+        if (buf == NULL) {
+                pr_err("aoe: nextbuf: unable to mempool_alloc!\n");
+                return NULL;
+        }
+        bio = d->ip.nxbio;
+        bufinit(buf, rq, bio);
+        bio = bio->bi_next;
+        d->ip.nxbio = bio;
+        if (bio == NULL)
+                d->ip.rq = NULL;
+        return d->ip.buf = buf;
 }
 
 /* enters with d->lock held */
 void
 aoecmd_work(struct aoedev *d)
 {
-        struct buf *buf;
-loop:
         if (d->htgt && !sthtith(d))
                 return;
-        if (d->inprocess == NULL) {
-                if (list_empty(&d->bufq))
-                        return;
-                buf = container_of(d->bufq.next, struct buf, bufs);
-                list_del(d->bufq.next);
-                d->inprocess = buf;
-        }
-        if (aoecmd_ata_rw(d))
-                goto loop;
+        while (aoecmd_ata_rw(d))
+                ;
 }
 
 /* this function performs work that has been deferred until sleeping is OK
@@ -604,28 +786,25 @@ void
 aoecmd_sleepwork(struct work_struct *work)
 {
         struct aoedev *d = container_of(work, struct aoedev, work);
+        struct block_device *bd;
+        u64 ssize;
 
         if (d->flags & DEVFL_GDALLOC)
                 aoeblk_gdalloc(d);
 
         if (d->flags & DEVFL_NEWSIZE) {
-                struct block_device *bd;
-                unsigned long flags;
-                u64 ssize;
-
                 ssize = get_capacity(d->gd);
                 bd = bdget_disk(d->gd, 0);
-
                 if (bd) {
                         mutex_lock(&bd->bd_inode->i_mutex);
                         i_size_write(bd->bd_inode, (loff_t)ssize<<9);
                         mutex_unlock(&bd->bd_inode->i_mutex);
                         bdput(bd);
                 }
-                spin_lock_irqsave(&d->lock, flags);
+                spin_lock_irq(&d->lock);
                 d->flags |= DEVFL_UP;
                 d->flags &= ~DEVFL_NEWSIZE;
-                spin_unlock_irqrestore(&d->lock, flags);
+                spin_unlock_irq(&d->lock);
         }
 }
 
@@ -718,163 +897,299 @@ gettgt(struct aoedev *d, char *addr)
         return NULL;
 }
 
-static inline void
-diskstats(struct gendisk *disk, struct bio *bio, ulong duration, sector_t sector)
+static void
+bvcpy(struct bio_vec *bv, ulong off, struct sk_buff *skb, long cnt)
+{
+        ulong fcnt;
+        char *p;
+        int soff = 0;
+loop:
+        fcnt = bv->bv_len - (off - bv->bv_offset);
+        if (fcnt > cnt)
+                fcnt = cnt;
+        p = page_address(bv->bv_page) + off;
+        skb_copy_bits(skb, soff, p, fcnt);
+        soff += fcnt;
+        cnt -= fcnt;
+        if (cnt <= 0)
+                return;
+        bv++;
+        off = bv->bv_offset;
+        goto loop;
+}
+
+void
+aoe_end_request(struct aoedev *d, struct request *rq, int fastfail)
+{
+        struct bio *bio;
+        int bok;
+        struct request_queue *q;
+
+        q = d->blkq;
+        if (rq == d->ip.rq)
+                d->ip.rq = NULL;
+        do {
+                bio = rq->bio;
+                bok = !fastfail && test_bit(BIO_UPTODATE, &bio->bi_flags);
+        } while (__blk_end_request(rq, bok ? 0 : -EIO, bio->bi_size));
+
+        /* cf. http://lkml.org/lkml/2006/10/31/28 */
+        if (!fastfail)
+                q->request_fn(q);
+}
+
+static void
+aoe_end_buf(struct aoedev *d, struct buf *buf)
+{
+        struct request *rq;
+        unsigned long n;
+
+        if (buf == d->ip.buf)
+                d->ip.buf = NULL;
+        rq = buf->rq;
+        bio_pagedec(buf->bio);
+        mempool_free(buf, d->bufpool);
+        n = (unsigned long) rq->special;
+        rq->special = (void *) --n;
+        if (n == 0)
+                aoe_end_request(d, rq, 0);
+}
+
+static void
+ktiocomplete(struct frame *f)
 {
-        unsigned long n_sect = bio->bi_size >> 9;
-        const int rw = bio_data_dir(bio);
-        struct hd_struct *part;
-        int cpu;
+        struct aoe_hdr *hin, *hout;
+        struct aoe_atahdr *ahin, *ahout;
+        struct buf *buf;
+        struct sk_buff *skb;
+        struct aoetgt *t;
+        struct aoeif *ifp;
+        struct aoedev *d;
+        long n;
+
+        if (f == NULL)
+                return;
+
+        t = f->t;
+        d = t->d;
+
+        hout = (struct aoe_hdr *) skb_mac_header(f->skb);
+        ahout = (struct aoe_atahdr *) (hout+1);
+        buf = f->buf;
+        skb = f->r_skb;
+        if (skb == NULL)
+                goto noskb;     /* just fail the buf. */
+
+        hin = (struct aoe_hdr *) skb->data;
+        skb_pull(skb, sizeof(*hin));
+        ahin = (struct aoe_atahdr *) skb->data;
+        skb_pull(skb, sizeof(*ahin));
+        if (ahin->cmdstat & 0xa9) {     /* these bits cleared on success */
+                pr_err("aoe: ata error cmd=%2.2Xh stat=%2.2Xh from e%ld.%d\n",
+                        ahout->cmdstat, ahin->cmdstat,
+                        d->aoemajor, d->aoeminor);
+noskb:  if (buf)
+                        clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
+                goto badrsp;
+        }
 
-        cpu = part_stat_lock();
-        part = disk_map_sector_rcu(disk, sector);
+        n = ahout->scnt << 9;
+        switch (ahout->cmdstat) {
+        case ATA_CMD_PIO_READ:
+        case ATA_CMD_PIO_READ_EXT:
+                if (skb->len < n) {
+                        pr_err("aoe: runt data size in read.  skb->len=%d need=%ld\n",
+                                skb->len, n);
+                        clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
+                        break;
+                }
+                bvcpy(f->bv, f->bv_off, skb, n);
+        case ATA_CMD_PIO_WRITE:
+        case ATA_CMD_PIO_WRITE_EXT:
+                spin_lock_irq(&d->lock);
+                ifp = getif(t, skb->dev);
+                if (ifp)
+                        ifp->lost = 0;
+                if (d->htgt == t) /* I'll help myself, thank you. */
+                        d->htgt = NULL;
+                spin_unlock_irq(&d->lock);
+                break;
+        case ATA_CMD_ID_ATA:
+                if (skb->len < 512) {
+                        pr_info("aoe: runt data size in ataid.  skb->len=%d\n",
+                                skb->len);
+                        break;
+                }
+                if (skb_linearize(skb))
+                        break;
+                spin_lock_irq(&d->lock);
+                ataid_complete(d, t, skb->data);
+                spin_unlock_irq(&d->lock);
+                break;
+        default:
+                pr_info("aoe: unrecognized ata command %2.2Xh for %d.%d\n",
+                        ahout->cmdstat,
+                        be16_to_cpu(get_unaligned(&hin->major)),
+                        hin->minor);
+        }
+badrsp:
+        spin_lock_irq(&d->lock);
+
+        aoe_freetframe(f);
+
+        if (buf && --buf->nframesout == 0 && buf->resid == 0)
+                aoe_end_buf(d, buf);
+
+        aoecmd_work(d);
+
+        spin_unlock_irq(&d->lock);
+        aoedev_put(d);
+        dev_kfree_skb(skb);
+}
+
+/* Enters with iocq.lock held.
+ * Returns true iff responses needing processing remain.
+ */
+static int
+ktio(void)
+{
+        struct frame *f;
+        struct list_head *pos;
+        int i;
 
-        part_stat_inc(cpu, part, ios[rw]);
-        part_stat_add(cpu, part, ticks[rw], duration);
-        part_stat_add(cpu, part, sectors[rw], n_sect);
-        part_stat_add(cpu, part, io_ticks, duration);
+        for (i = 0; ; ++i) {
+                if (i == MAXIOC)
+                        return 1;
+                if (list_empty(&iocq.head))
+                        return 0;
+                pos = iocq.head.next;
+                list_del(pos);
+                spin_unlock_irq(&iocq.lock);
+                f = list_entry(pos, struct frame, head);
+                ktiocomplete(f);
+                spin_lock_irq(&iocq.lock);
+        }
+}
 
-        part_stat_unlock();
+static int
+kthread(void *vp)
+{
+        struct ktstate *k;
+        DECLARE_WAITQUEUE(wait, current);
+        int more;
+
+        k = vp;
+        current->flags |= PF_NOFREEZE;
+        set_user_nice(current, -10);
+        complete(&k->rendez);   /* tell spawner we're running */
+        do {
+                spin_lock_irq(k->lock);
+                more = k->fn();
+                if (!more) {
+                        add_wait_queue(k->waitq, &wait);
+                        __set_current_state(TASK_INTERRUPTIBLE);
+                }
+                spin_unlock_irq(k->lock);
+                if (!more) {
+                        schedule();
+                        remove_wait_queue(k->waitq, &wait);
+                } else
+                        cond_resched();
+        } while (!kthread_should_stop());
+        complete(&k->rendez);   /* tell spawner we're stopping */
+        return 0;
 }
 
 void
+aoe_ktstop(struct ktstate *k)
+{
+        kthread_stop(k->task);
+        wait_for_completion(&k->rendez);
+}
+
+int
+aoe_ktstart(struct ktstate *k)
+{
+        struct task_struct *task;
+
+        init_completion(&k->rendez);
+        task = kthread_run(kthread, k, k->name);
+        if (task == NULL || IS_ERR(task))
+                return -ENOMEM;
+        k->task = task;
+        wait_for_completion(&k->rendez); /* allow kthread to start */
+        init_completion(&k->rendez);    /* for waiting for exit later */
+        return 0;
+}
+
+/* pass it off to kthreads for processing */
+static void
+ktcomplete(struct frame *f, struct sk_buff *skb)
+{
+        ulong flags;
+
+        f->r_skb = skb;
+        spin_lock_irqsave(&iocq.lock, flags);
+        list_add_tail(&f->head, &iocq.head);
+        spin_unlock_irqrestore(&iocq.lock, flags);
+        wake_up(&ktiowq);
+}
+
+struct sk_buff *
 aoecmd_ata_rsp(struct sk_buff *skb)
 {
-        struct sk_buff_head queue;
         struct aoedev *d;
-        struct aoe_hdr *hin, *hout;
-        struct aoe_atahdr *ahin, *ahout;
+        struct aoe_hdr *h;
         struct frame *f;
-        struct buf *buf;
         struct aoetgt *t;
-        struct aoeif *ifp;
-        register long n;
+        u32 n;
         ulong flags;
         char ebuf[128];
         u16 aoemajor;
 
-        hin = (struct aoe_hdr *) skb_mac_header(skb);
-        aoemajor = get_unaligned_be16(&hin->major);
-        d = aoedev_by_aoeaddr(aoemajor, hin->minor);
+        h = (struct aoe_hdr *) skb->data;
+        aoemajor = be16_to_cpu(get_unaligned(&h->major));
+        d = aoedev_by_aoeaddr(aoemajor, h->minor, 0);
         if (d == NULL) {
                 snprintf(ebuf, sizeof ebuf, "aoecmd_ata_rsp: ata response "
                         "for unknown device %d.%d\n",
-                         aoemajor, hin->minor);
+                        aoemajor, h->minor);
                 aoechr_error(ebuf);
-                return;
+                return skb;
         }
 
         spin_lock_irqsave(&d->lock, flags);
 
-        n = get_unaligned_be32(&hin->tag);
-        t = gettgt(d, hin->src);
-        if (t == NULL) {
-                printk(KERN_INFO "aoe: can't find target e%ld.%d:%pm\n",
-                        d->aoemajor, d->aoeminor, hin->src);
-                spin_unlock_irqrestore(&d->lock, flags);
-                return;
-        }
-        f = getframe(t, n);
+        n = be32_to_cpu(get_unaligned(&h->tag));
+        f = getframe(d, n);
         if (f == NULL) {
                 calc_rttavg(d, -tsince(n));
                 spin_unlock_irqrestore(&d->lock, flags);
+                aoedev_put(d);
                 snprintf(ebuf, sizeof ebuf,
                         "%15s e%d.%d    tag=%08x@%08lx\n",
                         "unexpected rsp",
-                        get_unaligned_be16(&hin->major),
-                        hin->minor,
-                        get_unaligned_be32(&hin->tag),
+                        get_unaligned_be16(&h->major),
+                        h->minor,
+                        get_unaligned_be32(&h->tag),
                         jiffies);
                 aoechr_error(ebuf);
-                return;
+                return skb;
         }
-
+        t = f->t;
         calc_rttavg(d, tsince(f->tag));
-
-        ahin = (struct aoe_atahdr *) (hin+1);
-        hout = (struct aoe_hdr *) skb_mac_header(f->skb);
-        ahout = (struct aoe_atahdr *) (hout+1);
-        buf = f->buf;
-
-        if (ahin->cmdstat & 0xa9) {     /* these bits cleared on success */
-                printk(KERN_ERR
-                        "aoe: ata error cmd=%2.2Xh stat=%2.2Xh from e%ld.%d\n",
-                        ahout->cmdstat, ahin->cmdstat,
-                        d->aoemajor, d->aoeminor);
-                if (buf)
-                        buf->flags |= BUFFL_FAIL;
-        } else {
-                if (d->htgt && t == *d->htgt) /* I'll help myself, thank you. */
-                        d->htgt = NULL;
-                n = ahout->scnt << 9;
-                switch (ahout->cmdstat) {
-                case ATA_CMD_PIO_READ:
-                case ATA_CMD_PIO_READ_EXT:
-                        if (skb->len - sizeof *hin - sizeof *ahin < n) {
-                                printk(KERN_ERR
-                                        "aoe: %s.  skb->len=%d need=%ld\n",
-                                        "runt data size in read", skb->len, n);
-                                /* fail frame f?  just returning will rexmit. */
-                                spin_unlock_irqrestore(&d->lock, flags);
-                                return;
-                        }
-                        memcpy(f->bufaddr, ahin+1, n);
-                case ATA_CMD_PIO_WRITE:
-                case ATA_CMD_PIO_WRITE_EXT:
-                        ifp = getif(t, skb->dev);
-                        if (ifp) {
-                                ifp->lost = 0;
-                                if (n > DEFAULTBCNT)
-                                        ifp->lostjumbo = 0;
-                        }
-                        if (f->bcnt -= n) {
-                                f->lba += n >> 9;
-                                f->bufaddr += n;
-                                resend(d, t, f);
-                                goto xmit;
-                        }
-                        break;
-                case ATA_CMD_ID_ATA:
-                        if (skb->len - sizeof *hin - sizeof *ahin < 512) {
-                                printk(KERN_INFO
-                                        "aoe: runt data size in ataid.  skb->len=%d\n",
-                                        skb->len);
-                                spin_unlock_irqrestore(&d->lock, flags);
-                                return;
-                        }
-                        ataid_complete(d, t, (char *) (ahin+1));
-                        break;
-                default:
-                        printk(KERN_INFO
-                                "aoe: unrecognized ata command %2.2Xh for %d.%d\n",
-                                ahout->cmdstat,
-                                get_unaligned_be16(&hin->major),
-                                hin->minor);
-                }
-        }
-
-        if (buf && --buf->nframesout == 0 && buf->resid == 0) {
-                diskstats(d->gd, buf->bio, jiffies - buf->stime, buf->sector);
-                if (buf->flags & BUFFL_FAIL)
-                        bio_endio(buf->bio, -EIO);
-                else {
-                        bio_flush_dcache_pages(buf->bio);
-                        bio_endio(buf->bio, 0);
-                }
-                mempool_free(buf, d->bufpool);
-        }
-
-        f->buf = NULL;
-        f->tag = FREETAG;
         t->nout--;
-
         aoecmd_work(d);
-xmit:
-        __skb_queue_head_init(&queue);
-        skb_queue_splice_init(&d->sendq, &queue);
 
         spin_unlock_irqrestore(&d->lock, flags);
-        aoenet_xmit(&queue);
+
+        ktcomplete(f, skb);
+
+        /*
+         * Note here that we do not perform an aoedev_put, as we are
+         * leaving this reference for the ktio to release.
+         */
+        return NULL;
 }
 
 void
@@ -896,7 +1211,7 @@ aoecmd_ata_id(struct aoedev *d)
         struct sk_buff *skb;
         struct aoetgt *t;
 
-        f = freeframe(d);
+        f = newframe(d);
         if (f == NULL)
                 return NULL;
 
@@ -909,6 +1224,7 @@ aoecmd_ata_id(struct aoedev *d)
         skb_put(skb, sizeof *h + sizeof *ah);
         memset(h, 0, skb->len);
         f->tag = aoehdr_atainit(d, t, h);
+        fhash(f);
         t->nout++;
         f->waited = 0;
 
@@ -929,7 +1245,6 @@ static struct aoetgt *
 addtgt(struct aoedev *d, char *addr, ulong nframes)
 {
         struct aoetgt *t, **tt, **te;
-        struct frame *f, *e;
 
         tt = d->targets;
         te = tt + NTARGETS;
@@ -941,26 +1256,73 @@ addtgt(struct aoedev *d, char *addr, ulong nframes)
                         "aoe: device addtgt failure; too many targets\n");
                 return NULL;
         }
-        t = kcalloc(1, sizeof *t, GFP_ATOMIC);
-        f = kcalloc(nframes, sizeof *f, GFP_ATOMIC);
-        if (!t || !f) {
-                kfree(f);
-                kfree(t);
+        t = kzalloc(sizeof(*t), GFP_ATOMIC);
+        if (!t) {
                 printk(KERN_INFO "aoe: cannot allocate memory to add target\n");
                 return NULL;
         }
 
+        d->ntargets++;
         t->nframes = nframes;
-        t->frames = f;
-        e = f + nframes;
-        for (; f < e; f++)
-                f->tag = FREETAG;
+        t->d = d;
         memcpy(t->addr, addr, sizeof t->addr);
         t->ifp = t->ifs;
         t->maxout = t->nframes;
+        INIT_LIST_HEAD(&t->ffree);
         return *tt = t;
 }
 
+static void
+setdbcnt(struct aoedev *d)
+{
+        struct aoetgt **t, **e;
+        int bcnt = 0;
+
+        t = d->targets;
+        e = t + NTARGETS;
+        for (; t < e && *t; t++)
+                if (bcnt == 0 || bcnt > (*t)->minbcnt)
+                        bcnt = (*t)->minbcnt;
+        if (bcnt != d->maxbcnt) {
+                d->maxbcnt = bcnt;
+                pr_info("aoe: e%ld.%d: setting %d byte data frames\n",
+                        d->aoemajor, d->aoeminor, bcnt);
+        }
+}
+
+static void
+setifbcnt(struct aoetgt *t, struct net_device *nd, int bcnt)
+{
+        struct aoedev *d;
+        struct aoeif *p, *e;
+        int minbcnt;
+
+        d = t->d;
+        minbcnt = bcnt;
+        p = t->ifs;
+        e = p + NAOEIFS;
+        for (; p < e; p++) {
+                if (p->nd == NULL)
+                        break;          /* end of the valid interfaces */
+                if (p->nd == nd) {
+                        p->bcnt = bcnt; /* we're updating */
+                        nd = NULL;
+                } else if (minbcnt > p->bcnt)
+                        minbcnt = p->bcnt; /* find the min interface */
+        }
+        if (nd) {
+                if (p == e) {
+                        pr_err("aoe: device setifbcnt failure; too many interfaces.\n");
+                        return;
+                }
+                dev_hold(nd);
+                p->nd = nd;
+                p->bcnt = bcnt;
+        }
+        t->minbcnt = minbcnt;
+        setdbcnt(d);
+}
+
 void
 aoecmd_cfg_rsp(struct sk_buff *skb)
 {
@@ -968,11 +1330,12 @@ aoecmd_cfg_rsp(struct sk_buff *skb)
         struct aoe_hdr *h;
         struct aoe_cfghdr *ch;
         struct aoetgt *t;
-        struct aoeif *ifp;
-        ulong flags, sysminor, aoemajor;
+        ulong flags, aoemajor;
         struct sk_buff *sl;
+        struct sk_buff_head queue;
         u16 n;
 
+        sl = NULL;
         h = (struct aoe_hdr *) skb_mac_header(skb);
         ch = (struct aoe_cfghdr *) (h+1);
 
@@ -986,10 +1349,13 @@ aoecmd_cfg_rsp(struct sk_buff *skb)
                         "Check shelf dip switches.\n");
                 return;
         }
-
-        sysminor = SYSMINOR(aoemajor, h->minor);
-        if (sysminor * AOE_PARTITIONS + AOE_PARTITIONS > MINORMASK) {
-                printk(KERN_INFO "aoe: e%ld.%d: minor number too large\n",
+        if (aoemajor == 0xffff) {
+                pr_info("aoe: e%ld.%d: broadcast shelf number invalid\n",
+                        aoemajor, (int) h->minor);
+                return;
+        }
+        if (h->minor == 0xff) {
+                pr_info("aoe: e%ld.%d: broadcast slot number invalid\n",
                         aoemajor, (int) h->minor);
                 return;
         }
@@ -998,9 +1364,9 @@ aoecmd_cfg_rsp(struct sk_buff *skb)
         if (n > aoe_maxout)     /* keep it reasonable */
                 n = aoe_maxout;
 
-        d = aoedev_by_sysminor_m(sysminor);
+        d = aoedev_by_aoeaddr(aoemajor, h->minor, 1);
         if (d == NULL) {
-                printk(KERN_INFO "aoe: device sysminor_m failure\n");
+                pr_info("aoe: device allocation failure\n");
                 return;
         }
 
@@ -1009,52 +1375,26 @@ aoecmd_cfg_rsp(struct sk_buff *skb)
         t = gettgt(d, h->src);
         if (!t) {
                 t = addtgt(d, h->src, n);
-                if (!t) {
-                        spin_unlock_irqrestore(&d->lock, flags);
-                        return;
-                }
-        }
-        ifp = getif(t, skb->dev);
-        if (!ifp) {
-                ifp = addif(t, skb->dev);
-                if (!ifp) {
-                        printk(KERN_INFO
-                                "aoe: device addif failure; "
-                                "too many interfaces?\n");
-                        spin_unlock_irqrestore(&d->lock, flags);
-                        return;
-                }
-        }
-        if (ifp->maxbcnt) {
-                n = ifp->nd->mtu;
-                n -= sizeof (struct aoe_hdr) + sizeof (struct aoe_atahdr);
-                n /= 512;
-                if (n > ch->scnt)
-                        n = ch->scnt;
-                n = n ? n * 512 : DEFAULTBCNT;
-                if (n != ifp->maxbcnt) {
-                        printk(KERN_INFO
-                                "aoe: e%ld.%d: setting %d%s%s:%pm\n",
-                                d->aoemajor, d->aoeminor, n,
-                                " byte data frames on ", ifp->nd->name,
-                                t->addr);
-                        ifp->maxbcnt = n;
-                }
+                if (!t)
+                        goto bail;
         }
+        n = skb->dev->mtu;
+        n -= sizeof(struct aoe_hdr) + sizeof(struct aoe_atahdr);
+        n /= 512;
+        if (n > ch->scnt)
+                n = ch->scnt;
+        n = n ? n * 512 : DEFAULTBCNT;
+        setifbcnt(t, skb->dev, n);
 
         /* don't change users' perspective */
-        if (d->nopen) {
-                spin_unlock_irqrestore(&d->lock, flags);
-                return;
+        if (d->nopen == 0) {
+                d->fw_ver = be16_to_cpu(ch->fwver);
+                sl = aoecmd_ata_id(d);
         }
-        d->fw_ver = be16_to_cpu(ch->fwver);
-
-        sl = aoecmd_ata_id(d);
-
+bail:
         spin_unlock_irqrestore(&d->lock, flags);
-
+        aoedev_put(d);
         if (sl) {
-                struct sk_buff_head queue;
                 __skb_queue_head_init(&queue);
                 __skb_queue_tail(&queue, sl);
                 aoenet_xmit(&queue);
@@ -1065,20 +1405,74 @@ void
 aoecmd_cleanslate(struct aoedev *d)
 {
         struct aoetgt **t, **te;
-        struct aoeif *p, *e;
 
         d->mintimer = MINTIMER;
+        d->maxbcnt = 0;
 
         t = d->targets;
         te = t + NTARGETS;
-        for (; t < te && *t; t++) {
+        for (; t < te && *t; t++)
                 (*t)->maxout = (*t)->nframes;
-                p = (*t)->ifs;
-                e = p + NAOEIFS;
-                for (; p < e; p++) {
-                        p->lostjumbo = 0;
-                        p->lost = 0;
-                        p->maxbcnt = DEFAULTBCNT;
+}
+
+void
+aoe_failbuf(struct aoedev *d, struct buf *buf)
+{
+        if (buf == NULL)
+                return;
+        buf->resid = 0;
+        clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
+        if (buf->nframesout == 0)
+                aoe_end_buf(d, buf);
+}
+
+void
+aoe_flush_iocq(void)
+{
+        struct frame *f;
+        struct aoedev *d;
+        LIST_HEAD(flist);
+        struct list_head *pos;
+        struct sk_buff *skb;
+        ulong flags;
+
+        spin_lock_irqsave(&iocq.lock, flags);
+        list_splice_init(&iocq.head, &flist);
+        spin_unlock_irqrestore(&iocq.lock, flags);
+        while (!list_empty(&flist)) {
+                pos = flist.next;
+                list_del(pos);
+                f = list_entry(pos, struct frame, head);
+                d = f->t->d;
+                skb = f->r_skb;
+                spin_lock_irqsave(&d->lock, flags);
+                if (f->buf) {
+                        f->buf->nframesout--;
+                        aoe_failbuf(d, f->buf);
                 }
+                aoe_freetframe(f);
+                spin_unlock_irqrestore(&d->lock, flags);
+                dev_kfree_skb(skb);
+                aoedev_put(d);
         }
 }
+
+int __init
+aoecmd_init(void)
+{
+        INIT_LIST_HEAD(&iocq.head);
+        spin_lock_init(&iocq.lock);
+        init_waitqueue_head(&ktiowq);
+        kts.name = "aoe_ktio";
+        kts.fn = ktio;
+        kts.waitq = &ktiowq;
+        kts.lock = &iocq.lock;
+        return aoe_ktstart(&kts);
+}
+
+void
+aoecmd_exit(void)
+{
+        aoe_ktstop(&kts);
+        aoe_flush_iocq();
+}
diff --git a/drivers/block/aoe/aoedev.c b/drivers/block/aoe/aoedev.c
index 6b5110a47458..90e5b537f94b 100644
--- a/drivers/block/aoe/aoedev.c
+++ b/drivers/block/aoe/aoedev.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007 Coraid, Inc.  See COPYING for GPL terms. */
+/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
 /*
  * aoedev.c
  * AoE device utility functions; maintains device list.
@@ -9,6 +9,9 @@
 #include <linux/netdevice.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
+#include <linux/bitmap.h>
+#include <linux/kdev_t.h>
+#include <linux/moduleparam.h>
 #include "aoe.h"
 
 static void dummy_timer(ulong);
@@ -16,23 +19,121 @@ static void aoedev_freedev(struct aoedev *);
 static void freetgt(struct aoedev *d, struct aoetgt *t);
 static void skbpoolfree(struct aoedev *d);
 
+static int aoe_dyndevs = 1;
+module_param(aoe_dyndevs, int, 0644);
+MODULE_PARM_DESC(aoe_dyndevs, "Use dynamic minor numbers for devices.");
+
 static struct aoedev *devlist;
 static DEFINE_SPINLOCK(devlist_lock);
 
-struct aoedev *
-aoedev_by_aoeaddr(int maj, int min)
+/* Because some systems will have one, many, or no
+ *   - partitions,
+ *   - slots per shelf,
+ *   - or shelves,
+ * we need some flexibility in the way the minor numbers
+ * are allocated.  So they are dynamic.
+ */
+#define N_DEVS ((1U<<MINORBITS)/AOE_PARTITIONS)
+
+static DEFINE_SPINLOCK(used_minors_lock);
+static DECLARE_BITMAP(used_minors, N_DEVS);
+
+static int
+minor_get_dyn(ulong *sysminor)
 {
-        struct aoedev *d;
         ulong flags;
+        ulong n;
+        int error = 0;
+
+        spin_lock_irqsave(&used_minors_lock, flags);
+        n = find_first_zero_bit(used_minors, N_DEVS);
+        if (n < N_DEVS)
+                set_bit(n, used_minors);
+        else
+                error = -1;
+        spin_unlock_irqrestore(&used_minors_lock, flags);
+
+        *sysminor = n * AOE_PARTITIONS;
+        return error;
+}
 
-        spin_lock_irqsave(&devlist_lock, flags);
+static int
+minor_get_static(ulong *sysminor, ulong aoemaj, int aoemin)
+{
+        ulong flags;
+        ulong n;
+        int error = 0;
+        enum {
+                /* for backwards compatibility when !aoe_dyndevs,
+                 * a static number of supported slots per shelf */
+                NPERSHELF = 16,
+        };
+
+        n = aoemaj * NPERSHELF + aoemin;
+        if (aoemin >= NPERSHELF || n >= N_DEVS) {
+                pr_err("aoe: %s with e%ld.%d\n",
+                        "cannot use static minor device numbers",
+                        aoemaj, aoemin);
+                error = -1;
+        } else {
+                spin_lock_irqsave(&used_minors_lock, flags);
+                if (test_bit(n, used_minors)) {
+                        pr_err("aoe: %s %lu\n",
+                                "existing device already has static minor number",
+                                n);
+                        error = -1;
+                } else
+                        set_bit(n, used_minors);
+                spin_unlock_irqrestore(&used_minors_lock, flags);
+        }
 
-        for (d=devlist; d; d=d->next)
-                if (d->aoemajor == maj && d->aoeminor == min)
-                        break;
+        *sysminor = n;
+        return error;
+}
+
+static int
+minor_get(ulong *sysminor, ulong aoemaj, int aoemin)
+{
+        if (aoe_dyndevs)
+                return minor_get_dyn(sysminor);
+        else
+                return minor_get_static(sysminor, aoemaj, aoemin);
+}
+
+static void
+minor_free(ulong minor)
+{
+        ulong flags;
+
+        minor /= AOE_PARTITIONS;
+        BUG_ON(minor >= N_DEVS);
+
+        spin_lock_irqsave(&used_minors_lock, flags);
+        BUG_ON(!test_bit(minor, used_minors));
+        clear_bit(minor, used_minors);
+        spin_unlock_irqrestore(&used_minors_lock, flags);
+}
+
+/*
+ * Users who grab a pointer to the device with aoedev_by_aoeaddr
+ * automatically get a reference count and must be responsible
+ * for performing a aoedev_put.  With the addition of async
+ * kthread processing I'm no longer confident that we can
+ * guarantee consistency in the face of device flushes.
+ *
+ * For the time being, we only bother to add extra references for
+ * frames sitting on the iocq.  When the kthreads finish processing
+ * these frames, they will aoedev_put the device.
+ */
+
+void
+aoedev_put(struct aoedev *d)
+{
+        ulong flags;
 
+        spin_lock_irqsave(&devlist_lock, flags);
+        d->ref--;
         spin_unlock_irqrestore(&devlist_lock, flags);
-        return d;
 }
 
 static void
@@ -47,54 +148,74 @@ dummy_timer(ulong vp)
         add_timer(&d->timer);
 }
 
+static void
+aoe_failip(struct aoedev *d)
+{
+        struct request *rq;
+        struct bio *bio;
+        unsigned long n;
+
+        aoe_failbuf(d, d->ip.buf);
+
+        rq = d->ip.rq;
+        if (rq == NULL)
+                return;
+        while ((bio = d->ip.nxbio)) {
+                clear_bit(BIO_UPTODATE, &bio->bi_flags);
+                d->ip.nxbio = bio->bi_next;
+                n = (unsigned long) rq->special;
+                rq->special = (void *) --n;
+        }
+        if ((unsigned long) rq->special == 0)
+                aoe_end_request(d, rq, 0);
+}
+
 void
 aoedev_downdev(struct aoedev *d)
 {
-        struct aoetgt **t, **te;
-        struct frame *f, *e;
-        struct buf *buf;
-        struct bio *bio;
+        struct aoetgt *t, **tt, **te;
+        struct frame *f;
+        struct list_head *head, *pos, *nx;
+        struct request *rq;
+        int i;
 
-        t = d->targets;
-        te = t + NTARGETS;
-        for (; t < te && *t; t++) {
-                f = (*t)->frames;
-                e = f + (*t)->nframes;
-                for (; f < e; f->tag = FREETAG, f->buf = NULL, f++) {
-                        if (f->tag == FREETAG || f->buf == NULL)
-                                continue;
-                        buf = f->buf;
-                        bio = buf->bio;
-                        if (--buf->nframesout == 0
-                        && buf != d->inprocess) {
-                                mempool_free(buf, d->bufpool);
-                                bio_endio(bio, -EIO);
+        d->flags &= ~DEVFL_UP;
+
+        /* clean out active buffers */
+        for (i = 0; i < NFACTIVE; i++) {
+                head = &d->factive[i];
+                list_for_each_safe(pos, nx, head) {
+                        f = list_entry(pos, struct frame, head);
+                        list_del(pos);
+                        if (f->buf) {
+                                f->buf->nframesout--;
+                                aoe_failbuf(d, f->buf);
                         }
+                        aoe_freetframe(f);
                 }
-                (*t)->maxout = (*t)->nframes;
-                (*t)->nout = 0;
         }
-        buf = d->inprocess;
-        if (buf) {
-                bio = buf->bio;
-                mempool_free(buf, d->bufpool);
-                bio_endio(bio, -EIO);
+        /* reset window dressings */
+        tt = d->targets;
+        te = tt + NTARGETS;
+        for (; tt < te && (t = *tt); tt++) {
+                t->maxout = t->nframes;
+                t->nout = 0;
         }
-        d->inprocess = NULL;
+
+        /* clean out the in-process request (if any) */
+        aoe_failip(d);
         d->htgt = NULL;
 
-        while (!list_empty(&d->bufq)) {
-                buf = container_of(d->bufq.next, struct buf, bufs);
-                list_del(d->bufq.next);
-                bio = buf->bio;
-                mempool_free(buf, d->bufpool);
-                bio_endio(bio, -EIO);
+        /* fast fail all pending I/O */
+        if (d->blkq) {
+                while ((rq = blk_peek_request(d->blkq))) {
+                        blk_start_request(rq);
+                        aoe_end_request(d, rq, 1);
+                }
         }
 
         if (d->gd)
                 set_capacity(d->gd, 0);
-
-        d->flags &= ~DEVFL_UP;
 }
 
 static void
@@ -107,6 +228,7 @@ aoedev_freedev(struct aoedev *d)
                 aoedisk_rm_sysfs(d);
                 del_gendisk(d->gd);
                 put_disk(d->gd);
+                blk_cleanup_queue(d->blkq);
         }
         t = d->targets;
         e = t + NTARGETS;
@@ -115,7 +237,7 @@ aoedev_freedev(struct aoedev *d)
         if (d->bufpool)
                 mempool_destroy(d->bufpool);
         skbpoolfree(d);
-        blk_cleanup_queue(d->blkq);
+        minor_free(d->sysminor);
         kfree(d);
 }
 
@@ -142,7 +264,8 @@ aoedev_flush(const char __user *str, size_t cnt)
                 spin_lock(&d->lock);
                 if ((!all && (d->flags & DEVFL_UP))
                 || (d->flags & (DEVFL_GDALLOC|DEVFL_NEWSIZE))
-                || d->nopen) {
+                || d->nopen
+                || d->ref) {
                         spin_unlock(&d->lock);
                         dd = &d->next;
                         continue;
@@ -163,12 +286,15 @@ aoedev_flush(const char __user *str, size_t cnt)
         return 0;
 }
 
-/* I'm not really sure that this is a realistic problem, but if the
-network driver goes gonzo let's just leak memory after complaining. */
+/* This has been confirmed to occur once with Tms=3*1000 due to the
+ * driver changing link and not processing its transmit ring.  The
+ * problem is hard enough to solve by returning an error that I'm
+ * still punting on "solving" this.
+ */
 static void
 skbfree(struct sk_buff *skb)
 {
-        enum { Sms = 100, Tms = 3*1000};
+        enum { Sms = 250, Tms = 30 * 1000};
         int i = Tms / Sms;
 
         if (skb == NULL)
@@ -182,6 +308,7 @@ skbfree(struct sk_buff *skb)
                         "cannot free skb -- memory leaked.");
                 return;
         }
+        skb->truesize -= skb->data_len;
         skb_shinfo(skb)->nr_frags = skb->data_len = 0;
         skb_trim(skb, 0);
         dev_kfree_skb(skb);
@@ -198,26 +325,29 @@ skbpoolfree(struct aoedev *d)
         __skb_queue_head_init(&d->skbpool);
 }
 
-/* find it or malloc it */
+/* find it or allocate it */
 struct aoedev *
-aoedev_by_sysminor_m(ulong sysminor)
+aoedev_by_aoeaddr(ulong maj, int min, int do_alloc)
 {
         struct aoedev *d;
+        int i;
         ulong flags;
+        ulong sysminor;
 
         spin_lock_irqsave(&devlist_lock, flags);
 
         for (d=devlist; d; d=d->next)
-                if (d->sysminor == sysminor)
+                if (d->aoemajor == maj && d->aoeminor == min) {
+                        d->ref++;
                         break;
-        if (d)
+                }
+        if (d || !do_alloc || minor_get(&sysminor, maj, min) < 0)
                 goto out;
         d = kcalloc(1, sizeof *d, GFP_ATOMIC);
         if (!d)
                 goto out;
         INIT_WORK(&d->work, aoecmd_sleepwork);
         spin_lock_init(&d->lock);
-        skb_queue_head_init(&d->sendq);
         skb_queue_head_init(&d->skbpool);
         init_timer(&d->timer);
         d->timer.data = (ulong) d;
@@ -226,10 +356,12 @@ aoedev_by_sysminor_m(ulong sysminor)
         add_timer(&d->timer);
         d->bufpool = NULL;      /* defer to aoeblk_gdalloc */
         d->tgt = d->targets;
-        INIT_LIST_HEAD(&d->bufq);
+        d->ref = 1;
+        for (i = 0; i < NFACTIVE; i++)
+                INIT_LIST_HEAD(&d->factive[i]);
         d->sysminor = sysminor;
-        d->aoemajor = AOEMAJOR(sysminor);
-        d->aoeminor = AOEMINOR(sysminor);
+        d->aoemajor = maj;
+        d->aoeminor = min;
         d->mintimer = MINTIMER;
         d->next = devlist;
         devlist = d;
@@ -241,13 +373,23 @@ aoedev_by_sysminor_m(ulong sysminor)
 static void
 freetgt(struct aoedev *d, struct aoetgt *t)
 {
-        struct frame *f, *e;
+        struct frame *f;
+        struct list_head *pos, *nx, *head;
+        struct aoeif *ifp;
 
-        f = t->frames;
-        e = f + t->nframes;
-        for (; f < e; f++)
+        for (ifp = t->ifs; ifp < &t->ifs[NAOEIFS]; ++ifp) {
+                if (!ifp->nd)
+                        break;
+                dev_put(ifp->nd);
+        }
+
+        head = &t->ffree;
+        list_for_each_safe(pos, nx, head) {
+                list_del(pos);
+                f = list_entry(pos, struct frame, head);
                 skbfree(f->skb);
-        kfree(t->frames);
+                kfree(f);
+        }
         kfree(t);
 }
 
@@ -257,6 +399,7 @@ aoedev_exit(void)
         struct aoedev *d;
         ulong flags;
 
+        aoe_flush_iocq();
         while ((d = devlist)) {
                 devlist = d->next;
 
diff --git a/drivers/block/aoe/aoemain.c b/drivers/block/aoe/aoemain.c
index 7f83ad90e76f..04793c2c701b 100644
--- a/drivers/block/aoe/aoemain.c
+++ b/drivers/block/aoe/aoemain.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007 Coraid, Inc.  See COPYING for GPL terms. */
+/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
 /*
  * aoemain.c
  * Module initialization routines, discover timer
@@ -61,6 +61,7 @@ aoe_exit(void)
 
         aoenet_exit();
         unregister_blkdev(AOE_MAJOR, DEVICE_NAME);
+        aoecmd_exit();
         aoechr_exit();
         aoedev_exit();
         aoeblk_exit();          /* free cache after de-allocating bufs */
@@ -83,17 +84,20 @@ aoe_init(void)
         ret = aoenet_init();
         if (ret)
                 goto net_fail;
+        ret = aoecmd_init();
+        if (ret)
+                goto cmd_fail;
         ret = register_blkdev(AOE_MAJOR, DEVICE_NAME);
         if (ret < 0) {
                 printk(KERN_ERR "aoe: can't register major\n");
                 goto blkreg_fail;
         }
-
         printk(KERN_INFO "aoe: AoE v%s initialised.\n", VERSION);
         discover_timer(TINIT);
         return 0;
-
  blkreg_fail:
+        aoecmd_exit();
+ cmd_fail:
         aoenet_exit();
  net_fail:
         aoeblk_exit();
diff --git a/drivers/block/aoe/aoenet.c b/drivers/block/aoe/aoenet.c
index 4d3bc0d49df5..162c6471275c 100644
--- a/drivers/block/aoe/aoenet.c
+++ b/drivers/block/aoe/aoenet.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007 Coraid, Inc.  See COPYING for GPL terms. */
+/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
 /*
  * aoenet.c
  * Ethernet portion of AoE driver
@@ -33,6 +33,9 @@ static char aoe_iflist[IFLISTSZ];
 module_param_string(aoe_iflist, aoe_iflist, IFLISTSZ, 0600);
 MODULE_PARM_DESC(aoe_iflist, "aoe_iflist=\"dev1 [dev2 ...]\"");
 
+static wait_queue_head_t txwq;
+static struct ktstate kts;
+
 #ifndef MODULE
 static int __init aoe_iflist_setup(char *str)
 {
@@ -44,6 +47,23 @@ static int __init aoe_iflist_setup(char *str)
 __setup("aoe_iflist=", aoe_iflist_setup);
 #endif
 
+static spinlock_t txlock;
+static struct sk_buff_head skbtxq;
+
+/* enters with txlock held */
+static int
+tx(void)
+{
+        struct sk_buff *skb;
+
+        while ((skb = skb_dequeue(&skbtxq))) {
+                spin_unlock_irq(&txlock);
+                dev_queue_xmit(skb);
+                spin_lock_irq(&txlock);
+        }
+        return 0;
+}
+
 int
 is_aoe_netif(struct net_device *ifp)
 {
@@ -88,10 +108,14 @@ void
 aoenet_xmit(struct sk_buff_head *queue)
 {
         struct sk_buff *skb, *tmp;
+        ulong flags;
 
         skb_queue_walk_safe(queue, skb, tmp) {
                 __skb_unlink(skb, queue);
-                dev_queue_xmit(skb);
+                spin_lock_irqsave(&txlock, flags);
+                skb_queue_tail(&skbtxq, skb);
+                spin_unlock_irqrestore(&txlock, flags);
+                wake_up(&txwq);
         }
 }
 
@@ -102,7 +126,9 @@ static int
 aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt, struct net_device *orig_dev)
 {
         struct aoe_hdr *h;
+        struct aoe_atahdr *ah;
         u32 n;
+        int sn;
 
         if (dev_net(ifp) != &init_net)
                 goto exit;
@@ -110,13 +136,16 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt,
         skb = skb_share_check(skb, GFP_ATOMIC);
         if (skb == NULL)
                 return 0;
-        if (skb_linearize(skb))
-                goto exit;
         if (!is_aoe_netif(ifp))
                 goto exit;
         skb_push(skb, ETH_HLEN);        /* (1) */
-
-        h = (struct aoe_hdr *) skb_mac_header(skb);
+        sn = sizeof(*h) + sizeof(*ah);
+        if (skb->len >= sn) {
+                sn -= skb_headlen(skb);
+                if (sn > 0 && !__pskb_pull_tail(skb, sn))
+                        goto exit;
+        }
+        h = (struct aoe_hdr *) skb->data;
         n = get_unaligned_be32(&h->tag);
         if ((h->verfl & AOEFL_RSP) == 0 || (n & 1<<31))
                 goto exit;
@@ -137,7 +166,8 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt,
 
         switch (h->cmd) {
         case AOECMD_ATA:
-                aoecmd_ata_rsp(skb);
+                /* ata_rsp may keep skb for later processing or give it back */
+                skb = aoecmd_ata_rsp(skb);
                 break;
         case AOECMD_CFG:
                 aoecmd_cfg_rsp(skb);
@@ -145,8 +175,12 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt,
         default:
                 if (h->cmd >= AOECMD_VEND_MIN)
                         break;  /* don't complain about vendor commands */
-                printk(KERN_INFO "aoe: unknown cmd %d\n", h->cmd);
+                pr_info("aoe: unknown AoE command type 0x%02x\n", h->cmd);
+                break;
         }
+
+        if (!skb)
+                return 0;
 exit:
         dev_kfree_skb(skb);
         return 0;
@@ -160,6 +194,15 @@ static struct packet_type aoe_pt __read_mostly = {
 int __init
 aoenet_init(void)
 {
+        skb_queue_head_init(&skbtxq);
+        init_waitqueue_head(&txwq);
+        spin_lock_init(&txlock);
+        kts.lock = &txlock;
+        kts.fn = tx;
+        kts.waitq = &txwq;
+        kts.name = "aoe_tx";
+        if (aoe_ktstart(&kts))
+                return -EAGAIN;
         dev_add_pack(&aoe_pt);
         return 0;
 }
@@ -167,6 +210,8 @@ aoenet_init(void)
 void
 aoenet_exit(void)
 {
+        aoe_ktstop(&kts);
+        skb_queue_purge(&skbtxq);
         dev_remove_pack(&aoe_pt);
 }
 
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 0c03411c59eb..043ddcca4abf 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -78,6 +78,8 @@ static const char *ioctl_cmd_to_ascii(int cmd)
         case NBD_SET_SOCK: return "set-sock";
         case NBD_SET_BLKSIZE: return "set-blksize";
         case NBD_SET_SIZE: return "set-size";
+        case NBD_SET_TIMEOUT: return "set-timeout";
+        case NBD_SET_FLAGS: return "set-flags";
         case NBD_DO_IT: return "do-it";
         case NBD_CLEAR_SOCK: return "clear-sock";
         case NBD_CLEAR_QUE: return "clear-que";
@@ -96,6 +98,7 @@ static const char *nbdcmd_to_ascii(int cmd)
         case  NBD_CMD_READ: return "read";
         case NBD_CMD_WRITE: return "write";
         case  NBD_CMD_DISC: return "disconnect";
+        case  NBD_CMD_TRIM: return "trim/discard";
         }
         return "invalid";
 }
@@ -467,8 +470,12 @@ static void nbd_handle_req(struct nbd_device *nbd, struct request *req)
 
         nbd_cmd(req) = NBD_CMD_READ;
         if (rq_data_dir(req) == WRITE) {
-                nbd_cmd(req) = NBD_CMD_WRITE;
-                if (nbd->flags & NBD_READ_ONLY) {
+                if ((req->cmd_flags & REQ_DISCARD)) {
+                        WARN_ON(!(nbd->flags & NBD_FLAG_SEND_TRIM));
+                        nbd_cmd(req) = NBD_CMD_TRIM;
+                } else
+                        nbd_cmd(req) = NBD_CMD_WRITE;
+                if (nbd->flags & NBD_FLAG_READ_ONLY) {
                         dev_err(disk_to_dev(nbd->disk),
                                 "Write on read-only\n");
                         goto error_out;
@@ -651,6 +658,10 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
                 nbd->xmit_timeout = arg * HZ;
                 return 0;
 
+        case NBD_SET_FLAGS:
+                nbd->flags = arg;
+                return 0;
+
         case NBD_SET_SIZE_BLOCKS:
                 nbd->bytesize = ((u64) arg) * nbd->blksize;
                 bdev->bd_inode->i_size = nbd->bytesize;
@@ -670,6 +681,10 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
 
                 mutex_unlock(&nbd->tx_lock);
 
+                if (nbd->flags & NBD_FLAG_SEND_TRIM)
+                        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD,
+                                nbd->disk->queue);
+
                 thread = kthread_create(nbd_thread, nbd, nbd->disk->disk_name);
                 if (IS_ERR(thread)) {
                         mutex_lock(&nbd->tx_lock);
@@ -687,6 +702,7 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
                 nbd->file = NULL;
                 nbd_clear_que(nbd);
                 dev_warn(disk_to_dev(nbd->disk), "queue cleared\n");
+                queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, nbd->disk->queue);
                 if (file)
                         fput(file);
                 nbd->bytesize = 0;
@@ -805,6 +821,9 @@ static int __init nbd_init(void)
                  * Tell the block layer that we are not a rotational device
                  */
                 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, disk->queue);
+                disk->queue->limits.discard_granularity = 512;
+                disk->queue->limits.max_discard_sectors = UINT_MAX;
+                disk->queue->limits.discard_zeroes_data = 0;
         }
 
         if (register_blkdev(NBD_MAJOR, "nbd")) {
diff --git a/drivers/char/mbcs.c b/drivers/char/mbcs.c
index 47ff7e470d87..0c7d340b9ab9 100644
--- a/drivers/char/mbcs.c
+++ b/drivers/char/mbcs.c
@@ -799,7 +799,7 @@ static int mbcs_remove(struct cx_dev *dev)
         return 0;
 }
 
-static const struct cx_device_id __devinitdata mbcs_id_table[] = {
+static const struct cx_device_id __devinitconst mbcs_id_table[] = {
         {
          .part_num = MBCS_PART_NUM,
          .mfg_num = MBCS_MFG_NUM,
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index 3491654cdf7b..a815d44c70a4 100644
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -582,7 +582,7 @@ void dmaengine_get(void)
                                 list_del_rcu(&device->global_node);
                                 break;
                         } else if (err)
-                                pr_err("%s: failed to get %s: (%d)\n",
+                                pr_debug("%s: failed to get %s: (%d)\n",
                                        __func__, dma_chan_name(chan), err);
                 }
         }
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 2091ae8f539a..2421d95130d4 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -982,7 +982,7 @@ int i2c_add_numbered_adapter(struct i2c_adapter *adap)
 
         if (adap->nr == -1) /* -1 means dynamically assign bus id */
                 return i2c_add_adapter(adap);
-        if (adap->nr & ~MAX_ID_MASK)
+        if (adap->nr & ~MAX_IDR_MASK)
                 return -EINVAL;
 
 retry:
diff --git a/drivers/ide/aec62xx.c b/drivers/ide/aec62xx.c
index 57d00caefc86..01451940393b 100644
--- a/drivers/ide/aec62xx.c
+++ b/drivers/ide/aec62xx.c
@@ -181,7 +181,7 @@ static const struct ide_port_ops atp86x_port_ops = {
         .cable_detect           = atp86x_cable_detect,
 };
 
-static const struct ide_port_info aec62xx_chipsets[] __devinitdata = {
+static const struct ide_port_info aec62xx_chipsets[] __devinitconst = {
         {       /* 0: AEC6210 */
                 .name           = DRV_NAME,
                 .init_chipset   = init_chipset_aec62xx,
diff --git a/drivers/ide/ali14xx.c b/drivers/ide/ali14xx.c
index d3be99fb4154..8f3570ee64c3 100644
--- a/drivers/ide/ali14xx.c
+++ b/drivers/ide/ali14xx.c
@@ -52,13 +52,13 @@
 
 /* port addresses for auto-detection */
 #define ALI_NUM_PORTS 4
-static const int ports[ALI_NUM_PORTS] __initdata =
+static const int ports[ALI_NUM_PORTS] __initconst =
         { 0x074, 0x0f4, 0x034, 0x0e4 };
 
 /* register initialization data */
 typedef struct { u8 reg, data; } RegInitializer;
 
-static const RegInitializer initData[] __initdata = {
+static const RegInitializer initData[] __initconst = {
         {0x01, 0x0f}, {0x02, 0x00}, {0x03, 0x00}, {0x04, 0x00},
         {0x05, 0x00}, {0x06, 0x00}, {0x07, 0x2b}, {0x0a, 0x0f},
         {0x25, 0x00}, {0x26, 0x00}, {0x27, 0x00}, {0x28, 0x00},
diff --git a/drivers/ide/alim15x3.c b/drivers/ide/alim15x3.c
index 2c8016ad0e26..911a27ca356b 100644
--- a/drivers/ide/alim15x3.c
+++ b/drivers/ide/alim15x3.c
@@ -512,7 +512,7 @@ static const struct ide_dma_ops ali_dma_ops = {
         .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
-static const struct ide_port_info ali15x3_chipset __devinitdata = {
+static const struct ide_port_info ali15x3_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_chipset   = init_chipset_ali15x3,
         .init_hwif      = init_hwif_ali15x3,
diff --git a/drivers/ide/amd74xx.c b/drivers/ide/amd74xx.c
index 3747b2561f09..56fc99557ba2 100644
--- a/drivers/ide/amd74xx.c
+++ b/drivers/ide/amd74xx.c
@@ -223,7 +223,7 @@ static const struct ide_port_ops amd_port_ops = {
                 .udma_mask      = udma,                                 \
         }
 
-static const struct ide_port_info amd74xx_chipsets[] __devinitdata = {
+static const struct ide_port_info amd74xx_chipsets[] __devinitconst = {
         /* 0: AMD7401 */        DECLARE_AMD_DEV(0x00, ATA_UDMA2),
         /* 1: AMD7409 */        DECLARE_AMD_DEV(ATA_SWDMA2, ATA_UDMA4),
         /* 2: AMD7411/7441 */   DECLARE_AMD_DEV(ATA_SWDMA2, ATA_UDMA5),
diff --git a/drivers/ide/atiixp.c b/drivers/ide/atiixp.c
index 15f0ead89f5c..cb43480b1bd5 100644
--- a/drivers/ide/atiixp.c
+++ b/drivers/ide/atiixp.c
@@ -139,7 +139,7 @@ static const struct ide_port_ops atiixp_port_ops = {
         .cable_detect           = atiixp_cable_detect,
 };
 
-static const struct ide_port_info atiixp_pci_info[] __devinitdata = {
+static const struct ide_port_info atiixp_pci_info[] __devinitconst = {
         {       /* 0: IXP200/300/400/700 */
                 .name           = DRV_NAME,
                 .enablebits     = {{0x48,0x01,0x00}, {0x48,0x08,0x00}},
diff --git a/drivers/ide/cmd640.c b/drivers/ide/cmd640.c
index 14717304b388..70f0a2754c13 100644
--- a/drivers/ide/cmd640.c
+++ b/drivers/ide/cmd640.c
@@ -685,7 +685,7 @@ static int pci_conf2(void)
         return 0;
 }
 
-static const struct ide_port_info cmd640_port_info __initdata = {
+static const struct ide_port_info cmd640_port_info __initconst = {
         .chipset                = ide_cmd640,
         .host_flags             = IDE_HFLAG_SERIALIZE |
                                   IDE_HFLAG_NO_DMA |
diff --git a/drivers/ide/cmd64x.c b/drivers/ide/cmd64x.c
index 5f80312e636b..d1fc43802f5d 100644
--- a/drivers/ide/cmd64x.c
+++ b/drivers/ide/cmd64x.c
@@ -327,7 +327,7 @@ static const struct ide_dma_ops cmd646_rev1_dma_ops = {
         .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
-static const struct ide_port_info cmd64x_chipsets[] __devinitdata = {
+static const struct ide_port_info cmd64x_chipsets[] __devinitconst = {
         {       /* 0: CMD643 */
                 .name           = DRV_NAME,
                 .init_chipset   = init_chipset_cmd64x,
diff --git a/drivers/ide/cs5520.c b/drivers/ide/cs5520.c
index 2c1e5f7cd261..14447621e60b 100644
--- a/drivers/ide/cs5520.c
+++ b/drivers/ide/cs5520.c
@@ -94,7 +94,7 @@ static const struct ide_port_ops cs5520_port_ops = {
         .set_dma_mode           = cs5520_set_dma_mode,
 };
 
-static const struct ide_port_info cyrix_chipset __devinitdata = {
+static const struct ide_port_info cyrix_chipset __devinitconst = {
         .name           = DRV_NAME,
         .enablebits     = { { 0x60, 0x01, 0x01 }, { 0x60, 0x02, 0x02 } },
         .port_ops       = &cs5520_port_ops,
diff --git a/drivers/ide/cs5530.c b/drivers/ide/cs5530.c
index 4dc4eb92b076..49b40ad59d1a 100644
--- a/drivers/ide/cs5530.c
+++ b/drivers/ide/cs5530.c
@@ -245,7 +245,7 @@ static const struct ide_port_ops cs5530_port_ops = {
         .udma_filter            = cs5530_udma_filter,
 };
 
-static const struct ide_port_info cs5530_chipset __devinitdata = {
+static const struct ide_port_info cs5530_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_chipset   = init_chipset_cs5530,
         .init_hwif      = init_hwif_cs5530,
diff --git a/drivers/ide/cs5535.c b/drivers/ide/cs5535.c
index 5059fafadf29..18d4c852602b 100644
--- a/drivers/ide/cs5535.c
+++ b/drivers/ide/cs5535.c
@@ -170,7 +170,7 @@ static const struct ide_port_ops cs5535_port_ops = {
         .cable_detect           = cs5535_cable_detect,
 };
 
-static const struct ide_port_info cs5535_chipset __devinitdata = {
+static const struct ide_port_info cs5535_chipset __devinitconst = {
         .name           = DRV_NAME,
         .port_ops       = &cs5535_port_ops,
         .host_flags     = IDE_HFLAG_SINGLE | IDE_HFLAG_POST_SET_MODE,
diff --git a/drivers/ide/cy82c693.c b/drivers/ide/cy82c693.c
index 847553fd8b96..3ffb49dab574 100644
--- a/drivers/ide/cy82c693.c
+++ b/drivers/ide/cy82c693.c
@@ -163,7 +163,7 @@ static const struct ide_port_ops cy82c693_port_ops = {
         .set_dma_mode           = cy82c693_set_dma_mode,
 };
 
-static const struct ide_port_info cy82c693_chipset __devinitdata = {
+static const struct ide_port_info cy82c693_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_iops      = init_iops_cy82c693,
         .port_ops       = &cy82c693_port_ops,
diff --git a/drivers/ide/dtc2278.c b/drivers/ide/dtc2278.c
index 46af4743b3e6..8722df329cbe 100644
--- a/drivers/ide/dtc2278.c
+++ b/drivers/ide/dtc2278.c
@@ -91,7 +91,7 @@ static const struct ide_port_ops dtc2278_port_ops = {
         .set_pio_mode           = dtc2278_set_pio_mode,
 };
 
-static const struct ide_port_info dtc2278_port_info __initdata = {
+static const struct ide_port_info dtc2278_port_info __initconst = {
         .name                   = DRV_NAME,
         .chipset                = ide_dtc2278,
         .port_ops               = &dtc2278_port_ops,
diff --git a/drivers/ide/hpt366.c b/drivers/ide/hpt366.c
index 58c51cddc100..4aec3b87ff91 100644
--- a/drivers/ide/hpt366.c
+++ b/drivers/ide/hpt366.c
@@ -443,7 +443,7 @@ static struct hpt_timings hpt37x_timings = {
         }
 };
 
-static const struct hpt_info hpt36x __devinitdata = {
+static const struct hpt_info hpt36x __devinitconst = {
         .chip_name      = "HPT36x",
         .chip_type      = HPT36x,
         .udma_mask      = HPT366_ALLOW_ATA66_3 ? (HPT366_ALLOW_ATA66_4 ? ATA_UDMA4 : ATA_UDMA3) : ATA_UDMA2,
@@ -451,7 +451,7 @@ static const struct hpt_info hpt36x __devinitdata = {
         .timings        = &hpt36x_timings
 };
 
-static const struct hpt_info hpt370 __devinitdata = {
+static const struct hpt_info hpt370 __devinitconst = {
         .chip_name      = "HPT370",
         .chip_type      = HPT370,
         .udma_mask      = HPT370_ALLOW_ATA100_5 ? ATA_UDMA5 : ATA_UDMA4,
@@ -459,7 +459,7 @@ static const struct hpt_info hpt370 __devinitdata = {
         .timings        = &hpt37x_timings
 };
 
-static const struct hpt_info hpt370a __devinitdata = {
+static const struct hpt_info hpt370a __devinitconst = {
         .chip_name      = "HPT370A",
         .chip_type      = HPT370A,
         .udma_mask      = HPT370_ALLOW_ATA100_5 ? ATA_UDMA5 : ATA_UDMA4,
@@ -467,7 +467,7 @@ static const struct hpt_info hpt370a __devinitdata = {
         .timings        = &hpt37x_timings
 };
 
-static const struct hpt_info hpt374 __devinitdata = {
+static const struct hpt_info hpt374 __devinitconst = {
         .chip_name      = "HPT374",
         .chip_type      = HPT374,
         .udma_mask      = ATA_UDMA5,
@@ -475,7 +475,7 @@ static const struct hpt_info hpt374 __devinitdata = {
         .timings        = &hpt37x_timings
 };
 
-static const struct hpt_info hpt372 __devinitdata = {
+static const struct hpt_info hpt372 __devinitconst = {
         .chip_name      = "HPT372",
         .chip_type      = HPT372,
         .udma_mask      = HPT372_ALLOW_ATA133_6 ? ATA_UDMA6 : ATA_UDMA5,
@@ -483,7 +483,7 @@ static const struct hpt_info hpt372 __devinitdata = {
         .timings        = &hpt37x_timings
 };
 
-static const struct hpt_info hpt372a __devinitdata = {
+static const struct hpt_info hpt372a __devinitconst = {
         .chip_name      = "HPT372A",
         .chip_type      = HPT372A,
         .udma_mask      = HPT372_ALLOW_ATA133_6 ? ATA_UDMA6 : ATA_UDMA5,
@@ -491,7 +491,7 @@ static const struct hpt_info hpt372a __devinitdata = {
         .timings        = &hpt37x_timings
 };
 
-static const struct hpt_info hpt302 __devinitdata = {
+static const struct hpt_info hpt302 __devinitconst = {
         .chip_name      = "HPT302",
         .chip_type      = HPT302,
         .udma_mask      = HPT302_ALLOW_ATA133_6 ? ATA_UDMA6 : ATA_UDMA5,
@@ -499,7 +499,7 @@ static const struct hpt_info hpt302 __devinitdata = {
         .timings        = &hpt37x_timings
 };
 
-static const struct hpt_info hpt371 __devinitdata = {
+static const struct hpt_info hpt371 __devinitconst = {
         .chip_name      = "HPT371",
         .chip_type      = HPT371,
         .udma_mask      = HPT371_ALLOW_ATA133_6 ? ATA_UDMA6 : ATA_UDMA5,
@@ -507,7 +507,7 @@ static const struct hpt_info hpt371 __devinitdata = {
         .timings        = &hpt37x_timings
 };
 
-static const struct hpt_info hpt372n __devinitdata = {
+static const struct hpt_info hpt372n __devinitconst = {
         .chip_name      = "HPT372N",
         .chip_type      = HPT372N,
         .udma_mask      = HPT372_ALLOW_ATA133_6 ? ATA_UDMA6 : ATA_UDMA5,
@@ -515,7 +515,7 @@ static const struct hpt_info hpt372n __devinitdata = {
         .timings        = &hpt37x_timings
 };
 
-static const struct hpt_info hpt302n __devinitdata = {
+static const struct hpt_info hpt302n __devinitconst = {
         .chip_name      = "HPT302N",
         .chip_type      = HPT302N,
         .udma_mask      = HPT302_ALLOW_ATA133_6 ? ATA_UDMA6 : ATA_UDMA5,
@@ -523,7 +523,7 @@ static const struct hpt_info hpt302n __devinitdata = {
         .timings        = &hpt37x_timings
 };
 
-static const struct hpt_info hpt371n __devinitdata = {
+static const struct hpt_info hpt371n __devinitconst = {
         .chip_name      = "HPT371N",
         .chip_type      = HPT371N,
         .udma_mask      = HPT371_ALLOW_ATA133_6 ? ATA_UDMA6 : ATA_UDMA5,
@@ -1361,7 +1361,7 @@ static const struct ide_dma_ops hpt36x_dma_ops = {
         .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
-static const struct ide_port_info hpt366_chipsets[] __devinitdata = {
+static const struct ide_port_info hpt366_chipsets[] __devinitconst = {
         {       /* 0: HPT36x */
                 .name           = DRV_NAME,
                 .init_chipset   = init_chipset_hpt366,
diff --git a/drivers/ide/ht6560b.c b/drivers/ide/ht6560b.c
index 986f2513eab4..1e0fd3aa962d 100644
--- a/drivers/ide/ht6560b.c
+++ b/drivers/ide/ht6560b.c
@@ -341,7 +341,7 @@ static const struct ide_port_ops ht6560b_port_ops = {
         .set_pio_mode           = ht6560b_set_pio_mode,
 };
 
-static const struct ide_port_info ht6560b_port_info __initdata = {
+static const struct ide_port_info ht6560b_port_info __initconst = {
         .name                   = DRV_NAME,
         .chipset                = ide_ht6560b,
         .tp_ops                 = &ht6560b_tp_ops,
diff --git a/drivers/ide/icside.c b/drivers/ide/icside.c
index bcb507b0cfd4..e640d0ac3af6 100644
--- a/drivers/ide/icside.c
+++ b/drivers/ide/icside.c
@@ -451,7 +451,7 @@ err_free:
         return ret;
 }
 
-static const struct ide_port_info icside_v6_port_info __initdata = {
+static const struct ide_port_info icside_v6_port_info __initconst = {
         .init_dma               = icside_dma_off_init,
         .port_ops               = &icside_v6_no_dma_port_ops,
         .host_flags             = IDE_HFLAG_SERIALIZE | IDE_HFLAG_MMIO,
diff --git a/drivers/ide/ide-pci-generic.c b/drivers/ide/ide-pci-generic.c
index 7f56b738d762..dab5b670bfbf 100644
--- a/drivers/ide/ide-pci-generic.c
+++ b/drivers/ide/ide-pci-generic.c
@@ -53,7 +53,7 @@ static const struct ide_port_ops netcell_port_ops = {
                 .udma_mask      = ATA_UDMA6, \
         }
 
-static const struct ide_port_info generic_chipsets[] __devinitdata = {
+static const struct ide_port_info generic_chipsets[] __devinitconst = {
         /*  0: Unknown */
         DECLARE_GENERIC_PCI_DEV(0),
 
diff --git a/drivers/ide/it8172.c b/drivers/ide/it8172.c
index 560e66d07659..d5dd180c4b85 100644
--- a/drivers/ide/it8172.c
+++ b/drivers/ide/it8172.c
@@ -115,7 +115,7 @@ static const struct ide_port_ops it8172_port_ops = {
         .set_dma_mode   = it8172_set_dma_mode,
 };
 
-static const struct ide_port_info it8172_port_info __devinitdata = {
+static const struct ide_port_info it8172_port_info __devinitconst = {
         .name           = DRV_NAME,
         .port_ops       = &it8172_port_ops,
         .enablebits     = { {0x41, 0x80, 0x80}, {0x00, 0x00, 0x00} },
diff --git a/drivers/ide/it8213.c b/drivers/ide/it8213.c
index 46816ba26416..1847aeb5450a 100644
--- a/drivers/ide/it8213.c
+++ b/drivers/ide/it8213.c
@@ -156,7 +156,7 @@ static const struct ide_port_ops it8213_port_ops = {
         .cable_detect           = it8213_cable_detect,
 };
 
-static const struct ide_port_info it8213_chipset __devinitdata = {
+static const struct ide_port_info it8213_chipset __devinitconst = {
         .name           = DRV_NAME,
         .enablebits     = { {0x41, 0x80, 0x80} },
         .port_ops       = &it8213_port_ops,
diff --git a/drivers/ide/it821x.c b/drivers/ide/it821x.c
index 2e3169f2acda..c5611dbca342 100644
--- a/drivers/ide/it821x.c
+++ b/drivers/ide/it821x.c
@@ -630,7 +630,7 @@ static const struct ide_port_ops it821x_port_ops = {
         .cable_detect           = it821x_cable_detect,
 };
 
-static const struct ide_port_info it821x_chipset __devinitdata = {
+static const struct ide_port_info it821x_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_chipset   = init_chipset_it821x,
         .init_hwif      = init_hwif_it821x,
diff --git a/drivers/ide/jmicron.c b/drivers/ide/jmicron.c
index 74c2c4a6d909..efddd7d9f92d 100644
--- a/drivers/ide/jmicron.c
+++ b/drivers/ide/jmicron.c
@@ -102,7 +102,7 @@ static const struct ide_port_ops jmicron_port_ops = {
         .cable_detect           = jmicron_cable_detect,
 };
 
-static const struct ide_port_info jmicron_chipset __devinitdata = {
+static const struct ide_port_info jmicron_chipset __devinitconst = {
         .name           = DRV_NAME,
         .enablebits     = { { 0x40, 0x01, 0x01 }, { 0x40, 0x10, 0x10 } },
         .port_ops       = &jmicron_port_ops,
diff --git a/drivers/ide/ns87415.c b/drivers/ide/ns87415.c
index 95327a2c2422..73f78d872d55 100644
--- a/drivers/ide/ns87415.c
+++ b/drivers/ide/ns87415.c
@@ -293,7 +293,7 @@ static const struct ide_dma_ops ns87415_dma_ops = {
         .dma_sff_read_status    = superio_dma_sff_read_status,
 };
 
-static const struct ide_port_info ns87415_chipset __devinitdata = {
+static const struct ide_port_info ns87415_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_hwif      = init_hwif_ns87415,
         .tp_ops         = &ns87415_tp_ops,
diff --git a/drivers/ide/opti621.c b/drivers/ide/opti621.c
index 1a53a4c375ed..39edc66cb96c 100644
--- a/drivers/ide/opti621.c
+++ b/drivers/ide/opti621.c
@@ -131,7 +131,7 @@ static const struct ide_port_ops opti621_port_ops = {
         .set_pio_mode           = opti621_set_pio_mode,
 };
 
-static const struct ide_port_info opti621_chipset __devinitdata = {
+static const struct ide_port_info opti621_chipset __devinitconst = {
         .name           = DRV_NAME,
         .enablebits     = { {0x45, 0x80, 0x00}, {0x40, 0x08, 0x00} },
         .port_ops       = &opti621_port_ops,
diff --git a/drivers/ide/pdc202xx_new.c b/drivers/ide/pdc202xx_new.c
index 9546fe2a93f7..2e5ceb62fb3b 100644
--- a/drivers/ide/pdc202xx_new.c
+++ b/drivers/ide/pdc202xx_new.c
@@ -465,7 +465,7 @@ static const struct ide_port_ops pdcnew_port_ops = {
                 .udma_mask      = udma, \
         }
 
-static const struct ide_port_info pdcnew_chipsets[] __devinitdata = {
+static const struct ide_port_info pdcnew_chipsets[] __devinitconst = {
         /* 0: PDC202{68,70} */          DECLARE_PDCNEW_DEV(ATA_UDMA5),
         /* 1: PDC202{69,71,75,76,77} */ DECLARE_PDCNEW_DEV(ATA_UDMA6),
 };
diff --git a/drivers/ide/pdc202xx_old.c b/drivers/ide/pdc202xx_old.c
index 3a35ec6193d2..563451096812 100644
--- a/drivers/ide/pdc202xx_old.c
+++ b/drivers/ide/pdc202xx_old.c
@@ -270,7 +270,7 @@ static const struct ide_dma_ops pdc2026x_dma_ops = {
                 .max_sectors    = sectors, \
         }
 
-static const struct ide_port_info pdc202xx_chipsets[] __devinitdata = {
+static const struct ide_port_info pdc202xx_chipsets[] __devinitconst = {
         {       /* 0: PDC20246 */
                 .name           = DRV_NAME,
                 .init_chipset   = init_chipset_pdc202xx,
diff --git a/drivers/ide/piix.c b/drivers/ide/piix.c
index 1892e81fb00f..fe0fd60cfc09 100644
--- a/drivers/ide/piix.c
+++ b/drivers/ide/piix.c
@@ -344,7 +344,7 @@ static const struct ide_port_ops ich_port_ops = {
                 .udma_mask      = udma, \
         }
 
-static const struct ide_port_info piix_pci_info[] __devinitdata = {
+static const struct ide_port_info piix_pci_info[] __devinitconst = {
         /* 0: MPIIX */
         {       /*
                  * MPIIX actually has only a single IDE channel mapped to
diff --git a/drivers/ide/qd65xx.c b/drivers/ide/qd65xx.c
index e03f4f19c1d6..a6fb6a894c7b 100644
--- a/drivers/ide/qd65xx.c
+++ b/drivers/ide/qd65xx.c
@@ -335,7 +335,7 @@ static const struct ide_port_ops qd6580_port_ops = {
         .set_pio_mode           = qd6580_set_pio_mode,
 };
 
-static const struct ide_port_info qd65xx_port_info __initdata = {
+static const struct ide_port_info qd65xx_port_info __initconst = {
         .name                   = DRV_NAME,
         .tp_ops                 = &qd65xx_tp_ops,
         .chipset                = ide_qd65xx,
diff --git a/drivers/ide/rz1000.c b/drivers/ide/rz1000.c
index a6414a884eb1..c04173e9fc38 100644
--- a/drivers/ide/rz1000.c
+++ b/drivers/ide/rz1000.c
@@ -38,7 +38,7 @@ static int __devinit rz1000_disable_readahead(struct pci_dev *dev)
         }
 }
 
-static const struct ide_port_info rz1000_chipset __devinitdata = {
+static const struct ide_port_info rz1000_chipset __devinitconst = {
         .name           = DRV_NAME,
         .host_flags     = IDE_HFLAG_NO_DMA,
 };
diff --git a/drivers/ide/sc1200.c b/drivers/ide/sc1200.c
index 356b9b504ffd..d4758ebe77da 100644
--- a/drivers/ide/sc1200.c
+++ b/drivers/ide/sc1200.c
@@ -291,7 +291,7 @@ static const struct ide_dma_ops sc1200_dma_ops = {
         .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
-static const struct ide_port_info sc1200_chipset __devinitdata = {
+static const struct ide_port_info sc1200_chipset __devinitconst = {
         .name           = DRV_NAME,
         .port_ops       = &sc1200_port_ops,
         .dma_ops        = &sc1200_dma_ops,
diff --git a/drivers/ide/scc_pata.c b/drivers/ide/scc_pata.c
index b7f5b0c4310c..970103810021 100644
--- a/drivers/ide/scc_pata.c
+++ b/drivers/ide/scc_pata.c
@@ -811,7 +811,7 @@ static const struct ide_dma_ops scc_dma_ops = {
         .dma_sff_read_status    = scc_dma_sff_read_status,
 };
 
-static const struct ide_port_info scc_chipset __devinitdata = {
+static const struct ide_port_info scc_chipset __devinitconst = {
         .name           = "sccIDE",
         .init_iops      = init_iops_scc,
         .init_dma       = scc_init_dma,
diff --git a/drivers/ide/serverworks.c b/drivers/ide/serverworks.c
index 35fb8dabb55d..24d72ef23df7 100644
--- a/drivers/ide/serverworks.c
+++ b/drivers/ide/serverworks.c
@@ -337,7 +337,7 @@ static const struct ide_port_ops svwks_port_ops = {
         .cable_detect           = svwks_cable_detect,
 };
 
-static const struct ide_port_info serverworks_chipsets[] __devinitdata = {
+static const struct ide_port_info serverworks_chipsets[] __devinitconst = {
         {       /* 0: OSB4 */
                 .name           = DRV_NAME,
                 .init_chipset   = init_chipset_svwks,
diff --git a/drivers/ide/siimage.c b/drivers/ide/siimage.c
index ddeda444a27a..46f7e30d3790 100644
--- a/drivers/ide/siimage.c
+++ b/drivers/ide/siimage.c
@@ -719,7 +719,7 @@ static const struct ide_dma_ops sil_dma_ops = {
                 .udma_mask      = ATA_UDMA6,            \
         }
 
-static const struct ide_port_info siimage_chipsets[] __devinitdata = {
+static const struct ide_port_info siimage_chipsets[] __devinitconst = {
         /* 0: SiI680 */  DECLARE_SII_DEV(&sil_pata_port_ops),
         /* 1: SiI3112 */ DECLARE_SII_DEV(&sil_sata_port_ops)
 };
diff --git a/drivers/ide/sis5513.c b/drivers/ide/sis5513.c
index 4a0022567758..09e61b4c5e94 100644
--- a/drivers/ide/sis5513.c
+++ b/drivers/ide/sis5513.c
@@ -563,7 +563,7 @@ static const struct ide_port_ops sis_ata133_port_ops = {
         .cable_detect           = sis_cable_detect,
 };
 
-static const struct ide_port_info sis5513_chipset __devinitdata = {
+static const struct ide_port_info sis5513_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_chipset   = init_chipset_sis5513,
         .enablebits     = { {0x4a, 0x02, 0x02}, {0x4a, 0x04, 0x04} },
diff --git a/drivers/ide/sl82c105.c b/drivers/ide/sl82c105.c
index f21dc2ad7682..d051cd224bdb 100644
--- a/drivers/ide/sl82c105.c
+++ b/drivers/ide/sl82c105.c
@@ -299,7 +299,7 @@ static const struct ide_dma_ops sl82c105_dma_ops = {
         .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
-static const struct ide_port_info sl82c105_chipset __devinitdata = {
+static const struct ide_port_info sl82c105_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_chipset   = init_chipset_sl82c105,
         .enablebits     = {{0x40,0x01,0x01}, {0x40,0x10,0x10}},
diff --git a/drivers/ide/slc90e66.c b/drivers/ide/slc90e66.c
index 864ffe0e26d9..863a5e9283ca 100644
--- a/drivers/ide/slc90e66.c
+++ b/drivers/ide/slc90e66.c
@@ -132,7 +132,7 @@ static const struct ide_port_ops slc90e66_port_ops = {
         .cable_detect           = slc90e66_cable_detect,
 };
 
-static const struct ide_port_info slc90e66_chipset __devinitdata = {
+static const struct ide_port_info slc90e66_chipset __devinitconst = {
         .name           = DRV_NAME,
         .enablebits     = { {0x41, 0x80, 0x80}, {0x43, 0x80, 0x80} },
         .port_ops       = &slc90e66_port_ops,
diff --git a/drivers/ide/tc86c001.c b/drivers/ide/tc86c001.c
index 4799d5c384e7..17946785ebf6 100644
--- a/drivers/ide/tc86c001.c
+++ b/drivers/ide/tc86c001.c
@@ -192,7 +192,7 @@ static const struct ide_dma_ops tc86c001_dma_ops = {
         .dma_sff_read_status    = ide_dma_sff_read_status,
 };
 
-static const struct ide_port_info tc86c001_chipset __devinitdata = {
+static const struct ide_port_info tc86c001_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_hwif      = init_hwif_tc86c001,
         .port_ops       = &tc86c001_port_ops,
diff --git a/drivers/ide/triflex.c b/drivers/ide/triflex.c
index 281c91426345..55ce1b80efcb 100644
--- a/drivers/ide/triflex.c
+++ b/drivers/ide/triflex.c
@@ -92,7 +92,7 @@ static const struct ide_port_ops triflex_port_ops = {
         .set_dma_mode           = triflex_set_mode,
 };
 
-static const struct ide_port_info triflex_device __devinitdata = {
+static const struct ide_port_info triflex_device __devinitconst = {
         .name           = DRV_NAME,
         .enablebits     = {{0x80, 0x01, 0x01}, {0x80, 0x02, 0x02}},
         .port_ops       = &triflex_port_ops,
diff --git a/drivers/ide/trm290.c b/drivers/ide/trm290.c
index 4b42ca091534..e494a98a43a9 100644
--- a/drivers/ide/trm290.c
+++ b/drivers/ide/trm290.c
@@ -324,7 +324,7 @@ static struct ide_dma_ops trm290_dma_ops = {
         .dma_check              = trm290_dma_check,
 };
 
-static const struct ide_port_info trm290_chipset __devinitdata = {
+static const struct ide_port_info trm290_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_hwif      = init_hwif_trm290,
         .tp_ops         = &trm290_tp_ops,
diff --git a/drivers/ide/tx4938ide.c b/drivers/ide/tx4938ide.c
index 7002765b593c..91d49dd957ef 100644
--- a/drivers/ide/tx4938ide.c
+++ b/drivers/ide/tx4938ide.c
@@ -117,7 +117,7 @@ static const struct ide_port_ops tx4938ide_port_ops = {
         .set_pio_mode           = tx4938ide_set_pio_mode,
 };
 
-static const struct ide_port_info tx4938ide_port_info __initdata = {
+static const struct ide_port_info tx4938ide_port_info __initconst = {
         .port_ops               = &tx4938ide_port_ops,
 #ifdef __BIG_ENDIAN
         .tp_ops                 = &tx4938ide_tp_ops,
diff --git a/drivers/ide/tx4939ide.c b/drivers/ide/tx4939ide.c
index 71c231954972..c0ab800b7bb3 100644
--- a/drivers/ide/tx4939ide.c
+++ b/drivers/ide/tx4939ide.c
@@ -522,7 +522,7 @@ static const struct ide_dma_ops tx4939ide_dma_ops = {
         .dma_sff_read_status    = tx4939ide_dma_sff_read_status,
 };
 
-static const struct ide_port_info tx4939ide_port_info __initdata = {
+static const struct ide_port_info tx4939ide_port_info __initconst = {
         .init_hwif              = tx4939ide_init_hwif,
         .init_dma               = tx4939ide_init_dma,
         .port_ops               = &tx4939ide_port_ops,
diff --git a/drivers/ide/umc8672.c b/drivers/ide/umc8672.c
index 5cfb78120669..3aa0fea0f3d9 100644
--- a/drivers/ide/umc8672.c
+++ b/drivers/ide/umc8672.c
@@ -128,7 +128,7 @@ static const struct ide_port_ops umc8672_port_ops = {
         .set_pio_mode           = umc_set_pio_mode,
 };
 
-static const struct ide_port_info umc8672_port_info __initdata = {
+static const struct ide_port_info umc8672_port_info __initconst = {
         .name                   = DRV_NAME,
         .chipset                = ide_umc8672,
         .port_ops               = &umc8672_port_ops,
diff --git a/drivers/ide/via82cxxx.c b/drivers/ide/via82cxxx.c
index f46f49cfcc28..eb7767864d10 100644
--- a/drivers/ide/via82cxxx.c
+++ b/drivers/ide/via82cxxx.c
@@ -403,7 +403,7 @@ static const struct ide_port_ops via_port_ops = {
         .cable_detect           = via82cxxx_cable_detect,
 };
 
-static const struct ide_port_info via82cxxx_chipset __devinitdata = {
+static const struct ide_port_info via82cxxx_chipset __devinitconst = {
         .name           = DRV_NAME,
         .init_chipset   = init_chipset_via82cxxx,
         .enablebits     = { { 0x40, 0x02, 0x02 }, { 0x40, 0x01, 0x01 } },
diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c
index d67999f6e34a..394fea2ba1bc 100644
--- a/drivers/infiniband/core/cm.c
+++ b/drivers/infiniband/core/cm.c
@@ -390,7 +390,7 @@ static int cm_alloc_id(struct cm_id_private *cm_id_priv)
                 ret = idr_get_new_above(&cm.local_id_table, cm_id_priv,
                                         next_id, &id);
                 if (!ret)
-                        next_id = ((unsigned) id + 1) & MAX_ID_MASK;
+                        next_id = ((unsigned) id + 1) & MAX_IDR_MASK;
                 spin_unlock_irqrestore(&cm.lock, flags);
         } while( (ret == -EAGAIN) && idr_pre_get(&cm.local_id_table, GFP_KERNEL) );
 
diff --git a/drivers/infiniband/hw/mlx4/cm.c b/drivers/infiniband/hw/mlx4/cm.c
index e25e4dafb8a8..80079e5a2e30 100644
--- a/drivers/infiniband/hw/mlx4/cm.c
+++ b/drivers/infiniband/hw/mlx4/cm.c
@@ -225,7 +225,7 @@ id_map_alloc(struct ib_device *ibdev, int slave_id, u32 sl_cm_id)
                 ret = idr_get_new_above(&sriov->pv_id_table, ent,
                                         next_id, &id);
                 if (!ret) {
-                        next_id = ((unsigned) id + 1) & MAX_ID_MASK;
+                        next_id = ((unsigned) id + 1) & MAX_IDR_MASK;
                         ent->pv_cm_id = (u32)id;
                         sl_id_map_add(ibdev, ent);
                 }
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index 20e5c2cda430..ef87310b7662 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -748,7 +748,7 @@ static void __devexit macio_pci_remove(struct pci_dev* pdev)
  * MacIO is matched against any Apple ID, it's probe() function
  * will then decide wether it applies or not
  */
-static const struct pci_device_id __devinitdata pci_ids [] = { {
+static const struct pci_device_id __devinitconst pci_ids[] = { {
         .vendor         = PCI_VENDOR_ID_APPLE,
         .device         = PCI_ANY_ID,
         .subvendor      = PCI_ANY_ID,
diff --git a/drivers/mfd/wm8994-core.c b/drivers/mfd/wm8994-core.c
index 3d6d9beb18d4..8fefc961ec06 100644
--- a/drivers/mfd/wm8994-core.c
+++ b/drivers/mfd/wm8994-core.c
@@ -374,21 +374,21 @@ static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
 }
 #endif
 
-static const __devinitdata struct reg_default wm8994_revc_patch[] = {
+static const __devinitconst struct reg_default wm8994_revc_patch[] = {
         { 0x102, 0x3 },
         { 0x56, 0x3 },
         { 0x817, 0x0 },
         { 0x102, 0x0 },
 };
 
-static const __devinitdata struct reg_default wm8958_reva_patch[] = {
+static const __devinitconst struct reg_default wm8958_reva_patch[] = {
         { 0x102, 0x3 },
         { 0xcb, 0x81 },
         { 0x817, 0x0 },
         { 0x102, 0x0 },
 };
 
-static const __devinitdata struct reg_default wm1811_reva_patch[] = {
+static const __devinitconst struct reg_default wm1811_reva_patch[] = {
         { 0x102, 0x3 },
         { 0x56, 0xc07 },
         { 0x5d, 0x7e },
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 504da715a41a..9722d43d6140 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -653,7 +653,7 @@ static const struct sdhci_pci_fixes sdhci_via = {
         .probe          = via_probe,
 };
 
-static const struct pci_device_id pci_ids[] __devinitdata = {
+static const struct pci_device_id pci_ids[] __devinitconst = {
         {
                 .vendor         = PCI_VENDOR_ID_RICOH,
                 .device         = PCI_DEVICE_ID_RICOH_R5C822,
diff --git a/drivers/net/can/slcan.c b/drivers/net/can/slcan.c
index 034c16b60e96..adc3708d8829 100644
--- a/drivers/net/can/slcan.c
+++ b/drivers/net/can/slcan.c
@@ -56,7 +56,7 @@
 #include <linux/kernel.h>
 #include <linux/can.h>
 
-static __initdata const char banner[] =
+static __initconst const char banner[] =
         KERN_INFO "slcan: serial line CAN interface driver\n";
 
 MODULE_ALIAS_LDISC(N_SLCAN);
diff --git a/drivers/net/can/vcan.c b/drivers/net/can/vcan.c
index 4f93c0be0053..0a2a5ee79a17 100644
--- a/drivers/net/can/vcan.c
+++ b/drivers/net/can/vcan.c
@@ -49,7 +49,7 @@
 #include <linux/slab.h>
 #include <net/rtnetlink.h>
 
-static __initdata const char banner[] =
+static __initconst const char banner[] =
         KERN_INFO "vcan: Virtual CAN interface driver\n";
 
 MODULE_DESCRIPTION("virtual CAN interface");
diff --git a/drivers/net/ethernet/8390/ne3210.c b/drivers/net/ethernet/8390/ne3210.c
index a2f8b2b8e27c..e3f57427d5c5 100644
--- a/drivers/net/ethernet/8390/ne3210.c
+++ b/drivers/net/ethernet/8390/ne3210.c
@@ -81,7 +81,7 @@ static void ne3210_block_output(struct net_device *dev, int count, const unsigne
 
 static unsigned char irq_map[] __initdata = {15, 12, 11, 10, 9, 7, 5, 3};
 static unsigned int shmem_map[] __initdata = {0xff0, 0xfe0, 0xfff0, 0xd8, 0xffe0, 0xffc0, 0xd0, 0x0};
-static const char *ifmap[] __initdata = {"UTP", "?", "BNC", "AUI"};
+static const char * const ifmap[] __initconst = {"UTP", "?", "BNC", "AUI"};
 static int ifmap_val[] __initdata = {
                 IF_PORT_10BASET,
                 IF_PORT_UNKNOWN,
diff --git a/drivers/net/ethernet/adaptec/starfire.c b/drivers/net/ethernet/adaptec/starfire.c
index d920a529ba22..5b65992c2a0a 100644
--- a/drivers/net/ethernet/adaptec/starfire.c
+++ b/drivers/net/ethernet/adaptec/starfire.c
@@ -295,7 +295,7 @@ MODULE_DEVICE_TABLE(pci, starfire_pci_tbl);
 static const struct chip_info {
         const char *name;
         int drv_flags;
-} netdrv_tbl[] __devinitdata = {
+} netdrv_tbl[] __devinitconst = {
         { "Adaptec Starfire 6915", CanHaveMII },
 };
 
diff --git a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
index 55a2e3795055..d19f82f7597a 100644
--- a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
+++ b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
@@ -702,7 +702,7 @@ struct atl1c_platform_patch {
         u32 patch_flag;
 #define ATL1C_LINK_PATCH        0x1
 };
-static const struct atl1c_platform_patch plats[] __devinitdata = {
+static const struct atl1c_platform_patch plats[] __devinitconst = {
 {0x2060, 0xC1, 0x1019, 0x8152, 0x1},
 {0x2060, 0xC1, 0x1019, 0x2060, 0x1},
 {0x2060, 0xC1, 0x1019, 0xE000, 0x1},
diff --git a/drivers/net/ethernet/atheros/atlx/atl2.c b/drivers/net/ethernet/atheros/atlx/atl2.c
index 57d64b80fd72..623dd8635c46 100644
--- a/drivers/net/ethernet/atheros/atlx/atl2.c
+++ b/drivers/net/ethernet/atheros/atlx/atl2.c
@@ -2845,7 +2845,7 @@ static void atl2_force_ps(struct atl2_hw *hw)
  */
 
 #define ATL2_PARAM(X, desc) \
-    static const int __devinitdata X[ATL2_MAX_NIC + 1] = ATL2_PARAM_INIT; \
+    static const int __devinitconst X[ATL2_MAX_NIC + 1] = ATL2_PARAM_INIT; \
     MODULE_PARM(X, "1-" __MODULE_STRING(ATL2_MAX_NIC) "i"); \
     MODULE_PARM_DESC(X, desc);
 #else
diff --git a/drivers/net/ethernet/dec/tulip/de2104x.c b/drivers/net/ethernet/dec/tulip/de2104x.c
index 61cc09342865..77335853ac36 100644
--- a/drivers/net/ethernet/dec/tulip/de2104x.c
+++ b/drivers/net/ethernet/dec/tulip/de2104x.c
@@ -661,9 +661,6 @@ static netdev_tx_t de_start_xmit (struct sk_buff *skb,
    new frame, not around filling de->setup_frame.  This is non-deterministic
    when re-entered but still correct. */
 
-#undef set_bit_le
-#define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
-
 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
 {
         struct de_private *de = netdev_priv(dev);
@@ -673,12 +670,12 @@ static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
         u16 *eaddrs;
 
         memset(hash_table, 0, sizeof(hash_table));
-        set_bit_le(255, hash_table);                    /* Broadcast entry */
+        __set_bit_le(255, hash_table);                  /* Broadcast entry */
         /* This should work on big-endian machines as well. */
         netdev_for_each_mc_addr(ha, dev) {
                 int index = ether_crc_le(ETH_ALEN, ha->addr) & 0x1ff;
 
-                set_bit_le(index, hash_table);
+                __set_bit_le(index, hash_table);
         }
 
         for (i = 0; i < 32; i++) {
diff --git a/drivers/net/ethernet/dec/tulip/eeprom.c b/drivers/net/ethernet/dec/tulip/eeprom.c
index ed7d1dcd9566..44f7e8e82d85 100644
--- a/drivers/net/ethernet/dec/tulip/eeprom.c
+++ b/drivers/net/ethernet/dec/tulip/eeprom.c
@@ -79,7 +79,7 @@ static struct eeprom_fixup eeprom_fixups[] __devinitdata = {
   {NULL}};
 
 
-static const char *block_name[] __devinitdata = {
+static const char *const block_name[] __devinitconst = {
         "21140 non-MII",
         "21140 MII PHY",
         "21142 Serial PHY",
diff --git a/drivers/net/ethernet/dec/tulip/tulip_core.c b/drivers/net/ethernet/dec/tulip/tulip_core.c
index c4f37aca2269..885700a19978 100644
--- a/drivers/net/ethernet/dec/tulip/tulip_core.c
+++ b/drivers/net/ethernet/dec/tulip/tulip_core.c
@@ -1010,9 +1010,6 @@ static int private_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
    new frame, not around filling tp->setup_frame.  This is non-deterministic
    when re-entered but still correct. */
 
-#undef set_bit_le
-#define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
-
 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
 {
         struct tulip_private *tp = netdev_priv(dev);
@@ -1022,12 +1019,12 @@ static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
         u16 *eaddrs;
 
         memset(hash_table, 0, sizeof(hash_table));
-        set_bit_le(255, hash_table);                    /* Broadcast entry */
+        __set_bit_le(255, hash_table);                  /* Broadcast entry */
         /* This should work on big-endian machines as well. */
         netdev_for_each_mc_addr(ha, dev) {
                 int index = ether_crc_le(ETH_ALEN, ha->addr) & 0x1ff;
 
-                set_bit_le(index, hash_table);
+                __set_bit_le(index, hash_table);
         }
         for (i = 0; i < 32; i++) {
                 *setup_frm++ = hash_table[i];
diff --git a/drivers/net/ethernet/dec/tulip/winbond-840.c b/drivers/net/ethernet/dec/tulip/winbond-840.c
index 4d1ffca83c82..7c1ec4d7920b 100644
--- a/drivers/net/ethernet/dec/tulip/winbond-840.c
+++ b/drivers/net/ethernet/dec/tulip/winbond-840.c
@@ -236,7 +236,7 @@ struct pci_id_info {
         int drv_flags;          /* Driver use, intended as capability flags. */
 };
 
-static const struct pci_id_info pci_id_tbl[] __devinitdata = {
+static const struct pci_id_info pci_id_tbl[] __devinitconst = {
         {                               /* Sometime a Level-One switch card. */
           "Winbond W89c840",    CanHaveMII | HasBrokenTx | FDXOnNoMII},
         { "Winbond W89c840",    CanHaveMII | HasBrokenTx},
diff --git a/drivers/net/ethernet/dlink/sundance.c b/drivers/net/ethernet/dlink/sundance.c
index d7bb52a7bda1..3b83588e51f6 100644
--- a/drivers/net/ethernet/dlink/sundance.c
+++ b/drivers/net/ethernet/dlink/sundance.c
@@ -218,7 +218,7 @@ enum {
 struct pci_id_info {
         const char *name;
 };
-static const struct pci_id_info pci_id_tbl[] __devinitdata = {
+static const struct pci_id_info pci_id_tbl[] __devinitconst = {
         {"D-Link DFE-550TX FAST Ethernet Adapter"},
         {"D-Link DFE-550FX 100Mbps Fiber-optics Adapter"},
         {"D-Link DFE-580TX 4 port Server Adapter"},
diff --git a/drivers/net/ethernet/fealnx.c b/drivers/net/ethernet/fealnx.c
index 9d71c9cc300b..0e4a0ac86aa8 100644
--- a/drivers/net/ethernet/fealnx.c
+++ b/drivers/net/ethernet/fealnx.c
@@ -150,7 +150,7 @@ struct chip_info {
         int flags;
 };
 
-static const struct chip_info skel_netdrv_tbl[] __devinitdata = {
+static const struct chip_info skel_netdrv_tbl[] __devinitconst = {
         { "100/10M Ethernet PCI Adapter",       HAS_MII_XCVR },
         { "100/10M Ethernet PCI Adapter",       HAS_CHIP_XCVR },
         { "1000/100/10M Ethernet PCI Adapter",  HAS_MII_XCVR },
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c
index b528e52a8ee1..2a0c9dc48eb3 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c
@@ -38,7 +38,7 @@ static inline void writeq(u64 val, void __iomem *addr)
 }
 #endif
 
-static const struct crb_128M_2M_block_map
+static struct crb_128M_2M_block_map
 crb_128M_2M_map[64] __cacheline_aligned_in_smp = {
     {{{0, 0,         0,         0} } },         /* 0: PCI */
     {{{1, 0x0100000, 0x0102000, 0x120000},      /* 1: PCIE */
diff --git a/drivers/net/ethernet/realtek/8139too.c b/drivers/net/ethernet/realtek/8139too.c
index 1d83565cc6af..3ed7add23c12 100644
--- a/drivers/net/ethernet/realtek/8139too.c
+++ b/drivers/net/ethernet/realtek/8139too.c
@@ -228,7 +228,7 @@ typedef enum {
 static const struct {
         const char *name;
         u32 hw_flags;
-} board_info[] __devinitdata = {
+} board_info[] __devinitconst = {
         { "RealTek RTL8139", RTL8139_CAPS },
         { "RealTek RTL8129", RTL8129_CAPS },
 };
diff --git a/drivers/net/ethernet/sfc/efx.c b/drivers/net/ethernet/sfc/efx.c
index 96bd980e828d..4f86d0cd516a 100644
--- a/drivers/net/ethernet/sfc/efx.c
+++ b/drivers/net/ethernet/sfc/efx.c
@@ -2019,14 +2019,14 @@ static void efx_set_rx_mode(struct net_device *net_dev)
                 netdev_for_each_mc_addr(ha, net_dev) {
                         crc = ether_crc_le(ETH_ALEN, ha->addr);
                         bit = crc & (EFX_MCAST_HASH_ENTRIES - 1);
-                        set_bit_le(bit, mc_hash->byte);
+                        __set_bit_le(bit, mc_hash);
                 }
 
                 /* Broadcast packets go through the multicast hash filter.
                  * ether_crc_le() of the broadcast address is 0xbe2612ff
                  * so we always add bit 0xff to the mask.
                  */
-                set_bit_le(0xff, mc_hash->byte);
+                __set_bit_le(0xff, mc_hash);
         }
 
         if (efx->port_enabled)
diff --git a/drivers/net/ethernet/sfc/net_driver.h b/drivers/net/ethernet/sfc/net_driver.h
index c1a010cda89b..576a31091165 100644
--- a/drivers/net/ethernet/sfc/net_driver.h
+++ b/drivers/net/ethernet/sfc/net_driver.h
@@ -1101,18 +1101,6 @@ static inline struct efx_rx_buffer *efx_rx_buffer(struct efx_rx_queue *rx_queue,
         return &rx_queue->buffer[index];
 }
 
-/* Set bit in a little-endian bitfield */
-static inline void set_bit_le(unsigned nr, unsigned char *addr)
-{
-        addr[nr / 8] |= (1 << (nr % 8));
-}
-
-/* Clear bit in a little-endian bitfield */
-static inline void clear_bit_le(unsigned nr, unsigned char *addr)
-{
-        addr[nr / 8] &= ~(1 << (nr % 8));
-}
-
 
 /**
  * EFX_MAX_FRAME_LEN - calculate maximum frame length
diff --git a/drivers/net/ethernet/sfc/nic.c b/drivers/net/ethernet/sfc/nic.c
index cdff40b65729..aab7cacb2e34 100644
--- a/drivers/net/ethernet/sfc/nic.c
+++ b/drivers/net/ethernet/sfc/nic.c
@@ -472,9 +472,9 @@ void efx_nic_init_tx(struct efx_tx_queue *tx_queue)
 
                 efx_reado(efx, &reg, FR_AA_TX_CHKSM_CFG);
                 if (tx_queue->queue & EFX_TXQ_TYPE_OFFLOAD)
-                        clear_bit_le(tx_queue->queue, (void *)&reg);
+                        __clear_bit_le(tx_queue->queue, &reg);
                 else
-                        set_bit_le(tx_queue->queue, (void *)&reg);
+                        __set_bit_le(tx_queue->queue, &reg);
                 efx_writeo(efx, &reg, FR_AA_TX_CHKSM_CFG);
         }
 
diff --git a/drivers/net/ethernet/sis/sis190.c b/drivers/net/ethernet/sis/sis190.c
index 4613591b43e7..d8166012b7d4 100644
--- a/drivers/net/ethernet/sis/sis190.c
+++ b/drivers/net/ethernet/sis/sis190.c
@@ -1618,7 +1618,7 @@ static int __devinit sis190_get_mac_addr_from_eeprom(struct pci_dev *pdev,
 static int __devinit sis190_get_mac_addr_from_apc(struct pci_dev *pdev,
                                                   struct net_device *dev)
 {
-        static const u16 __devinitdata ids[] = { 0x0965, 0x0966, 0x0968 };
+        static const u16 __devinitconst ids[] = { 0x0965, 0x0966, 0x0968 };
         struct sis190_private *tp = netdev_priv(dev);
         struct pci_dev *isa_bridge;
         u8 reg, tmp8;
diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 64783a0d545a..1450e33fc250 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -811,9 +811,9 @@ static struct tty_ldisc_ops sp_ldisc = {
 
 /* Initialize 6pack control device -- register 6pack line discipline */
 
-static const char msg_banner[]  __initdata = KERN_INFO \
+static const char msg_banner[]  __initconst = KERN_INFO \
         "AX.25: 6pack driver, " SIXPACK_VERSION "\n";
-static const char msg_regfail[] __initdata = KERN_ERR  \
+static const char msg_regfail[] __initconst = KERN_ERR  \
         "6pack: can't register line discipline (err = %d)\n";
 
 static int __init sixpack_init_driver(void)
@@ -829,7 +829,7 @@ static int __init sixpack_init_driver(void)
         return status;
 }
 
-static const char msg_unregfail[] __exitdata = KERN_ERR \
+static const char msg_unregfail[] = KERN_ERR \
         "6pack: can't unregister line discipline (err = %d)\n";
 
 static void __exit sixpack_exit_driver(void)
diff --git a/drivers/net/hamradio/bpqether.c b/drivers/net/hamradio/bpqether.c
index 76d54774ba82..c2e5497397d5 100644
--- a/drivers/net/hamradio/bpqether.c
+++ b/drivers/net/hamradio/bpqether.c
@@ -87,7 +87,7 @@
 
 #include <linux/bpqether.h>
 
-static const char banner[] __initdata = KERN_INFO \
+static const char banner[] __initconst = KERN_INFO \
         "AX.25: bpqether driver version 004\n";
 
 static char bcast_addr[6]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c
index 2c0894a92abd..8e01c457015b 100644
--- a/drivers/net/hamradio/mkiss.c
+++ b/drivers/net/hamradio/mkiss.c
@@ -997,9 +997,9 @@ static struct tty_ldisc_ops ax_ldisc = {
         .write_wakeup   = mkiss_write_wakeup
 };
 
-static const char banner[] __initdata = KERN_INFO \
+static const char banner[] __initconst = KERN_INFO \
         "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
-static const char msg_regfail[] __initdata = KERN_ERR \
+static const char msg_regfail[] __initconst = KERN_ERR \
         "mkiss: can't register line discipline (err = %d)\n";
 
 static int __init mkiss_init_driver(void)
@@ -1015,7 +1015,7 @@ static int __init mkiss_init_driver(void)
         return status;
 }
 
-static const char msg_unregfail[] __exitdata = KERN_ERR \
+static const char msg_unregfail[] = KERN_ERR \
         "mkiss: can't unregister line discipline (err = %d)\n";
 
 static void __exit mkiss_exit_driver(void)
diff --git a/drivers/net/hamradio/scc.c b/drivers/net/hamradio/scc.c
index efc6c97163a7..1b4a47bd32b7 100644
--- a/drivers/net/hamradio/scc.c
+++ b/drivers/net/hamradio/scc.c
@@ -182,7 +182,7 @@
 
 #include "z8530.h"
 
-static const char banner[] __initdata = KERN_INFO \
+static const char banner[] __initconst = KERN_INFO \
         "AX.25: Z8530 SCC driver version "VERSION".dl1bke\n";
 
 static void t_dwait(unsigned long);
diff --git a/drivers/net/hamradio/yam.c b/drivers/net/hamradio/yam.c
index 5a6412ecce73..c6645f1017af 100644
--- a/drivers/net/hamradio/yam.c
+++ b/drivers/net/hamradio/yam.c
@@ -76,7 +76,7 @@
 /* --------------------------------------------------------------------- */
 
 static const char yam_drvname[] = "yam";
-static const char yam_drvinfo[] __initdata = KERN_INFO \
+static const char yam_drvinfo[] __initconst = KERN_INFO \
         "YAM driver version 0.8 by F1OAT/F6FBB\n";
 
 /* --------------------------------------------------------------------- */
diff --git a/drivers/net/rionet.c b/drivers/net/rionet.c
index 91d25888a1b9..d8b9b1e8ee02 100644
--- a/drivers/net/rionet.c
+++ b/drivers/net/rionet.c
@@ -26,7 +26,7 @@
 #include <linux/ethtool.h>
 
 #define DRV_NAME        "rionet"
-#define DRV_VERSION     "0.2"
+#define DRV_VERSION     "0.3"
 #define DRV_AUTHOR      "Matt Porter <mporter@kernel.crashing.org>"
 #define DRV_DESC        "Ethernet over RapidIO"
 
@@ -47,8 +47,7 @@ MODULE_LICENSE("GPL");
 
 #define RIONET_TX_RING_SIZE     CONFIG_RIONET_TX_SIZE
 #define RIONET_RX_RING_SIZE     CONFIG_RIONET_RX_SIZE
-
-static LIST_HEAD(rionet_peers);
+#define RIONET_MAX_NETS         8
 
 struct rionet_private {
         struct rio_mport *mport;
@@ -69,16 +68,14 @@ struct rionet_peer {
         struct resource *res;
 };
 
-static int rionet_check = 0;
-static int rionet_capable = 1;
+struct rionet_net {
+        struct net_device *ndev;
+        struct list_head peers;
+        struct rio_dev **active;
+        int nact;       /* number of active peers */
+};
 
-/*
- * This is a fast lookup table for translating TX
- * Ethernet packets into a destination RIO device. It
- * could be made into a hash table to save memory depending
- * on system trade-offs.
- */
-static struct rio_dev **rionet_active;
+static struct rionet_net nets[RIONET_MAX_NETS];
 
 #define is_rionet_capable(src_ops, dst_ops)                     \
                         ((src_ops & RIO_SRC_OPS_DATA_MSG) &&    \
@@ -175,6 +172,7 @@ static int rionet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         struct ethhdr *eth = (struct ethhdr *)skb->data;
         u16 destid;
         unsigned long flags;
+        int add_num = 1;
 
         local_irq_save(flags);
         if (!spin_trylock(&rnet->tx_lock)) {
@@ -182,7 +180,10 @@ static int rionet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
                 return NETDEV_TX_LOCKED;
         }
 
-        if ((rnet->tx_cnt + 1) > RIONET_TX_RING_SIZE) {
+        if (is_multicast_ether_addr(eth->h_dest))
+                add_num = nets[rnet->mport->id].nact;
+
+        if ((rnet->tx_cnt + add_num) > RIONET_TX_RING_SIZE) {
                 netif_stop_queue(ndev);
                 spin_unlock_irqrestore(&rnet->tx_lock, flags);
                 printk(KERN_ERR "%s: BUG! Tx Ring full when queue awake!\n",
@@ -191,15 +192,22 @@ static int rionet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         }
 
         if (is_multicast_ether_addr(eth->h_dest)) {
+                int count = 0;
+
                 for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rnet->mport->sys_size);
                                 i++)
-                        if (rionet_active[i])
+                        if (nets[rnet->mport->id].active[i]) {
                                 rionet_queue_tx_msg(skb, ndev,
-                                                    rionet_active[i]);
+                                        nets[rnet->mport->id].active[i]);
+                                if (count)
+                                        atomic_inc(&skb->users);
+                                count++;
+                        }
         } else if (RIONET_MAC_MATCH(eth->h_dest)) {
                 destid = RIONET_GET_DESTID(eth->h_dest);
-                if (rionet_active[destid])
-                        rionet_queue_tx_msg(skb, ndev, rionet_active[destid]);
+                if (nets[rnet->mport->id].active[destid])
+                        rionet_queue_tx_msg(skb, ndev,
+                                        nets[rnet->mport->id].active[destid]);
         }
 
         spin_unlock_irqrestore(&rnet->tx_lock, flags);
@@ -218,16 +226,21 @@ static void rionet_dbell_event(struct rio_mport *mport, void *dev_id, u16 sid, u
                 printk(KERN_INFO "%s: doorbell sid %4.4x tid %4.4x info %4.4x",
                        DRV_NAME, sid, tid, info);
         if (info == RIONET_DOORBELL_JOIN) {
-                if (!rionet_active[sid]) {
-                        list_for_each_entry(peer, &rionet_peers, node) {
-                                if (peer->rdev->destid == sid)
-                                        rionet_active[sid] = peer->rdev;
+                if (!nets[rnet->mport->id].active[sid]) {
+                        list_for_each_entry(peer,
+                                           &nets[rnet->mport->id].peers, node) {
+                                if (peer->rdev->destid == sid) {
+                                        nets[rnet->mport->id].active[sid] =
+                                                                peer->rdev;
+                                        nets[rnet->mport->id].nact++;
+                                }
                         }
                         rio_mport_send_doorbell(mport, sid,
                                                 RIONET_DOORBELL_JOIN);
                 }
         } else if (info == RIONET_DOORBELL_LEAVE) {
-                rionet_active[sid] = NULL;
+                nets[rnet->mport->id].active[sid] = NULL;
+                nets[rnet->mport->id].nact--;
         } else {
                 if (netif_msg_intr(rnet))
                         printk(KERN_WARNING "%s: unhandled doorbell\n",
@@ -321,7 +334,8 @@ static int rionet_open(struct net_device *ndev)
         netif_carrier_on(ndev);
         netif_start_queue(ndev);
 
-        list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
+        list_for_each_entry_safe(peer, tmp,
+                                 &nets[rnet->mport->id].peers, node) {
                 if (!(peer->res = rio_request_outb_dbell(peer->rdev,
                                                          RIONET_DOORBELL_JOIN,
                                                          RIONET_DOORBELL_LEAVE)))
@@ -346,7 +360,7 @@ static int rionet_close(struct net_device *ndev)
         int i;
 
         if (netif_msg_ifup(rnet))
-                printk(KERN_INFO "%s: close\n", DRV_NAME);
+                printk(KERN_INFO "%s: close %s\n", DRV_NAME, ndev->name);
 
         netif_stop_queue(ndev);
         netif_carrier_off(ndev);
@@ -354,10 +368,11 @@ static int rionet_close(struct net_device *ndev)
         for (i = 0; i < RIONET_RX_RING_SIZE; i++)
                 kfree_skb(rnet->rx_skb[i]);
 
-        list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
-                if (rionet_active[peer->rdev->destid]) {
+        list_for_each_entry_safe(peer, tmp,
+                                 &nets[rnet->mport->id].peers, node) {
+                if (nets[rnet->mport->id].active[peer->rdev->destid]) {
                         rio_send_doorbell(peer->rdev, RIONET_DOORBELL_LEAVE);
-                        rionet_active[peer->rdev->destid] = NULL;
+                        nets[rnet->mport->id].active[peer->rdev->destid] = NULL;
                 }
                 rio_release_outb_dbell(peer->rdev, peer->res);
         }
@@ -373,17 +388,21 @@ static int rionet_close(struct net_device *ndev)
 static void rionet_remove(struct rio_dev *rdev)
 {
         struct net_device *ndev = rio_get_drvdata(rdev);
+        unsigned char netid = rdev->net->hport->id;
         struct rionet_peer *peer, *tmp;
 
-        free_pages((unsigned long)rionet_active, get_order(sizeof(void *) *
-                        RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size)));
         unregister_netdev(ndev);
-        free_netdev(ndev);
 
-        list_for_each_entry_safe(peer, tmp, &rionet_peers, node) {
+        free_pages((unsigned long)nets[netid].active, get_order(sizeof(void *) *
+                        RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size)));
+        nets[netid].active = NULL;
+
+        list_for_each_entry_safe(peer, tmp, &nets[netid].peers, node) {
                 list_del(&peer->node);
                 kfree(peer);
         }
+
+        free_netdev(ndev);
 }
 
 static void rionet_get_drvinfo(struct net_device *ndev,
@@ -435,13 +454,13 @@ static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
         const size_t rionet_active_bytes = sizeof(void *) *
                                 RIO_MAX_ROUTE_ENTRIES(mport->sys_size);
 
-        rionet_active = (struct rio_dev **)__get_free_pages(GFP_KERNEL,
-                        get_order(rionet_active_bytes));
-        if (!rionet_active) {
+        nets[mport->id].active = (struct rio_dev **)__get_free_pages(GFP_KERNEL,
+                                                get_order(rionet_active_bytes));
+        if (!nets[mport->id].active) {
                 rc = -ENOMEM;
                 goto out;
         }
-        memset((void *)rionet_active, 0, rionet_active_bytes);
+        memset((void *)nets[mport->id].active, 0, rionet_active_bytes);
 
         /* Set up private area */
         rnet = netdev_priv(ndev);
@@ -470,60 +489,62 @@ static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
         if (rc != 0)
                 goto out;
 
-        printk("%s: %s %s Version %s, MAC %pM\n",
+        printk(KERN_INFO "%s: %s %s Version %s, MAC %pM, %s\n",
                ndev->name,
                DRV_NAME,
                DRV_DESC,
                DRV_VERSION,
-               ndev->dev_addr);
+               ndev->dev_addr,
+               mport->name);
 
       out:
         return rc;
 }
 
-/*
- * XXX Make multi-net safe
- */
+static unsigned long net_table[RIONET_MAX_NETS/sizeof(unsigned long) + 1];
+
 static int rionet_probe(struct rio_dev *rdev, const struct rio_device_id *id)
 {
         int rc = -ENODEV;
         u32 lsrc_ops, ldst_ops;
         struct rionet_peer *peer;
         struct net_device *ndev = NULL;
+        unsigned char netid = rdev->net->hport->id;
+        int oldnet;
 
-        /* If local device is not rionet capable, give up quickly */
-        if (!rionet_capable)
-                goto out;
+        if (netid >= RIONET_MAX_NETS)
+                return rc;
 
-        /* Allocate our net_device structure */
-        ndev = alloc_etherdev(sizeof(struct rionet_private));
-        if (ndev == NULL) {
-                rc = -ENOMEM;
-                goto out;
-        }
+        oldnet = test_and_set_bit(netid, net_table);
 
         /*
          * First time through, make sure local device is rionet
-         * capable, setup netdev,  and set flags so this is skipped
-         * on later probes
+         * capable, setup netdev (will be skipped on later probes)
          */
-        if (!rionet_check) {
+        if (!oldnet) {
                 rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR,
                                          &lsrc_ops);
                 rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR,
                                          &ldst_ops);
                 if (!is_rionet_capable(lsrc_ops, ldst_ops)) {
                         printk(KERN_ERR
-                               "%s: local device is not network capable\n",
-                               DRV_NAME);
-                        rionet_check = 1;
-                        rionet_capable = 0;
+                               "%s: local device %s is not network capable\n",
+                               DRV_NAME, rdev->net->hport->name);
                         goto out;
                 }
 
+                /* Allocate our net_device structure */
+                ndev = alloc_etherdev(sizeof(struct rionet_private));
+                if (ndev == NULL) {
+                        rc = -ENOMEM;
+                        goto out;
+                }
+                nets[netid].ndev = ndev;
                 rc = rionet_setup_netdev(rdev->net->hport, ndev);
-                rionet_check = 1;
-        }
+                INIT_LIST_HEAD(&nets[netid].peers);
+                nets[netid].nact = 0;
+        } else if (nets[netid].ndev == NULL)
+                goto out;
 
         /*
          * If the remote device has mailbox/doorbell capabilities,
@@ -535,10 +556,10 @@ static int rionet_probe(struct rio_dev *rdev, const struct rio_device_id *id)
                         goto out;
                 }
                 peer->rdev = rdev;
-                list_add_tail(&peer->node, &rionet_peers);
+                list_add_tail(&peer->node, &nets[netid].peers);
         }
 
-        rio_set_drvdata(rdev, ndev);
+        rio_set_drvdata(rdev, nets[netid].ndev);
 
       out:
         return rc;
diff --git a/drivers/net/wan/z85230.c b/drivers/net/wan/z85230.c
index 0e5769061702..feacc3b994b7 100644
--- a/drivers/net/wan/z85230.c
+++ b/drivers/net/wan/z85230.c
@@ -1775,7 +1775,7 @@ EXPORT_SYMBOL(z8530_queue_xmit);
 /*
  *      Module support
  */
-static const char banner[] __initdata =
+static const char banner[] __initconst =
         KERN_INFO "Generic Z85C30/Z85230 interface driver v0.02\n";
 
 static int __init z85230_init_driver(void)
diff --git a/drivers/platform/x86/amilo-rfkill.c b/drivers/platform/x86/amilo-rfkill.c
index a514bf66fdd7..1deca7f6c4ea 100644
--- a/drivers/platform/x86/amilo-rfkill.c
+++ b/drivers/platform/x86/amilo-rfkill.c
@@ -74,7 +74,7 @@ static const struct rfkill_ops amilo_m7440_rfkill_ops = {
         .set_block = amilo_m7440_rfkill_set_block
 };
 
-static const struct dmi_system_id __devinitdata amilo_rfkill_id_table[] = {
+static const struct dmi_system_id __devinitconst amilo_rfkill_id_table[] = {
         {
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
diff --git a/drivers/platform/x86/fujitsu-tablet.c b/drivers/platform/x86/fujitsu-tablet.c
index 7acae3f85f3b..f77484528b1b 100644
--- a/drivers/platform/x86/fujitsu-tablet.c
+++ b/drivers/platform/x86/fujitsu-tablet.c
@@ -52,7 +52,7 @@ struct fujitsu_config {
         unsigned int quirks;
 };
 
-static unsigned short keymap_Lifebook_Tseries[KEYMAP_LEN] __initconst = {
+static unsigned short keymap_Lifebook_Tseries[KEYMAP_LEN] __initdata = {
         KEY_RESERVED,
         KEY_RESERVED,
         KEY_RESERVED,
@@ -71,7 +71,7 @@ static unsigned short keymap_Lifebook_Tseries[KEYMAP_LEN] __initconst = {
         KEY_LEFTALT
 };
 
-static unsigned short keymap_Lifebook_U810[KEYMAP_LEN] __initconst = {
+static unsigned short keymap_Lifebook_U810[KEYMAP_LEN] __initdata = {
         KEY_RESERVED,
         KEY_RESERVED,
         KEY_RESERVED,
@@ -90,7 +90,7 @@ static unsigned short keymap_Lifebook_U810[KEYMAP_LEN] __initconst = {
         KEY_LEFTALT
 };
 
-static unsigned short keymap_Stylistic_Tseries[KEYMAP_LEN] __initconst = {
+static unsigned short keymap_Stylistic_Tseries[KEYMAP_LEN] __initdata = {
         KEY_RESERVED,
         KEY_RESERVED,
         KEY_RESERVED,
@@ -109,7 +109,7 @@ static unsigned short keymap_Stylistic_Tseries[KEYMAP_LEN] __initconst = {
         KEY_LEFTALT
 };
 
-static unsigned short keymap_Stylistic_ST5xxx[KEYMAP_LEN] __initconst = {
+static unsigned short keymap_Stylistic_ST5xxx[KEYMAP_LEN] __initdata = {
         KEY_RESERVED,
         KEY_RESERVED,
         KEY_RESERVED,
@@ -299,7 +299,7 @@ static int __devinit fujitsu_dmi_stylistic(const struct dmi_system_id *dmi)
         return 1;
 }
 
-static struct dmi_system_id dmi_ids[] __initconst = {
+static const struct dmi_system_id dmi_ids[] __initconst = {
         {
                 .callback = fujitsu_dmi_lifebook,
                 .ident = "Fujitsu Siemens P/T Series",
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 9da5fe715e6a..75dd651664ae 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -522,7 +522,7 @@ static acpi_handle ec_handle;
 
 #define TPACPI_HANDLE(object, parent, paths...)                 \
         static acpi_handle  object##_handle;                    \
-        static const acpi_handle *object##_parent __initdata =  \
+        static const acpi_handle * const object##_parent __initconst =  \
                                                 &parent##_handle; \
         static char *object##_paths[] __initdata = { paths }
 
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
index e771487132f7..2420d5af0583 100644
--- a/drivers/pps/pps.c
+++ b/drivers/pps/pps.c
@@ -306,7 +306,7 @@ int pps_register_cdev(struct pps_device *pps)
         if (err < 0)
                 return err;
 
-        pps->id &= MAX_ID_MASK;
+        pps->id &= MAX_IDR_MASK;
         if (pps->id >= PPS_MAX_SOURCES) {
                 pr_err("%s: too many PPS sources in the system\n",
                                         pps->info.name);
diff --git a/drivers/rapidio/devices/tsi721.c b/drivers/rapidio/devices/tsi721.c
index d5e1625bbac2..38ecd8f4d60e 100644
--- a/drivers/rapidio/devices/tsi721.c
+++ b/drivers/rapidio/devices/tsi721.c
@@ -862,6 +862,90 @@ static void tsi721_init_pc2sr_mapping(struct tsi721_device *priv)
 }
 
 /**
+ * tsi721_rio_map_inb_mem -- Mapping inbound memory region.
+ * @mport: RapidIO master port
+ * @lstart: Local memory space start address.
+ * @rstart: RapidIO space start address.
+ * @size: The mapping region size.
+ * @flags: Flags for mapping. 0 for using default flags.
+ *
+ * Return: 0 -- Success.
+ *
+ * This function will create the inbound mapping
+ * from rstart to lstart.
+ */
+static int tsi721_rio_map_inb_mem(struct rio_mport *mport, dma_addr_t lstart,
+                u64 rstart, u32 size, u32 flags)
+{
+        struct tsi721_device *priv = mport->priv;
+        int i;
+        u32 regval;
+
+        if (!is_power_of_2(size) || size < 0x1000 ||
+            ((u64)lstart & (size - 1)) || (rstart & (size - 1)))
+                return -EINVAL;
+
+        /* Search for free inbound translation window */
+        for (i = 0; i < TSI721_IBWIN_NUM; i++) {
+                regval = ioread32(priv->regs + TSI721_IBWIN_LB(i));
+                if (!(regval & TSI721_IBWIN_LB_WEN))
+                        break;
+        }
+
+        if (i >= TSI721_IBWIN_NUM) {
+                dev_err(&priv->pdev->dev,
+                        "Unable to find free inbound window\n");
+                return -EBUSY;
+        }
+
+        iowrite32(TSI721_IBWIN_SIZE(size) << 8,
+                        priv->regs + TSI721_IBWIN_SZ(i));
+
+        iowrite32(((u64)lstart >> 32), priv->regs + TSI721_IBWIN_TUA(i));
+        iowrite32(((u64)lstart & TSI721_IBWIN_TLA_ADD),
+                  priv->regs + TSI721_IBWIN_TLA(i));
+
+        iowrite32(rstart >> 32, priv->regs + TSI721_IBWIN_UB(i));
+        iowrite32((rstart & TSI721_IBWIN_LB_BA) | TSI721_IBWIN_LB_WEN,
+                priv->regs + TSI721_IBWIN_LB(i));
+        dev_dbg(&priv->pdev->dev,
+                "Configured IBWIN%d mapping (RIO_0x%llx -> PCIe_0x%llx)\n",
+                i, rstart, (unsigned long long)lstart);
+
+        return 0;
+}
+
+/**
+ * fsl_rio_unmap_inb_mem -- Unmapping inbound memory region.
+ * @mport: RapidIO master port
+ * @lstart: Local memory space start address.
+ */
+static void tsi721_rio_unmap_inb_mem(struct rio_mport *mport,
+                                dma_addr_t lstart)
+{
+        struct tsi721_device *priv = mport->priv;
+        int i;
+        u64 addr;
+        u32 regval;
+
+        /* Search for matching active inbound translation window */
+        for (i = 0; i < TSI721_IBWIN_NUM; i++) {
+                regval = ioread32(priv->regs + TSI721_IBWIN_LB(i));
+                if (regval & TSI721_IBWIN_LB_WEN) {
+                        regval = ioread32(priv->regs + TSI721_IBWIN_TUA(i));
+                        addr = (u64)regval << 32;
+                        regval = ioread32(priv->regs + TSI721_IBWIN_TLA(i));
+                        addr |= regval & TSI721_IBWIN_TLA_ADD;
+
+                        if (addr == (u64)lstart) {
+                                iowrite32(0, priv->regs + TSI721_IBWIN_LB(i));
+                                break;
+                        }
+                }
+        }
+}
+
+/**
  * tsi721_init_sr2pc_mapping - initializes inbound (SRIO->PCIe)
  * translation regions.
  * @priv: pointer to tsi721 private data
@@ -874,7 +958,7 @@ static void tsi721_init_sr2pc_mapping(struct tsi721_device *priv)
 
         /* Disable all SR2PC inbound windows */
         for (i = 0; i < TSI721_IBWIN_NUM; i++)
-                iowrite32(0, priv->regs + TSI721_IBWINLB(i));
+                iowrite32(0, priv->regs + TSI721_IBWIN_LB(i));
 }
 
 /**
@@ -2144,6 +2228,8 @@ static int __devinit tsi721_setup_mport(struct tsi721_device *priv)
         ops->add_outb_message = tsi721_add_outb_message;
         ops->add_inb_buffer = tsi721_add_inb_buffer;
         ops->get_inb_message = tsi721_get_inb_message;
+        ops->map_inb = tsi721_rio_map_inb_mem;
+        ops->unmap_inb = tsi721_rio_unmap_inb_mem;
 
         mport = kzalloc(sizeof(struct rio_mport), GFP_KERNEL);
         if (!mport) {
@@ -2165,7 +2251,8 @@ static int __devinit tsi721_setup_mport(struct tsi721_device *priv)
         rio_init_dbell_res(&mport->riores[RIO_DOORBELL_RESOURCE], 0, 0xffff);
         rio_init_mbox_res(&mport->riores[RIO_INB_MBOX_RESOURCE], 0, 3);
         rio_init_mbox_res(&mport->riores[RIO_OUTB_MBOX_RESOURCE], 0, 3);
-        strcpy(mport->name, "Tsi721 mport");
+        snprintf(mport->name, RIO_MAX_MPORT_NAME, "%s(%s)",
+                 dev_driver_string(&pdev->dev), dev_name(&pdev->dev));
 
         /* Hook up interrupt handler */
 
@@ -2315,7 +2402,8 @@ static int __devinit tsi721_probe(struct pci_dev *pdev,
 
         /* Configure DMA attributes. */
         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
-                if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
+                err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+                if (err) {
                         dev_info(&pdev->dev, "Unable to set DMA mask\n");
                         goto err_unmap_bars;
                 }
diff --git a/drivers/rapidio/devices/tsi721.h b/drivers/rapidio/devices/tsi721.h
index 59de9d7be346..7d5b13ba8d4f 100644
--- a/drivers/rapidio/devices/tsi721.h
+++ b/drivers/rapidio/devices/tsi721.h
@@ -156,9 +156,18 @@
 
 #define TSI721_IBWIN_NUM        8
 
-#define TSI721_IBWINLB(x)       (0x29000 + (x) * 0x20)
-#define TSI721_IBWINLB_BA       0xfffff000
-#define TSI721_IBWINLB_WEN      0x00000001
+#define TSI721_IBWIN_LB(x)      (0x29000 + (x) * 0x20)
+#define TSI721_IBWIN_LB_BA      0xfffff000
+#define TSI721_IBWIN_LB_WEN     0x00000001
+
+#define TSI721_IBWIN_UB(x)      (0x29004 + (x) * 0x20)
+#define TSI721_IBWIN_SZ(x)      (0x29008 + (x) * 0x20)
+#define TSI721_IBWIN_SZ_SIZE    0x00001f00
+#define TSI721_IBWIN_SIZE(size) (__fls(size) - 12)
+
+#define TSI721_IBWIN_TLA(x)     (0x2900c + (x) * 0x20)
+#define TSI721_IBWIN_TLA_ADD    0xfffff000
+#define TSI721_IBWIN_TUA(x)     (0x29010 + (x) * 0x20)
 
 #define TSI721_SR2PC_GEN_INTE   0x29800
 #define TSI721_SR2PC_PWE        0x29804
diff --git a/drivers/rapidio/rio-scan.c b/drivers/rapidio/rio-scan.c
index 2bebd791a092..48e9041dd1e2 100644
--- a/drivers/rapidio/rio-scan.c
+++ b/drivers/rapidio/rio-scan.c
@@ -31,27 +31,21 @@
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <linux/timer.h>
+#include <linux/sched.h>
 #include <linux/jiffies.h>
 #include <linux/slab.h>
 
 #include "rio.h"
 
 LIST_HEAD(rio_devices);
-static LIST_HEAD(rio_switches);
-
-static void rio_enum_timeout(unsigned long);
 
 static void rio_init_em(struct rio_dev *rdev);
 
 DEFINE_SPINLOCK(rio_global_list_lock);
 
 static int next_destid = 0;
-static int next_net = 0;
 static int next_comptag = 1;
 
-static struct timer_list rio_enum_timer =
-TIMER_INITIALIZER(rio_enum_timeout, 0, 0);
-
 static int rio_mport_phys_table[] = {
         RIO_EFB_PAR_EP_ID,
         RIO_EFB_PAR_EP_REC_ID,
@@ -60,6 +54,114 @@ static int rio_mport_phys_table[] = {
         -1,
 };
 
+
+/*
+ * rio_destid_alloc - Allocate next available destID for given network
+ * net: RIO network
+ *
+ * Returns next available device destination ID for the specified RIO network.
+ * Marks allocated ID as one in use.
+ * Returns RIO_INVALID_DESTID if new destID is not available.
+ */
+static u16 rio_destid_alloc(struct rio_net *net)
+{
+        int destid;
+        struct rio_id_table *idtab = &net->destid_table;
+
+        spin_lock(&idtab->lock);
+        destid = find_next_zero_bit(idtab->table, idtab->max, idtab->next);
+        if (destid >= idtab->max)
+                destid = find_first_zero_bit(idtab->table, idtab->max);
+
+        if (destid < idtab->max) {
+                idtab->next = destid + 1;
+                if (idtab->next >= idtab->max)
+                        idtab->next = 0;
+                set_bit(destid, idtab->table);
+                destid += idtab->start;
+        } else
+                destid = RIO_INVALID_DESTID;
+
+        spin_unlock(&idtab->lock);
+        return (u16)destid;
+}
+
+/*
+ * rio_destid_reserve - Reserve the specivied destID
+ * net: RIO network
+ * destid: destID to reserve
+ *
+ * Tries to reserve the specified destID.
+ * Returns 0 if successfull.
+ */
+static int rio_destid_reserve(struct rio_net *net, u16 destid)
+{
+        int oldbit;
+        struct rio_id_table *idtab = &net->destid_table;
+
+        destid -= idtab->start;
+        spin_lock(&idtab->lock);
+        oldbit = test_and_set_bit(destid, idtab->table);
+        spin_unlock(&idtab->lock);
+        return oldbit;
+}
+
+/*
+ * rio_destid_free - free a previously allocated destID
+ * net: RIO network
+ * destid: destID to free
+ *
+ * Makes the specified destID available for use.
+ */
+static void rio_destid_free(struct rio_net *net, u16 destid)
+{
+        struct rio_id_table *idtab = &net->destid_table;
+
+        destid -= idtab->start;
+        spin_lock(&idtab->lock);
+        clear_bit(destid, idtab->table);
+        spin_unlock(&idtab->lock);
+}
+
+/*
+ * rio_destid_first - return first destID in use
+ * net: RIO network
+ */
+static u16 rio_destid_first(struct rio_net *net)
+{
+        int destid;
+        struct rio_id_table *idtab = &net->destid_table;
+
+        spin_lock(&idtab->lock);
+        destid = find_first_bit(idtab->table, idtab->max);
+        if (destid >= idtab->max)
+                destid = RIO_INVALID_DESTID;
+        else
+                destid += idtab->start;
+        spin_unlock(&idtab->lock);
+        return (u16)destid;
+}
+
+/*
+ * rio_destid_next - return next destID in use
+ * net: RIO network
+ * from: destination ID from which search shall continue
+ */
+static u16 rio_destid_next(struct rio_net *net, u16 from)
+{
+        int destid;
+        struct rio_id_table *idtab = &net->destid_table;
+
+        spin_lock(&idtab->lock);
+        destid = find_next_bit(idtab->table, idtab->max, from);
+        if (destid >= idtab->max)
+                destid = RIO_INVALID_DESTID;
+        else
+                destid += idtab->start;
+        spin_unlock(&idtab->lock);
+        return (u16)destid;
+}
+
 /**
  * rio_get_device_id - Get the base/extended device id for a device
  * @port: RIO master port
@@ -108,14 +210,15 @@ static void rio_local_set_device_id(struct rio_mport *port, u16 did)
 
 /**
  * rio_clear_locks- Release all host locks and signal enumeration complete
- * @port: Master port to issue transaction
+ * @net: RIO network to run on
  *
  * Marks the component tag CSR on each device with the enumeration
  * complete flag. When complete, it then release the host locks on
  * each device. Returns 0 on success or %-EINVAL on failure.
  */
-static int rio_clear_locks(struct rio_mport *port)
+static int rio_clear_locks(struct rio_net *net)
 {
+        struct rio_mport *port = net->hport;
         struct rio_dev *rdev;
         u32 result;
         int ret = 0;
@@ -130,7 +233,7 @@ static int rio_clear_locks(struct rio_mport *port)
                        result);
                 ret = -EINVAL;
         }
-        list_for_each_entry(rdev, &rio_devices, global_list) {
+        list_for_each_entry(rdev, &net->devices, net_list) {
                 rio_write_config_32(rdev, RIO_HOST_DID_LOCK_CSR,
                                     port->host_deviceid);
                 rio_read_config_32(rdev, RIO_HOST_DID_LOCK_CSR, &result);
@@ -176,10 +279,6 @@ static int rio_enum_host(struct rio_mport *port)
 
         /* Set master port destid and init destid ctr */
         rio_local_set_device_id(port, port->host_deviceid);
-
-        if (next_destid == port->host_deviceid)
-                next_destid++;
-
         return 0;
 }
 
@@ -446,9 +545,8 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
         if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops)) {
                 if (do_enum) {
                         rio_set_device_id(port, destid, hopcount, next_destid);
-                        rdev->destid = next_destid++;
-                        if (next_destid == port->host_deviceid)
-                                next_destid++;
+                        rdev->destid = next_destid;
+                        next_destid = rio_destid_alloc(net);
                 } else
                         rdev->destid = rio_get_device_id(port, destid, hopcount);
 
@@ -483,7 +581,7 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
                         rswitch->clr_table(port, destid, hopcount,
                                            RIO_GLOBAL_TABLE);
 
-                list_add_tail(&rswitch->node, &rio_switches);
+                list_add_tail(&rswitch->node, &net->switches);
 
         } else {
                 if (do_enum)
@@ -747,12 +845,7 @@ static u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount)
 static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                          u8 hopcount, struct rio_dev *prev, int prev_port)
 {
-        int port_num;
-        int cur_destid;
-        int sw_destid;
-        int sw_inport;
         struct rio_dev *rdev;
-        u16 destid;
         u32 regval;
         int tmp;
 
@@ -818,19 +911,26 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                 return -1;
 
         if (rio_is_switch(rdev)) {
+                int sw_destid;
+                int cur_destid;
+                int sw_inport;
+                u16 destid;
+                int port_num;
+
                 sw_inport = RIO_GET_PORT_NUM(rdev->swpinfo);
                 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
                                     port->host_deviceid, sw_inport, 0);
                 rdev->rswitch->route_table[port->host_deviceid] = sw_inport;
 
-                for (destid = 0; destid < next_destid; destid++) {
-                        if (destid == port->host_deviceid)
-                                continue;
-                        rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
-                                            destid, sw_inport, 0);
-                        rdev->rswitch->route_table[destid] = sw_inport;
+                destid = rio_destid_first(net);
+                while (destid != RIO_INVALID_DESTID && destid < next_destid) {
+                        if (destid != port->host_deviceid) {
+                                rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
+                                                    destid, sw_inport, 0);
+                                rdev->rswitch->route_table[destid] = sw_inport;
+                        }
+                        destid = rio_destid_next(net, destid + 1);
                 }
-
                 pr_debug(
                     "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
                     rio_name(rdev), rdev->vid, rdev->did,
@@ -839,12 +939,10 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                 for (port_num = 0;
                      port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo);
                      port_num++) {
-                        /*Enable Input Output Port (transmitter reviever)*/
-                        rio_enable_rx_tx_port(port, 0,
+                        if (sw_inport == port_num) {
+                                rio_enable_rx_tx_port(port, 0,
                                               RIO_ANY_DESTID(port->sys_size),
                                               hopcount, port_num);
-
-                        if (sw_inport == port_num) {
                                 rdev->rswitch->port_ok |= (1 << port_num);
                                 continue;
                         }
@@ -857,6 +955,9 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                                 pr_debug(
                                     "RIO: scanning device on port %d\n",
                                     port_num);
+                                rio_enable_rx_tx_port(port, 0,
+                                              RIO_ANY_DESTID(port->sys_size),
+                                              hopcount, port_num);
                                 rdev->rswitch->port_ok |= (1 << port_num);
                                 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
                                                 RIO_ANY_DESTID(port->sys_size),
@@ -867,19 +968,22 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                                         return -1;
 
                                 /* Update routing tables */
-                                if (next_destid > cur_destid) {
+                                destid = rio_destid_next(net, cur_destid + 1);
+                                if (destid != RIO_INVALID_DESTID) {
                                         for (destid = cur_destid;
-                                             destid < next_destid; destid++) {
-                                                if (destid == port->host_deviceid)
-                                                        continue;
-                                                rio_route_add_entry(rdev,
+                                             destid < next_destid;) {
+                                                if (destid != port->host_deviceid) {
+                                                        rio_route_add_entry(rdev,
                                                                     RIO_GLOBAL_TABLE,
                                                                     destid,
                                                                     port_num,
                                                                     0);
-                                                rdev->rswitch->
-                                                    route_table[destid] =
-                                                    port_num;
+                                                        rdev->rswitch->
+                                                                route_table[destid] =
+                                                                port_num;
+                                                }
+                                                destid = rio_destid_next(net,
+                                                                destid + 1);
                                         }
                                 }
                         } else {
@@ -905,11 +1009,8 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                 rio_init_em(rdev);
 
                 /* Check for empty switch */
-                if (next_destid == sw_destid) {
-                        next_destid++;
-                        if (next_destid == port->host_deviceid)
-                                next_destid++;
-                }
+                if (next_destid == sw_destid)
+                        next_destid = rio_destid_alloc(net);
 
                 rdev->destid = sw_destid;
         } else
@@ -1047,48 +1148,71 @@ static int rio_mport_is_active(struct rio_mport *port)
 /**
  * rio_alloc_net- Allocate and configure a new RIO network
  * @port: Master port associated with the RIO network
+ * @do_enum: Enumeration/Discovery mode flag
+ * @start: logical minimal start id for new net
  *
  * Allocates a RIO network structure, initializes per-network
  * list heads, and adds the associated master port to the
  * network list of associated master ports. Returns a
  * RIO network pointer on success or %NULL on failure.
  */
-static struct rio_net __devinit *rio_alloc_net(struct rio_mport *port)
+static struct rio_net __devinit *rio_alloc_net(struct rio_mport *port,
+                                               int do_enum, u16 start)
 {
         struct rio_net *net;
 
         net = kzalloc(sizeof(struct rio_net), GFP_KERNEL);
+        if (net && do_enum) {
+                net->destid_table.table = kzalloc(
+                        BITS_TO_LONGS(RIO_MAX_ROUTE_ENTRIES(port->sys_size)) *
+                        sizeof(long),
+                        GFP_KERNEL);
+
+                if (net->destid_table.table == NULL) {
+                        pr_err("RIO: failed to allocate destID table\n");
+                        kfree(net);
+                        net = NULL;
+                } else {
+                        net->destid_table.start = start;
+                        net->destid_table.next = 0;
+                        net->destid_table.max =
+                                        RIO_MAX_ROUTE_ENTRIES(port->sys_size);
+                        spin_lock_init(&net->destid_table.lock);
+                }
+        }
+
         if (net) {
                 INIT_LIST_HEAD(&net->node);
                 INIT_LIST_HEAD(&net->devices);
+                INIT_LIST_HEAD(&net->switches);
                 INIT_LIST_HEAD(&net->mports);
                 list_add_tail(&port->nnode, &net->mports);
                 net->hport = port;
-                net->id = next_net++;
+                net->id = port->id;
         }
         return net;
 }
 
 /**
  * rio_update_route_tables- Updates route tables in switches
- * @port: Master port associated with the RIO network
+ * @net: RIO network to run update on
  *
  * For each enumerated device, ensure that each switch in a system
  * has correct routing entries. Add routes for devices that where
  * unknown dirung the first enumeration pass through the switch.
  */
-static void rio_update_route_tables(struct rio_mport *port)
+static void rio_update_route_tables(struct rio_net *net)
 {
         struct rio_dev *rdev, *swrdev;
         struct rio_switch *rswitch;
         u8 sport;
         u16 destid;
 
-        list_for_each_entry(rdev, &rio_devices, global_list) {
+        list_for_each_entry(rdev, &net->devices, net_list) {
 
                 destid = rdev->destid;
 
-                list_for_each_entry(rswitch, &rio_switches, node) {
+                list_for_each_entry(rswitch, &net->switches, node) {
 
                         if (rio_is_switch(rdev) && (rdev->rswitch == rswitch))
                                 continue;
@@ -1166,12 +1290,16 @@ int __devinit rio_enum_mport(struct rio_mport *mport)
 
         /* If master port has an active link, allocate net and enum peers */
         if (rio_mport_is_active(mport)) {
-                if (!(net = rio_alloc_net(mport))) {
+                net = rio_alloc_net(mport, 1, 0);
+                if (!net) {
                         printk(KERN_ERR "RIO: failed to allocate new net\n");
                         rc = -ENOMEM;
                         goto out;
                 }
 
+                /* reserve mport destID in new net */
+                rio_destid_reserve(net, mport->host_deviceid);
+
                 /* Enable Input Output Port (transmitter reviever) */
                 rio_enable_rx_tx_port(mport, 1, 0, 0, 0);
 
@@ -1179,17 +1307,21 @@ int __devinit rio_enum_mport(struct rio_mport *mport)
                 rio_local_write_config_32(mport, RIO_COMPONENT_TAG_CSR,
                                           next_comptag++);
 
+                next_destid = rio_destid_alloc(net);
+
                 if (rio_enum_peer(net, mport, 0, NULL, 0) < 0) {
                         /* A higher priority host won enumeration, bail. */
                         printk(KERN_INFO
                                "RIO: master port %d device has lost enumeration to a remote host\n",
                                mport->id);
-                        rio_clear_locks(mport);
+                        rio_clear_locks(net);
                         rc = -EBUSY;
                         goto out;
                 }
-                rio_update_route_tables(mport);
-                rio_clear_locks(mport);
+                /* free the last allocated destID (unused) */
+                rio_destid_free(net, next_destid);
+                rio_update_route_tables(net);
+                rio_clear_locks(net);
                 rio_pw_enable(mport, 1);
         } else {
                 printk(KERN_INFO "RIO: master port %d link inactive\n",
@@ -1203,47 +1335,34 @@ int __devinit rio_enum_mport(struct rio_mport *mport)
 
 /**
  * rio_build_route_tables- Generate route tables from switch route entries
+ * @net: RIO network to run route tables scan on
  *
  * For each switch device, generate a route table by copying existing
  * route entries from the switch.
  */
-static void rio_build_route_tables(void)
+static void rio_build_route_tables(struct rio_net *net)
 {
+        struct rio_switch *rswitch;
         struct rio_dev *rdev;
         int i;
         u8 sport;
 
-        list_for_each_entry(rdev, &rio_devices, global_list)
-                if (rio_is_switch(rdev)) {
-                        rio_lock_device(rdev->net->hport, rdev->destid,
-                                        rdev->hopcount, 1000);
-                        for (i = 0;
-                             i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
-                             i++) {
-                                if (rio_route_get_entry(rdev,
-                                        RIO_GLOBAL_TABLE, i, &sport, 0) < 0)
-                                        continue;
-                                rdev->rswitch->route_table[i] = sport;
-                        }
+        list_for_each_entry(rswitch, &net->switches, node) {
+                rdev = sw_to_rio_dev(rswitch);
 
-                        rio_unlock_device(rdev->net->hport,
-                                          rdev->destid,
-                                          rdev->hopcount);
+                rio_lock_device(net->hport, rdev->destid,
+                                rdev->hopcount, 1000);
+                for (i = 0;
+                     i < RIO_MAX_ROUTE_ENTRIES(net->hport->sys_size);
+                     i++) {
+                        if (rio_route_get_entry(rdev, RIO_GLOBAL_TABLE,
+                                                i, &sport, 0) < 0)
+                                continue;
+                        rswitch->route_table[i] = sport;
                 }
-}
 
-/**
- * rio_enum_timeout- Signal that enumeration timed out
- * @data: Address of timeout flag.
- *
- * When the enumeration complete timer expires, set a flag that
- * signals to the discovery process that enumeration did not
- * complete in a sane amount of time.
- */
-static void rio_enum_timeout(unsigned long data)
-{
-        /* Enumeration timed out, set flag */
-        *(int *)data = 1;
+                rio_unlock_device(net->hport, rdev->destid, rdev->hopcount);
+        }
 }
 
 /**
@@ -1259,34 +1378,33 @@ static void rio_enum_timeout(unsigned long data)
 int __devinit rio_disc_mport(struct rio_mport *mport)
 {
         struct rio_net *net = NULL;
-        int enum_timeout_flag = 0;
+        unsigned long to_end;
 
         printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id,
                mport->name);
 
         /* If master port has an active link, allocate net and discover peers */
         if (rio_mport_is_active(mport)) {
-                if (!(net = rio_alloc_net(mport))) {
-                        printk(KERN_ERR "RIO: Failed to allocate new net\n");
-                        goto bail;
-                }
+                pr_debug("RIO: wait for enumeration to complete...\n");
 
-                pr_debug("RIO: wait for enumeration complete...");
-
-                rio_enum_timer.expires =
-                    jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ;
-                rio_enum_timer.data = (unsigned long)&enum_timeout_flag;
-                add_timer(&rio_enum_timer);
-                while (!rio_enum_complete(mport)) {
-                        mdelay(1);
-                        if (enum_timeout_flag) {
-                                del_timer_sync(&rio_enum_timer);
-                                goto timeout;
-                        }
+                to_end = jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ;
+                while (time_before(jiffies, to_end)) {
+                        if (rio_enum_complete(mport))
+                                goto enum_done;
+                        schedule_timeout_uninterruptible(msecs_to_jiffies(10));
                 }
-                del_timer_sync(&rio_enum_timer);
 
-                pr_debug("done\n");
+                pr_debug("RIO: discovery timeout on mport %d %s\n",
+                         mport->id, mport->name);
+                goto bail;
+enum_done:
+                pr_debug("RIO: ... enumeration done\n");
+
+                net = rio_alloc_net(mport, 0, 0);
+                if (!net) {
+                        printk(KERN_ERR "RIO: Failed to allocate new net\n");
+                        goto bail;
+                }
 
                 /* Read DestID assigned by enumerator */
                 rio_local_read_config_32(mport, RIO_DID_CSR,
@@ -1302,13 +1420,10 @@ int __devinit rio_disc_mport(struct rio_mport *mport)
                         goto bail;
                 }
 
-                rio_build_route_tables();
+                rio_build_route_tables(net);
         }
 
         return 0;
-
-      timeout:
-        pr_debug("timeout\n");
-      bail:
+bail:
         return -EBUSY;
 }
diff --git a/drivers/rapidio/rio.c b/drivers/rapidio/rio.c
index c40665a4fa33..d4bd69013c50 100644
--- a/drivers/rapidio/rio.c
+++ b/drivers/rapidio/rio.c
@@ -33,6 +33,7 @@
 
 static LIST_HEAD(rio_mports);
 static unsigned char next_portid;
+static DEFINE_SPINLOCK(rio_mmap_lock);
 
 /**
  * rio_local_get_device_id - Get the base/extended device id for a port
@@ -398,6 +399,49 @@ int rio_release_inb_pwrite(struct rio_dev *rdev)
 EXPORT_SYMBOL_GPL(rio_release_inb_pwrite);
 
 /**
+ * rio_map_inb_region -- Map inbound memory region.
+ * @mport: Master port.
+ * @lstart: physical address of memory region to be mapped
+ * @rbase: RIO base address assigned to this window
+ * @size: Size of the memory region
+ * @rflags: Flags for mapping.
+ *
+ * Return: 0 -- Success.
+ *
+ * This function will create the mapping from RIO space to local memory.
+ */
+int rio_map_inb_region(struct rio_mport *mport, dma_addr_t local,
+                        u64 rbase, u32 size, u32 rflags)
+{
+        int rc = 0;
+        unsigned long flags;
+
+        if (!mport->ops->map_inb)
+                return -1;
+        spin_lock_irqsave(&rio_mmap_lock, flags);
+        rc = mport->ops->map_inb(mport, local, rbase, size, rflags);
+        spin_unlock_irqrestore(&rio_mmap_lock, flags);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(rio_map_inb_region);
+
+/**
+ * rio_unmap_inb_region -- Unmap the inbound memory region
+ * @mport: Master port
+ * @lstart: physical address of memory region to be unmapped
+ */
+void rio_unmap_inb_region(struct rio_mport *mport, dma_addr_t lstart)
+{
+        unsigned long flags;
+        if (!mport->ops->unmap_inb)
+                return;
+        spin_lock_irqsave(&rio_mmap_lock, flags);
+        mport->ops->unmap_inb(mport, lstart);
+        spin_unlock_irqrestore(&rio_mmap_lock, flags);
+}
+EXPORT_SYMBOL_GPL(rio_unmap_inb_region);
+
+/**
  * rio_mport_get_physefb - Helper function that returns register offset
  *                      for Physical Layer Extended Features Block.
  * @port: Master port to issue transaction
@@ -1216,15 +1260,62 @@ static int __devinit rio_init(void)
         return 0;
 }
 
+static struct workqueue_struct *rio_wq;
+
+struct rio_disc_work {
+        struct work_struct      work;
+        struct rio_mport        *mport;
+};
+
+static void __devinit disc_work_handler(struct work_struct *_work)
+{
+        struct rio_disc_work *work;
+
+        work = container_of(_work, struct rio_disc_work, work);
+        pr_debug("RIO: discovery work for mport %d %s\n",
+                 work->mport->id, work->mport->name);
+        rio_disc_mport(work->mport);
+
+        kfree(work);
+}
+
 int __devinit rio_init_mports(void)
 {
         struct rio_mport *port;
+        struct rio_disc_work *work;
+        int no_disc = 0;
 
         list_for_each_entry(port, &rio_mports, node) {
                 if (port->host_deviceid >= 0)
                         rio_enum_mport(port);
-                else
-                        rio_disc_mport(port);
+                else if (!no_disc) {
+                        if (!rio_wq) {
+                                rio_wq = alloc_workqueue("riodisc", 0, 0);
+                                if (!rio_wq) {
+                                        pr_err("RIO: unable allocate rio_wq\n");
+                                        no_disc = 1;
+                                        continue;
+                                }
+                        }
+
+                        work = kzalloc(sizeof *work, GFP_KERNEL);
+                        if (!work) {
+                                pr_err("RIO: no memory for work struct\n");
+                                no_disc = 1;
+                                continue;
+                        }
+
+                        work->mport = port;
+                        INIT_WORK(&work->work, disc_work_handler);
+                        queue_work(rio_wq, &work->work);
+                }
+        }
+
+        if (rio_wq) {
+                pr_debug("RIO: flush discovery workqueue\n");
+                flush_workqueue(rio_wq);
+                pr_debug("RIO: flush discovery workqueue finished\n");
+                destroy_workqueue(rio_wq);
         }
 
         rio_init();
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index fabc99a75c65..e069f176a82d 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -19,7 +19,6 @@ if RTC_CLASS
 
 config RTC_HCTOSYS
         bool "Set system time from RTC on startup and resume"
-        depends on RTC_CLASS = y
         default y
         help
           If you say yes here, the system time (wall clock) will be set using
@@ -51,7 +50,6 @@ config RTC_HCTOSYS_DEVICE
 
 config RTC_DEBUG
         bool "RTC debug support"
-        depends on RTC_CLASS = y
         help
           Say yes here to enable debugging support in the RTC framework
           and individual RTC drivers.
@@ -61,7 +59,6 @@ comment "RTC interfaces"
 config RTC_INTF_SYSFS
         boolean "/sys/class/rtc/rtcN (sysfs)"
         depends on SYSFS
-        default RTC_CLASS
         help
           Say yes here if you want to use your RTCs using sysfs interfaces,
           /sys/class/rtc/rtc0 through /sys/.../rtcN.
@@ -69,19 +66,19 @@ config RTC_INTF_SYSFS
           If unsure, say Y.
 
 config RTC_INTF_PROC
-        boolean "/proc/driver/rtc (procfs for rtc0)"
+        boolean "/proc/driver/rtc (procfs for rtcN)"
         depends on PROC_FS
-        default RTC_CLASS
         help
-          Say yes here if you want to use your first RTC through the proc
-          interface, /proc/driver/rtc. Other RTCs will not be available
-          through that API.
+          Say yes here if you want to use your system clock RTC through
+          the proc interface, /proc/driver/rtc.
+          Other RTCs will not be available through that API.
+          If there is no RTC for the system clock, then the first RTC(rtc0)
+          is used by default.
 
           If unsure, say Y.
 
 config RTC_INTF_DEV
         boolean "/dev/rtcN (character devices)"
-        default RTC_CLASS
         help
           Say yes here if you want to use your RTCs using the /dev
           interfaces, which "udev" sets up as /dev/rtc0 through
@@ -127,7 +124,7 @@ if I2C
 
 config RTC_DRV_88PM860X
         tristate "Marvell 88PM860x"
-        depends on RTC_CLASS && I2C && MFD_88PM860X
+        depends on I2C && MFD_88PM860X
         help
           If you say yes here you get support for RTC function in Marvell
           88PM860x chips.
@@ -137,7 +134,7 @@ config RTC_DRV_88PM860X
 
 config RTC_DRV_88PM80X
         tristate "Marvell 88PM80x"
-        depends on RTC_CLASS && I2C && MFD_88PM800
+        depends on I2C && MFD_88PM800
         help
           If you say yes here you get support for RTC function in Marvell
           88PM80x chips.
@@ -165,7 +162,7 @@ config RTC_DRV_DS1307
 
 config RTC_DRV_DS1374
         tristate "Dallas/Maxim DS1374"
-        depends on RTC_CLASS && I2C
+        depends on I2C
         help
           If you say yes here you get support for Dallas Semiconductor
           DS1374 real-time clock chips. If an interrupt is associated
@@ -185,7 +182,7 @@ config RTC_DRV_DS1672
 
 config RTC_DRV_DS3232
         tristate "Dallas/Maxim DS3232"
-        depends on RTC_CLASS && I2C
+        depends on I2C
         help
           If you say yes here you get support for Dallas Semiconductor
           DS3232 real-time clock chips. If an interrupt is associated
@@ -203,6 +200,16 @@ config RTC_DRV_MAX6900
           This driver can also be built as a module. If so, the module
           will be called rtc-max6900.
 
+config RTC_DRV_MAX8907
+        tristate "Maxim MAX8907"
+        depends on MFD_MAX8907
+        help
+          If you say yes here you will get support for the
+          RTC of Maxim MAX8907 PMIC.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-max8907.
+
 config RTC_DRV_MAX8925
         tristate "Maxim MAX8925"
         depends on MFD_MAX8925
@@ -325,7 +332,7 @@ config RTC_DRV_TWL92330
 
 config RTC_DRV_TWL4030
         tristate "TI TWL4030/TWL5030/TWL6030/TPS659x0"
-        depends on RTC_CLASS && TWL4030_CORE
+        depends on TWL4030_CORE
         help
           If you say yes here you get support for the RTC on the
           TWL4030/TWL5030/TWL6030 family chips, used mostly with OMAP3 platforms.
@@ -333,6 +340,26 @@ config RTC_DRV_TWL4030
           This driver can also be built as a module. If so, the module
           will be called rtc-twl.
 
+config RTC_DRV_TPS65910
+        tristate "TI TPS65910 RTC driver"
+        depends on RTC_CLASS && MFD_TPS65910
+        help
+          If you say yes here you get support for the RTC on the
+          TPS65910 chips.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-tps65910.
+
+config RTC_DRV_RC5T583
+        tristate "RICOH 5T583 RTC driver"
+        depends on MFD_RC5T583
+        help
+          If you say yes here you get support for the RTC on the
+          RICOH 5T583 chips.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-rc5t583.
+
 config RTC_DRV_S35390A
         tristate "Seiko Instruments S-35390A"
         select BITREVERSE
@@ -538,7 +565,6 @@ config RTC_DRV_DS1302
 
 config RTC_DRV_DS1511
         tristate "Dallas DS1511"
-        depends on RTC_CLASS
         help
           If you say yes here you get support for the
           Dallas DS1511 timekeeping/watchdog chip.
@@ -583,7 +609,6 @@ config RTC_DRV_EFI
 
 config RTC_DRV_STK17TA8
         tristate "Simtek STK17TA8"
-        depends on RTC_CLASS
         help
           If you say yes here you get support for the
           Simtek STK17TA8 timekeeping chip.
@@ -658,6 +683,15 @@ config RTC_DRV_V3020
           This driver can also be built as a module. If so, the module
           will be called rtc-v3020.
 
+config RTC_DRV_DS2404
+        tristate "Dallas DS2404"
+        help
+          If you say yes here you get support for the
+          Dallas DS2404 RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds2404.
+
 config RTC_DRV_WM831X
         tristate "Wolfson Microelectronics WM831x RTC"
         depends on MFD_WM831X
@@ -704,6 +738,7 @@ config RTC_DRV_AB3100
 config RTC_DRV_AB8500
         tristate "ST-Ericsson AB8500 RTC"
         depends on AB8500_CORE
+        select RTC_INTF_DEV
         select RTC_INTF_DEV_UIE_EMUL
         help
           Select this to enable the ST-Ericsson AB8500 power management IC RTC
@@ -711,7 +746,7 @@ config RTC_DRV_AB8500
 
 config RTC_DRV_NUC900
         tristate "NUC910/NUC920 RTC driver"
-        depends on RTC_CLASS && ARCH_W90X900
+        depends on ARCH_W90X900
         help
           If you say yes here you get support for the RTC subsystem of the
           NUC910/NUC920 used in embedded systems.
@@ -731,7 +766,6 @@ config RTC_DRV_DAVINCI
 config RTC_DRV_IMXDI
         tristate "Freescale IMX DryIce Real Time Clock"
         depends on SOC_IMX25
-        depends on RTC_CLASS
         help
            Support for Freescale IMX DryIce RTC
 
@@ -791,7 +825,7 @@ config RTC_DRV_SA1100
 
 config RTC_DRV_SH
         tristate "SuperH On-Chip RTC"
-        depends on RTC_CLASS && SUPERH && HAVE_CLK
+        depends on SUPERH && HAVE_CLK
         help
           Say Y here to enable support for the on-chip RTC found in
           most SuperH processors.
@@ -1023,7 +1057,6 @@ config RTC_DRV_MPC5121
 
 config RTC_DRV_JZ4740
         tristate "Ingenic JZ4740 SoC"
-        depends on RTC_CLASS
         depends on MACH_JZ4740
         help
           If you say yes here you get support for the Ingenic JZ4740 SoC RTC
@@ -1053,7 +1086,7 @@ config RTC_DRV_PM8XXX
 
 config RTC_DRV_TEGRA
         tristate "NVIDIA Tegra Internal RTC driver"
-        depends on RTC_CLASS && ARCH_TEGRA
+        depends on ARCH_TEGRA
         help
           If you say yes here you get support for the
           Tegra 200 series internal RTC module.
@@ -1090,7 +1123,6 @@ config RTC_DRV_LOONGSON1
 config RTC_DRV_MXC
         tristate "Freescale MXC Real Time Clock"
         depends on ARCH_MXC
-        depends on RTC_CLASS
         help
            If you say yes here you get support for the Freescale MXC
            RTC module.
@@ -1098,4 +1130,15 @@ config RTC_DRV_MXC
            This driver can also be built as a module, if so, the module
            will be called "rtc-mxc".
 
+config RTC_DRV_SNVS
+        tristate "Freescale SNVS RTC support"
+        depends on HAS_IOMEM
+        depends on OF
+        help
+           If you say yes here you get support for the Freescale SNVS
+           Low Power (LP) RTC module.
+
+           This driver can also be built as a module, if so, the module
+           will be called "rtc-snvs".
+
 endif # RTC_CLASS
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 0d5b2b66f90d..56297f0fd388 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -43,6 +43,7 @@ obj-$(CONFIG_RTC_DRV_DS1511)	+= rtc-ds1511.o
 obj-$(CONFIG_RTC_DRV_DS1553)    += rtc-ds1553.o
 obj-$(CONFIG_RTC_DRV_DS1672)    += rtc-ds1672.o
 obj-$(CONFIG_RTC_DRV_DS1742)    += rtc-ds1742.o
+obj-$(CONFIG_RTC_DRV_DS2404)    += rtc-ds2404.o
 obj-$(CONFIG_RTC_DRV_DS3232)    += rtc-ds3232.o
 obj-$(CONFIG_RTC_DRV_DS3234)    += rtc-ds3234.o
 obj-$(CONFIG_RTC_DRV_EFI)       += rtc-efi.o
@@ -64,6 +65,7 @@ obj-$(CONFIG_RTC_DRV_M48T59)	+= rtc-m48t59.o
 obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
 obj-$(CONFIG_RTC_DRV_MXC)       += rtc-mxc.o
 obj-$(CONFIG_RTC_DRV_MAX6900)   += rtc-max6900.o
+obj-$(CONFIG_RTC_DRV_MAX8907)   += rtc-max8907.o
 obj-$(CONFIG_RTC_DRV_MAX8925)   += rtc-max8925.o
 obj-$(CONFIG_RTC_DRV_MAX8998)   += rtc-max8998.o
 obj-$(CONFIG_RTC_DRV_MAX6902)   += rtc-max6902.o
@@ -85,6 +87,7 @@ obj-$(CONFIG_RTC_DRV_PS3)	+= rtc-ps3.o
 obj-$(CONFIG_RTC_DRV_PUV3)      += rtc-puv3.o
 obj-$(CONFIG_RTC_DRV_PXA)       += rtc-pxa.o
 obj-$(CONFIG_RTC_DRV_R9701)     += rtc-r9701.o
+obj-$(CONFIG_RTC_DRV_RC5T583)   += rtc-rc5t583.o
 obj-$(CONFIG_RTC_DRV_RP5C01)    += rtc-rp5c01.o
 obj-$(CONFIG_RTC_DRV_RS5C313)   += rtc-rs5c313.o
 obj-$(CONFIG_RTC_DRV_RS5C348)   += rtc-rs5c348.o
@@ -96,6 +99,7 @@ obj-$(CONFIG_RTC_DRV_S35390A)	+= rtc-s35390a.o
 obj-$(CONFIG_RTC_DRV_S3C)       += rtc-s3c.o
 obj-$(CONFIG_RTC_DRV_SA1100)    += rtc-sa1100.o
 obj-$(CONFIG_RTC_DRV_SH)        += rtc-sh.o
+obj-$(CONFIG_RTC_DRV_SNVS)      += rtc-snvs.o
 obj-$(CONFIG_RTC_DRV_SPEAR)     += rtc-spear.o
 obj-$(CONFIG_RTC_DRV_STARFIRE)  += rtc-starfire.o
 obj-$(CONFIG_RTC_DRV_STK17TA8)  += rtc-stk17ta8.o
@@ -105,6 +109,7 @@ obj-$(CONFIG_RTC_DRV_TEGRA)	+= rtc-tegra.o
 obj-$(CONFIG_RTC_DRV_TEST)      += rtc-test.o
 obj-$(CONFIG_RTC_DRV_TILE)      += rtc-tile.o
 obj-$(CONFIG_RTC_DRV_TWL4030)   += rtc-twl.o
+obj-$(CONFIG_RTC_DRV_TPS65910)  += rtc-tps65910.o
 obj-$(CONFIG_RTC_DRV_TX4939)    += rtc-tx4939.o
 obj-$(CONFIG_RTC_DRV_V3020)     += rtc-v3020.o
 obj-$(CONFIG_RTC_DRV_VR41XX)    += rtc-vr41xx.o
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index dc4c2748bbc3..f8a0aab218cb 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -31,8 +31,12 @@ static void rtc_device_release(struct device *dev)
         kfree(rtc);
 }
 
-#if defined(CONFIG_PM) && defined(CONFIG_RTC_HCTOSYS_DEVICE)
+#ifdef CONFIG_RTC_HCTOSYS_DEVICE
+/* Result of the last RTC to system clock attempt. */
+int rtc_hctosys_ret = -ENODEV;
+#endif
 
+#if defined(CONFIG_PM) && defined(CONFIG_RTC_HCTOSYS_DEVICE)
 /*
  * On suspend(), measure the delta between one RTC and the
  * system's wall clock; restore it on resume().
@@ -84,6 +88,7 @@ static int rtc_resume(struct device *dev)
         struct timespec         new_system, new_rtc;
         struct timespec         sleep_time;
 
+        rtc_hctosys_ret = -ENODEV;
         if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
                 return 0;
 
@@ -117,6 +122,7 @@ static int rtc_resume(struct device *dev)
 
         if (sleep_time.tv_sec >= 0)
                 timekeeping_inject_sleeptime(&sleep_time);
+        rtc_hctosys_ret = 0;
         return 0;
 }
 
@@ -238,6 +244,7 @@ void rtc_device_unregister(struct rtc_device *rtc)
                 rtc_proc_del_device(rtc);
                 device_unregister(&rtc->dev);
                 rtc->ops = NULL;
+                ida_simple_remove(&rtc_ida, rtc->id);
                 mutex_unlock(&rtc->ops_lock);
                 put_device(&rtc->dev);
         }
diff --git a/drivers/rtc/hctosys.c b/drivers/rtc/hctosys.c
index bc90b091f195..4aa60d74004e 100644
--- a/drivers/rtc/hctosys.c
+++ b/drivers/rtc/hctosys.c
@@ -22,8 +22,6 @@
  * the best guess is to add 0.5s.
  */
 
-int rtc_hctosys_ret = -ENODEV;
-
 static int __init rtc_hctosys(void)
 {
         int err = -ENODEV;
@@ -56,7 +54,7 @@ static int __init rtc_hctosys(void)
 
         rtc_tm_to_time(&tm, &tv.tv_sec);
 
-        do_settimeofday(&tv);
+        err = do_settimeofday(&tv);
 
         dev_info(rtc->dev.parent,
                 "setting system clock to "
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index 1dd61f402b04..2dfe7a2fb998 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -473,18 +473,7 @@ static struct platform_driver at91_rtc_driver = {
         },
 };
 
-static int __init at91_rtc_init(void)
-{
-        return platform_driver_register(&at91_rtc_driver);
-}
-module_init(at91_rtc_init);
-
-static void __exit at91_rtc_exit(void)
-{
-        platform_driver_unregister(&at91_rtc_driver);
-}
-module_exit(at91_rtc_exit);
-
+module_platform_driver(at91_rtc_driver);
 
 MODULE_AUTHOR("Michel Benoit");
 MODULE_DESCRIPTION("RTC driver for Atmel AT91SAM9x");
diff --git a/drivers/rtc/rtc-coh901331.c b/drivers/rtc/rtc-coh901331.c
index 76b2156d3c62..c8115b83e5ab 100644
--- a/drivers/rtc/rtc-coh901331.c
+++ b/drivers/rtc/rtc-coh901331.c
@@ -276,8 +276,7 @@ static void coh901331_shutdown(struct platform_device *pdev)
 
         clk_enable(rtap->clk);
         writel(0, rtap->virtbase + COH901331_IRQ_MASK);
-        clk_disable(rtap->clk);
-        clk_unprepare(rtap->clk);
+        clk_disable_unprepare(rtap->clk);
 }
 
 static struct platform_driver coh901331_driver = {
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
index 7fa67d0df172..45d65c0b3a85 100644
--- a/drivers/rtc/rtc-ds1672.c
+++ b/drivers/rtc/rtc-ds1672.c
@@ -37,8 +37,17 @@ static int ds1672_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         unsigned char buf[4];
 
         struct i2c_msg msgs[] = {
-                {client->addr, 0, 1, &addr},    /* setup read ptr */
-                {client->addr, I2C_M_RD, 4, buf},       /* read date */
+                {/* setup read ptr */
+                        .addr = client->addr,
+                        .len = 1,
+                        .buf = &addr
+                },
+                {/* read date */
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 4,
+                        .buf = buf
+                },
         };
 
         /* read date registers */
@@ -99,8 +108,17 @@ static int ds1672_get_control(struct i2c_client *client, u8 *status)
         unsigned char addr = DS1672_REG_CONTROL;
 
         struct i2c_msg msgs[] = {
-                {client->addr, 0, 1, &addr},    /* setup read ptr */
-                {client->addr, I2C_M_RD, 1, status},    /* read control */
+                {/* setup read ptr */
+                        .addr = client->addr,
+                        .len = 1,
+                        .buf = &addr
+                },
+                {/* read control */
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = status
+                },
         };
 
         /* read control register */
diff --git a/drivers/rtc/rtc-ds2404.c b/drivers/rtc/rtc-ds2404.c
new file mode 100644
index 000000000000..5ea9df7c8c31
--- /dev/null
+++ b/drivers/rtc/rtc-ds2404.c
@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2012 Sven Schnelle <svens@stackframe.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/rtc.h>
+#include <linux/types.h>
+#include <linux/bcd.h>
+#include <linux/rtc-ds2404.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+
+#include <linux/io.h>
+
+#define DS2404_STATUS_REG 0x200
+#define DS2404_CONTROL_REG 0x201
+#define DS2404_RTC_REG 0x202
+
+#define DS2404_WRITE_SCRATCHPAD_CMD 0x0f
+#define DS2404_READ_SCRATCHPAD_CMD 0xaa
+#define DS2404_COPY_SCRATCHPAD_CMD 0x55
+#define DS2404_READ_MEMORY_CMD 0xf0
+
+struct ds2404;
+
+struct ds2404_chip_ops {
+        int (*map_io)(struct ds2404 *chip, struct platform_device *pdev,
+                      struct ds2404_platform_data *pdata);
+        void (*unmap_io)(struct ds2404 *chip);
+};
+
+#define DS2404_RST      0
+#define DS2404_CLK      1
+#define DS2404_DQ       2
+
+struct ds2404_gpio {
+        const char *name;
+        unsigned int gpio;
+};
+
+struct ds2404 {
+        struct ds2404_gpio *gpio;
+        struct ds2404_chip_ops *ops;
+        struct rtc_device *rtc;
+};
+
+static struct ds2404_gpio ds2404_gpio[] = {
+        { "RTC RST", 0 },
+        { "RTC CLK", 0 },
+        { "RTC DQ", 0 },
+};
+
+static int ds2404_gpio_map(struct ds2404 *chip, struct platform_device *pdev,
+                          struct ds2404_platform_data *pdata)
+{
+        int i, err;
+
+        ds2404_gpio[DS2404_RST].gpio = pdata->gpio_rst;
+        ds2404_gpio[DS2404_CLK].gpio = pdata->gpio_clk;
+        ds2404_gpio[DS2404_DQ].gpio = pdata->gpio_dq;
+
+        for (i = 0; i < ARRAY_SIZE(ds2404_gpio); i++) {
+                err = gpio_request(ds2404_gpio[i].gpio, ds2404_gpio[i].name);
+                if (err) {
+                        printk(KERN_ERR "error mapping gpio %s: %d\n",
+                                ds2404_gpio[i].name, err);
+                        goto err_request;
+                }
+                if (i != DS2404_DQ)
+                        gpio_direction_output(ds2404_gpio[i].gpio, 1);
+        }
+
+        chip->gpio = ds2404_gpio;
+        return 0;
+
+err_request:
+        while (--i >= 0)
+                gpio_free(ds2404_gpio[i].gpio);
+        return err;
+}
+
+static void ds2404_gpio_unmap(struct ds2404 *chip)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(ds2404_gpio); i++)
+                gpio_free(ds2404_gpio[i].gpio);
+}
+
+static struct ds2404_chip_ops ds2404_gpio_ops = {
+        .map_io         = ds2404_gpio_map,
+        .unmap_io       = ds2404_gpio_unmap,
+};
+
+static void ds2404_reset(struct device *dev)
+{
+        gpio_set_value(ds2404_gpio[DS2404_RST].gpio, 0);
+        udelay(1000);
+        gpio_set_value(ds2404_gpio[DS2404_RST].gpio, 1);
+        gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 0);
+        gpio_direction_output(ds2404_gpio[DS2404_DQ].gpio, 0);
+        udelay(10);
+}
+
+static void ds2404_write_byte(struct device *dev, u8 byte)
+{
+        int i;
+
+        gpio_direction_output(ds2404_gpio[DS2404_DQ].gpio, 1);
+        for (i = 0; i < 8; i++) {
+                gpio_set_value(ds2404_gpio[DS2404_DQ].gpio, byte & (1 << i));
+                udelay(10);
+                gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 1);
+                udelay(10);
+                gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 0);
+                udelay(10);
+        }
+}
+
+static u8 ds2404_read_byte(struct device *dev)
+{
+        int i;
+        u8 ret = 0;
+
+        gpio_direction_input(ds2404_gpio[DS2404_DQ].gpio);
+
+        for (i = 0; i < 8; i++) {
+                gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 0);
+                udelay(10);
+                if (gpio_get_value(ds2404_gpio[DS2404_DQ].gpio))
+                        ret |= 1 << i;
+                gpio_set_value(ds2404_gpio[DS2404_CLK].gpio, 1);
+                udelay(10);
+        }
+        return ret;
+}
+
+static void ds2404_read_memory(struct device *dev, u16 offset,
+                               int length, u8 *out)
+{
+        ds2404_reset(dev);
+        ds2404_write_byte(dev, DS2404_READ_MEMORY_CMD);
+        ds2404_write_byte(dev, offset & 0xff);
+        ds2404_write_byte(dev, (offset >> 8) & 0xff);
+        while (length--)
+                *out++ = ds2404_read_byte(dev);
+}
+
+static void ds2404_write_memory(struct device *dev, u16 offset,
+                                int length, u8 *out)
+{
+        int i;
+        u8 ta01, ta02, es;
+
+        ds2404_reset(dev);
+        ds2404_write_byte(dev, DS2404_WRITE_SCRATCHPAD_CMD);
+        ds2404_write_byte(dev, offset & 0xff);
+        ds2404_write_byte(dev, (offset >> 8) & 0xff);
+
+        for (i = 0; i < length; i++)
+                ds2404_write_byte(dev, out[i]);
+
+        ds2404_reset(dev);
+        ds2404_write_byte(dev, DS2404_READ_SCRATCHPAD_CMD);
+
+        ta01 = ds2404_read_byte(dev);
+        ta02 = ds2404_read_byte(dev);
+        es = ds2404_read_byte(dev);
+
+        for (i = 0; i < length; i++) {
+                if (out[i] != ds2404_read_byte(dev)) {
+                        printk(KERN_ERR "read invalid data\n");
+                        return;
+                }
+        }
+
+        ds2404_reset(dev);
+        ds2404_write_byte(dev, DS2404_COPY_SCRATCHPAD_CMD);
+        ds2404_write_byte(dev, ta01);
+        ds2404_write_byte(dev, ta02);
+        ds2404_write_byte(dev, es);
+
+        gpio_direction_input(ds2404_gpio[DS2404_DQ].gpio);
+        while (gpio_get_value(ds2404_gpio[DS2404_DQ].gpio))
+                ;
+}
+
+static void ds2404_enable_osc(struct device *dev)
+{
+        u8 in[1] = { 0x10 }; /* enable oscillator */
+        ds2404_write_memory(dev, 0x201, 1, in);
+}
+
+static int ds2404_read_time(struct device *dev, struct rtc_time *dt)
+{
+        unsigned long time = 0;
+
+        ds2404_read_memory(dev, 0x203, 4, (u8 *)&time);
+        time = le32_to_cpu(time);
+
+        rtc_time_to_tm(time, dt);
+        return rtc_valid_tm(dt);
+}
+
+static int ds2404_set_mmss(struct device *dev, unsigned long secs)
+{
+        u32 time = cpu_to_le32(secs);
+        ds2404_write_memory(dev, 0x203, 4, (u8 *)&time);
+        return 0;
+}
+
+static const struct rtc_class_ops ds2404_rtc_ops = {
+        .read_time      = ds2404_read_time,
+        .set_mmss       = ds2404_set_mmss,
+};
+
+static int rtc_probe(struct platform_device *pdev)
+{
+        struct ds2404_platform_data *pdata = pdev->dev.platform_data;
+        struct ds2404 *chip;
+        int retval = -EBUSY;
+
+        chip = kzalloc(sizeof(struct ds2404), GFP_KERNEL);
+        if (!chip)
+                return -ENOMEM;
+
+        chip->ops = &ds2404_gpio_ops;
+
+        retval = chip->ops->map_io(chip, pdev, pdata);
+        if (retval)
+                goto err_chip;
+
+        dev_info(&pdev->dev, "using GPIOs RST:%d, CLK:%d, DQ:%d\n",
+                 chip->gpio[DS2404_RST].gpio, chip->gpio[DS2404_CLK].gpio,
+                 chip->gpio[DS2404_DQ].gpio);
+
+        platform_set_drvdata(pdev, chip);
+
+        chip->rtc = rtc_device_register("ds2404",
+                                &pdev->dev, &ds2404_rtc_ops, THIS_MODULE);
+        if (IS_ERR(chip->rtc)) {
+                retval = PTR_ERR(chip->rtc);
+                goto err_io;
+        }
+
+        ds2404_enable_osc(&pdev->dev);
+        return 0;
+
+err_io:
+        chip->ops->unmap_io(chip);
+err_chip:
+        kfree(chip);
+        return retval;
+}
+
+static int rtc_remove(struct platform_device *dev)
+{
+        struct ds2404 *chip = platform_get_drvdata(dev);
+        struct rtc_device *rtc = chip->rtc;
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        chip->ops->unmap_io(chip);
+        kfree(chip);
+
+        return 0;
+}
+
+static struct platform_driver rtc_device_driver = {
+        .probe  = rtc_probe,
+        .remove = rtc_remove,
+        .driver = {
+                .name   = "ds2404",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static __init int ds2404_init(void)
+{
+        return platform_driver_register(&rtc_device_driver);
+}
+
+static __exit void ds2404_exit(void)
+{
+        platform_driver_unregister(&rtc_device_driver);
+}
+
+module_init(ds2404_init);
+module_exit(ds2404_exit);
+
+MODULE_DESCRIPTION("DS2404 RTC");
+MODULE_AUTHOR("Sven Schnelle");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ds2404");
diff --git a/drivers/rtc/rtc-em3027.c b/drivers/rtc/rtc-em3027.c
index 0104ea7ebe50..f6c24ce35d36 100644
--- a/drivers/rtc/rtc-em3027.c
+++ b/drivers/rtc/rtc-em3027.c
@@ -49,8 +49,17 @@ static int em3027_get_time(struct device *dev, struct rtc_time *tm)
         unsigned char buf[7];
 
         struct i2c_msg msgs[] = {
-                {client->addr, 0, 1, &addr},            /* setup read addr */
-                {client->addr, I2C_M_RD, 7, buf},       /* read time/date */
+                {/* setup read addr */
+                        .addr = client->addr,
+                        .len = 1,
+                        .buf = &addr
+                },
+                {/* read time/date */
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 7,
+                        .buf = buf
+                },
         };
 
         /* read time/date registers */
@@ -76,7 +85,9 @@ static int em3027_set_time(struct device *dev, struct rtc_time *tm)
         unsigned char buf[8];
 
         struct i2c_msg msg = {
-                client->addr, 0, 8, buf,        /* write time/date */
+                .addr = client->addr,
+                .len = 8,
+                .buf = buf,     /* write time/date */
         };
 
         buf[0] = EM3027_REG_WATCH_SEC;
diff --git a/drivers/rtc/rtc-isl1208.c b/drivers/rtc/rtc-isl1208.c
index dd2aeee6c66a..26c81f233606 100644
--- a/drivers/rtc/rtc-isl1208.c
+++ b/drivers/rtc/rtc-isl1208.c
@@ -68,9 +68,17 @@ isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[],
 {
         u8 reg_addr[1] = { reg };
         struct i2c_msg msgs[2] = {
-                {client->addr, 0, sizeof(reg_addr), reg_addr}
-                ,
-                {client->addr, I2C_M_RD, len, buf}
+                {
+                        .addr = client->addr,
+                        .len = sizeof(reg_addr),
+                        .buf = reg_addr
+                },
+                {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = len,
+                        .buf = buf
+                }
         };
         int ret;
 
@@ -90,7 +98,11 @@ isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[],
 {
         u8 i2c_buf[ISL1208_REG_USR2 + 2];
         struct i2c_msg msgs[1] = {
-                {client->addr, 0, len + 1, i2c_buf}
+                {
+                        .addr = client->addr,
+                        .len = len + 1,
+                        .buf = i2c_buf
+                }
         };
         int ret;
 
@@ -697,6 +709,7 @@ isl1208_remove(struct i2c_client *client)
 
 static const struct i2c_device_id isl1208_id[] = {
         { "isl1208", 0 },
+        { "isl1218", 0 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, isl1208_id);
diff --git a/drivers/rtc/rtc-jz4740.c b/drivers/rtc/rtc-jz4740.c
index 05ab227eeff7..1224182d3eab 100644
--- a/drivers/rtc/rtc-jz4740.c
+++ b/drivers/rtc/rtc-jz4740.c
@@ -42,7 +42,7 @@ struct jz4740_rtc {
 
         struct rtc_device *rtc;
 
-        unsigned int irq;
+        int irq;
 
         spinlock_t lock;
 };
diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
index 4e0f84af99a7..b885bcd08908 100644
--- a/drivers/rtc/rtc-m41t80.c
+++ b/drivers/rtc/rtc-m41t80.c
@@ -213,163 +213,14 @@ static int m41t80_rtc_set_time(struct device *dev, struct rtc_time *tm)
         return m41t80_set_datetime(to_i2c_client(dev), tm);
 }
 
-static int m41t80_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        int rc;
-
-        rc = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_MON);
-        if (rc < 0)
-                goto err;
-
-        if (enabled)
-                rc |= M41T80_ALMON_AFE;
-        else
-                rc &= ~M41T80_ALMON_AFE;
-
-        if (i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON, rc) < 0)
-                goto err;
-
-        return 0;
-err:
-        return -EIO;
-}
-
-static int m41t80_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *t)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        u8 wbuf[1 + M41T80_ALARM_REG_SIZE];
-        u8 *buf = &wbuf[1];
-        u8 *reg = buf - M41T80_REG_ALARM_MON;
-        u8 dt_addr[1] = { M41T80_REG_ALARM_MON };
-        struct i2c_msg msgs_in[] = {
-                {
-                        .addr   = client->addr,
-                        .flags  = 0,
-                        .len    = 1,
-                        .buf    = dt_addr,
-                },
-                {
-                        .addr   = client->addr,
-                        .flags  = I2C_M_RD,
-                        .len    = M41T80_ALARM_REG_SIZE,
-                        .buf    = buf,
-                },
-        };
-        struct i2c_msg msgs[] = {
-                {
-                        .addr   = client->addr,
-                        .flags  = 0,
-                        .len    = 1 + M41T80_ALARM_REG_SIZE,
-                        .buf    = wbuf,
-                 },
-        };
-
-        if (i2c_transfer(client->adapter, msgs_in, 2) < 0) {
-                dev_err(&client->dev, "read error\n");
-                return -EIO;
-        }
-        reg[M41T80_REG_ALARM_MON] &= ~(0x1f | M41T80_ALMON_AFE);
-        reg[M41T80_REG_ALARM_DAY] = 0;
-        reg[M41T80_REG_ALARM_HOUR] &= ~(0x3f | 0x80);
-        reg[M41T80_REG_ALARM_MIN] = 0;
-        reg[M41T80_REG_ALARM_SEC] = 0;
-
-        wbuf[0] = M41T80_REG_ALARM_MON; /* offset into rtc's regs */
-        reg[M41T80_REG_ALARM_SEC] |= t->time.tm_sec >= 0 ?
-                bin2bcd(t->time.tm_sec) : 0x80;
-        reg[M41T80_REG_ALARM_MIN] |= t->time.tm_min >= 0 ?
-                bin2bcd(t->time.tm_min) : 0x80;
-        reg[M41T80_REG_ALARM_HOUR] |= t->time.tm_hour >= 0 ?
-                bin2bcd(t->time.tm_hour) : 0x80;
-        reg[M41T80_REG_ALARM_DAY] |= t->time.tm_mday >= 0 ?
-                bin2bcd(t->time.tm_mday) : 0x80;
-        if (t->time.tm_mon >= 0)
-                reg[M41T80_REG_ALARM_MON] |= bin2bcd(t->time.tm_mon + 1);
-        else
-                reg[M41T80_REG_ALARM_DAY] |= 0x40;
-
-        if (i2c_transfer(client->adapter, msgs, 1) != 1) {
-                dev_err(&client->dev, "write error\n");
-                return -EIO;
-        }
-
-        if (t->enabled) {
-                reg[M41T80_REG_ALARM_MON] |= M41T80_ALMON_AFE;
-                if (i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON,
-                                              reg[M41T80_REG_ALARM_MON]) < 0) {
-                        dev_err(&client->dev, "write error\n");
-                        return -EIO;
-                }
-        }
-        return 0;
-}
-
-static int m41t80_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *t)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        u8 buf[M41T80_ALARM_REG_SIZE + 1]; /* all alarm regs and flags */
-        u8 dt_addr[1] = { M41T80_REG_ALARM_MON };
-        u8 *reg = buf - M41T80_REG_ALARM_MON;
-        struct i2c_msg msgs[] = {
-                {
-                        .addr   = client->addr,
-                        .flags  = 0,
-                        .len    = 1,
-                        .buf    = dt_addr,
-                },
-                {
-                        .addr   = client->addr,
-                        .flags  = I2C_M_RD,
-                        .len    = M41T80_ALARM_REG_SIZE + 1,
-                        .buf    = buf,
-                },
-        };
-
-        if (i2c_transfer(client->adapter, msgs, 2) < 0) {
-                dev_err(&client->dev, "read error\n");
-                return -EIO;
-        }
-        t->time.tm_sec = -1;
-        t->time.tm_min = -1;
-        t->time.tm_hour = -1;
-        t->time.tm_mday = -1;
-        t->time.tm_mon = -1;
-        if (!(reg[M41T80_REG_ALARM_SEC] & 0x80))
-                t->time.tm_sec = bcd2bin(reg[M41T80_REG_ALARM_SEC] & 0x7f);
-        if (!(reg[M41T80_REG_ALARM_MIN] & 0x80))
-                t->time.tm_min = bcd2bin(reg[M41T80_REG_ALARM_MIN] & 0x7f);
-        if (!(reg[M41T80_REG_ALARM_HOUR] & 0x80))
-                t->time.tm_hour = bcd2bin(reg[M41T80_REG_ALARM_HOUR] & 0x3f);
-        if (!(reg[M41T80_REG_ALARM_DAY] & 0x80))
-                t->time.tm_mday = bcd2bin(reg[M41T80_REG_ALARM_DAY] & 0x3f);
-        if (!(reg[M41T80_REG_ALARM_DAY] & 0x40))
-                t->time.tm_mon = bcd2bin(reg[M41T80_REG_ALARM_MON] & 0x1f) - 1;
-        t->time.tm_year = -1;
-        t->time.tm_wday = -1;
-        t->time.tm_yday = -1;
-        t->time.tm_isdst = -1;
-        t->enabled = !!(reg[M41T80_REG_ALARM_MON] & M41T80_ALMON_AFE);
-        t->pending = !!(reg[M41T80_REG_FLAGS] & M41T80_FLAGS_AF);
-        return 0;
-}
-
+/*
+ * XXX - m41t80 alarm functionality is reported broken.
+ * until it is fixed, don't register alarm functions.
+ */
 static struct rtc_class_ops m41t80_rtc_ops = {
         .read_time = m41t80_rtc_read_time,
         .set_time = m41t80_rtc_set_time,
-        /*
-         * XXX - m41t80 alarm functionality is reported broken.
-         * until it is fixed, don't register alarm functions.
-         *
-        .read_alarm = m41t80_rtc_read_alarm,
-        .set_alarm = m41t80_rtc_set_alarm,
-        */
         .proc = m41t80_rtc_proc,
-        /*
-         * See above comment on broken alarm
-         *
-        .alarm_irq_enable = m41t80_rtc_alarm_irq_enable,
-        */
 };
 
 #if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
diff --git a/drivers/rtc/rtc-max8907.c b/drivers/rtc/rtc-max8907.c
new file mode 100644
index 000000000000..e094ffa434f8
--- /dev/null
+++ b/drivers/rtc/rtc-max8907.c
@@ -0,0 +1,244 @@
+/*
+ * RTC driver for Maxim MAX8907
+ *
+ * Copyright (c) 2011-2012, NVIDIA Corporation.
+ *
+ * Based on drivers/rtc/rtc-max8925.c,
+ * Copyright (C) 2009-2010 Marvell International Ltd.
+ *
+ * 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/bcd.h>
+#include <linux/i2c.h>
+#include <linux/mfd/max8907.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+
+enum {
+        RTC_SEC = 0,
+        RTC_MIN,
+        RTC_HOUR,
+        RTC_WEEKDAY,
+        RTC_DATE,
+        RTC_MONTH,
+        RTC_YEAR1,
+        RTC_YEAR2,
+};
+
+#define TIME_NUM                        8
+#define ALARM_1SEC                      (1 << 7)
+#define HOUR_12                         (1 << 7)
+#define HOUR_AM_PM                      (1 << 5)
+#define ALARM0_IRQ                      (1 << 3)
+#define ALARM1_IRQ                      (1 << 2)
+#define ALARM0_STATUS                   (1 << 2)
+#define ALARM1_STATUS                   (1 << 1)
+
+struct max8907_rtc {
+        struct max8907          *max8907;
+        struct regmap           *regmap;
+        struct rtc_device       *rtc_dev;
+        int                     irq;
+};
+
+static irqreturn_t max8907_irq_handler(int irq, void *data)
+{
+        struct max8907_rtc *rtc = data;
+
+        regmap_update_bits(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0x7f, 0);
+
+        rtc_update_irq(rtc->rtc_dev, 1, RTC_IRQF | RTC_AF);
+
+        return IRQ_HANDLED;
+}
+
+static void regs_to_tm(u8 *regs, struct rtc_time *tm)
+{
+        tm->tm_year = bcd2bin(regs[RTC_YEAR2]) * 100 +
+                bcd2bin(regs[RTC_YEAR1]) - 1900;
+        tm->tm_mon = bcd2bin(regs[RTC_MONTH] & 0x1f) - 1;
+        tm->tm_mday = bcd2bin(regs[RTC_DATE] & 0x3f);
+        tm->tm_wday = (regs[RTC_WEEKDAY] & 0x07) - 1;
+        if (regs[RTC_HOUR] & HOUR_12) {
+                tm->tm_hour = bcd2bin(regs[RTC_HOUR] & 0x01f);
+                if (tm->tm_hour == 12)
+                        tm->tm_hour = 0;
+                if (regs[RTC_HOUR] & HOUR_AM_PM)
+                        tm->tm_hour += 12;
+        } else {
+                tm->tm_hour = bcd2bin(regs[RTC_HOUR] & 0x03f);
+        }
+        tm->tm_min = bcd2bin(regs[RTC_MIN] & 0x7f);
+        tm->tm_sec = bcd2bin(regs[RTC_SEC] & 0x7f);
+}
+
+static void tm_to_regs(struct rtc_time *tm, u8 *regs)
+{
+        u8 high, low;
+
+        high = (tm->tm_year + 1900) / 100;
+        low = tm->tm_year % 100;
+        regs[RTC_YEAR2] = bin2bcd(high);
+        regs[RTC_YEAR1] = bin2bcd(low);
+        regs[RTC_MONTH] = bin2bcd(tm->tm_mon + 1);
+        regs[RTC_DATE] = bin2bcd(tm->tm_mday);
+        regs[RTC_WEEKDAY] = tm->tm_wday + 1;
+        regs[RTC_HOUR] = bin2bcd(tm->tm_hour);
+        regs[RTC_MIN] = bin2bcd(tm->tm_min);
+        regs[RTC_SEC] = bin2bcd(tm->tm_sec);
+}
+
+static int max8907_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct max8907_rtc *rtc = dev_get_drvdata(dev);
+        u8 regs[TIME_NUM];
+        int ret;
+
+        ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_RTC_SEC, regs,
+                               TIME_NUM);
+        if (ret < 0)
+                return ret;
+
+        regs_to_tm(regs, tm);
+
+        return 0;
+}
+
+static int max8907_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct max8907_rtc *rtc = dev_get_drvdata(dev);
+        u8 regs[TIME_NUM];
+
+        tm_to_regs(tm, regs);
+
+        return regmap_bulk_write(rtc->regmap, MAX8907_REG_RTC_SEC, regs,
+                                 TIME_NUM);
+}
+
+static int max8907_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct max8907_rtc *rtc = dev_get_drvdata(dev);
+        u8 regs[TIME_NUM];
+        unsigned int val;
+        int ret;
+
+        ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs,
+                               TIME_NUM);
+        if (ret < 0)
+                return ret;
+
+        regs_to_tm(regs, &alrm->time);
+
+        ret = regmap_read(rtc->regmap, MAX8907_REG_ALARM0_CNTL, &val);
+        if (ret < 0)
+                return ret;
+
+        alrm->enabled = !!(val & 0x7f);
+
+        return 0;
+}
+
+static int max8907_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct max8907_rtc *rtc = dev_get_drvdata(dev);
+        u8 regs[TIME_NUM];
+        int ret;
+
+        tm_to_regs(&alrm->time, regs);
+
+        /* Disable alarm while we update the target time */
+        ret = regmap_update_bits(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0x7f, 0);
+        if (ret < 0)
+                return ret;
+
+        ret = regmap_bulk_write(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs,
+                                TIME_NUM);
+        if (ret < 0)
+                return ret;
+
+        if (alrm->enabled)
+                ret = regmap_update_bits(rtc->regmap, MAX8907_REG_ALARM0_CNTL,
+                                         0x7f, 0x7f);
+
+        return ret;
+}
+
+static const struct rtc_class_ops max8907_rtc_ops = {
+        .read_time      = max8907_rtc_read_time,
+        .set_time       = max8907_rtc_set_time,
+        .read_alarm     = max8907_rtc_read_alarm,
+        .set_alarm      = max8907_rtc_set_alarm,
+};
+
+static int __devinit max8907_rtc_probe(struct platform_device *pdev)
+{
+        struct max8907 *max8907 = dev_get_drvdata(pdev->dev.parent);
+        struct max8907_rtc *rtc;
+        int ret;
+
+        rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
+        if (!rtc)
+                return -ENOMEM;
+        platform_set_drvdata(pdev, rtc);
+
+        rtc->max8907 = max8907;
+        rtc->regmap = max8907->regmap_rtc;
+
+        rtc->rtc_dev = rtc_device_register("max8907-rtc", &pdev->dev,
+                                        &max8907_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc->rtc_dev)) {
+                ret = PTR_ERR(rtc->rtc_dev);
+                dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
+                return ret;
+        }
+
+        rtc->irq = regmap_irq_get_virq(max8907->irqc_rtc,
+                                       MAX8907_IRQ_RTC_ALARM0);
+        if (rtc->irq < 0) {
+                ret = rtc->irq;
+                goto err_unregister;
+        }
+
+        ret = request_threaded_irq(rtc->irq, NULL, max8907_irq_handler,
+                                   IRQF_ONESHOT, "max8907-alarm0", rtc);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to request IRQ%d: %d\n",
+                        rtc->irq, ret);
+                goto err_unregister;
+        }
+
+        return 0;
+
+err_unregister:
+        rtc_device_unregister(rtc->rtc_dev);
+        return ret;
+}
+
+static int __devexit max8907_rtc_remove(struct platform_device *pdev)
+{
+        struct max8907_rtc *rtc = platform_get_drvdata(pdev);
+
+        free_irq(rtc->irq, rtc);
+        rtc_device_unregister(rtc->rtc_dev);
+
+        return 0;
+}
+
+static struct platform_driver max8907_rtc_driver = {
+        .driver = {
+                .name = "max8907-rtc",
+                .owner = THIS_MODULE,
+        },
+        .probe = max8907_rtc_probe,
+        .remove = __devexit_p(max8907_rtc_remove),
+};
+module_platform_driver(max8907_rtc_driver);
+
+MODULE_DESCRIPTION("Maxim MAX8907 RTC driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index e3e50d69baf8..cd0106293a49 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -343,7 +343,7 @@ static struct rtc_class_ops mxc_rtc_ops = {
         .alarm_irq_enable       = mxc_rtc_alarm_irq_enable,
 };
 
-static int __init mxc_rtc_probe(struct platform_device *pdev)
+static int __devinit mxc_rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct rtc_device *rtc;
@@ -367,14 +367,14 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
         pdata->ioaddr = devm_ioremap(&pdev->dev, res->start,
                                      resource_size(res));
 
-        pdata->clk = clk_get(&pdev->dev, "rtc");
+        pdata->clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(pdata->clk)) {
                 dev_err(&pdev->dev, "unable to get clock!\n");
                 ret = PTR_ERR(pdata->clk);
                 goto exit_free_pdata;
         }
 
-        clk_enable(pdata->clk);
+        clk_prepare_enable(pdata->clk);
         rate = clk_get_rate(pdata->clk);
 
         if (rate == 32768)
@@ -426,22 +426,20 @@ static int __init mxc_rtc_probe(struct platform_device *pdev)
 exit_clr_drvdata:
         platform_set_drvdata(pdev, NULL);
 exit_put_clk:
-        clk_disable(pdata->clk);
-        clk_put(pdata->clk);
+        clk_disable_unprepare(pdata->clk);
 
 exit_free_pdata:
 
         return ret;
 }
 
-static int __exit mxc_rtc_remove(struct platform_device *pdev)
+static int __devexit mxc_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
 
         rtc_device_unregister(pdata->rtc);
 
-        clk_disable(pdata->clk);
-        clk_put(pdata->clk);
+        clk_disable_unprepare(pdata->clk);
         platform_set_drvdata(pdev, NULL);
 
         return 0;
@@ -482,21 +480,11 @@ static struct platform_driver mxc_rtc_driver = {
 #endif
                    .owner       = THIS_MODULE,
         },
-        .remove         = __exit_p(mxc_rtc_remove),
+        .probe = mxc_rtc_probe,
+        .remove = __devexit_p(mxc_rtc_remove),
 };
 
-static int __init mxc_rtc_init(void)
-{
-        return platform_driver_probe(&mxc_rtc_driver, mxc_rtc_probe);
-}
-
-static void __exit mxc_rtc_exit(void)
-{
-        platform_driver_unregister(&mxc_rtc_driver);
-}
-
-module_init(mxc_rtc_init);
-module_exit(mxc_rtc_exit);
+module_platform_driver(mxc_rtc_driver)
 
 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
 MODULE_DESCRIPTION("RTC driver for Freescale MXC");
diff --git a/drivers/rtc/rtc-pcf8563.c b/drivers/rtc/rtc-pcf8563.c
index c2fe426a6ef2..98e3a2b681e6 100644
--- a/drivers/rtc/rtc-pcf8563.c
+++ b/drivers/rtc/rtc-pcf8563.c
@@ -78,8 +78,17 @@ static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         unsigned char buf[13] = { PCF8563_REG_ST1 };
 
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 1, buf },    /* setup read ptr */
-                { client->addr, I2C_M_RD, 13, buf },    /* read status + date */
+                {/* setup read ptr */
+                        .addr = client->addr,
+                        .len = 1,
+                        .buf = buf
+                },
+                {/* read status + date */
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 13,
+                        .buf = buf
+                },
         };
 
         /* read registers */
diff --git a/drivers/rtc/rtc-proc.c b/drivers/rtc/rtc-proc.c
index 0a59fda5c09d..e96236ac2e78 100644
--- a/drivers/rtc/rtc-proc.c
+++ b/drivers/rtc/rtc-proc.c
@@ -18,6 +18,26 @@
 
 #include "rtc-core.h"
 
+#define NAME_SIZE       10
+
+#if defined(CONFIG_RTC_HCTOSYS_DEVICE)
+static bool is_rtc_hctosys(struct rtc_device *rtc)
+{
+        int size;
+        char name[NAME_SIZE];
+
+        size = scnprintf(name, NAME_SIZE, "rtc%d", rtc->id);
+        if (size > NAME_SIZE)
+                return false;
+
+        return !strncmp(name, CONFIG_RTC_HCTOSYS_DEVICE, NAME_SIZE);
+}
+#else
+static bool is_rtc_hctosys(struct rtc_device *rtc)
+{
+        return (rtc->id == 0);
+}
+#endif
 
 static int rtc_proc_show(struct seq_file *seq, void *offset)
 {
@@ -117,12 +137,12 @@ static const struct file_operations rtc_proc_fops = {
 
 void rtc_proc_add_device(struct rtc_device *rtc)
 {
-        if (rtc->id == 0)
+        if (is_rtc_hctosys(rtc))
                 proc_create_data("driver/rtc", 0, NULL, &rtc_proc_fops, rtc);
 }
 
 void rtc_proc_del_device(struct rtc_device *rtc)
 {
-        if (rtc->id == 0)
+        if (is_rtc_hctosys(rtc))
                 remove_proc_entry("driver/rtc", NULL);
 }
diff --git a/drivers/rtc/rtc-rc5t583.c b/drivers/rtc/rtc-rc5t583.c
new file mode 100644
index 000000000000..cdb140c29c56
--- /dev/null
+++ b/drivers/rtc/rtc-rc5t583.c
@@ -0,0 +1,331 @@
+/*
+ * rtc-rc5t583.c -- RICOH RC5T583 Real Time Clock
+ *
+ * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
+ * Author: Venu Byravarasu <vbyravarasu@nvidia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/rc5t583.h>
+
+struct rc5t583_rtc {
+        struct rtc_device       *rtc;
+        /* To store the list of enabled interrupts, during system suspend */
+        u32 irqen;
+};
+
+/* Total number of RTC registers needed to set time*/
+#define NUM_TIME_REGS   (RC5T583_RTC_YEAR - RC5T583_RTC_SEC + 1)
+
+/* Total number of RTC registers needed to set Y-Alarm*/
+#define NUM_YAL_REGS    (RC5T583_RTC_AY_YEAR - RC5T583_RTC_AY_MIN + 1)
+
+/* Set Y-Alarm interrupt */
+#define SET_YAL BIT(5)
+
+/* Get Y-Alarm interrupt status*/
+#define GET_YAL_STATUS BIT(3)
+
+static int rc5t583_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
+{
+        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
+        u8 val;
+
+        /* Set Y-Alarm, based on 'enabled' */
+        val = enabled ? SET_YAL : 0;
+
+        return regmap_update_bits(rc5t583->regmap, RC5T583_RTC_CTL1, SET_YAL,
+                val);
+}
+
+/*
+ * Gets current rc5t583 RTC time and date parameters.
+ *
+ * The RTC's time/alarm representation is not what gmtime(3) requires
+ * Linux to use:
+ *
+ *  - Months are 1..12 vs Linux 0-11
+ *  - Years are 0..99 vs Linux 1900..N (we assume 21st century)
+ */
+static int rc5t583_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
+        u8 rtc_data[NUM_TIME_REGS];
+        int ret;
+
+        ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data,
+                NUM_TIME_REGS);
+        if (ret < 0) {
+                dev_err(dev, "RTC read time failed with err:%d\n", ret);
+                return ret;
+        }
+
+        tm->tm_sec = bcd2bin(rtc_data[0]);
+        tm->tm_min = bcd2bin(rtc_data[1]);
+        tm->tm_hour = bcd2bin(rtc_data[2]);
+        tm->tm_wday = bcd2bin(rtc_data[3]);
+        tm->tm_mday = bcd2bin(rtc_data[4]);
+        tm->tm_mon = bcd2bin(rtc_data[5]) - 1;
+        tm->tm_year = bcd2bin(rtc_data[6]) + 100;
+
+        return ret;
+}
+
+static int rc5t583_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
+        unsigned char rtc_data[NUM_TIME_REGS];
+        int ret;
+
+        rtc_data[0] = bin2bcd(tm->tm_sec);
+        rtc_data[1] = bin2bcd(tm->tm_min);
+        rtc_data[2] = bin2bcd(tm->tm_hour);
+        rtc_data[3] = bin2bcd(tm->tm_wday);
+        rtc_data[4] = bin2bcd(tm->tm_mday);
+        rtc_data[5] = bin2bcd(tm->tm_mon + 1);
+        rtc_data[6] = bin2bcd(tm->tm_year - 100);
+
+        ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data,
+                NUM_TIME_REGS);
+        if (ret < 0) {
+                dev_err(dev, "RTC set time failed with error %d\n", ret);
+                return ret;
+        }
+
+        return ret;
+}
+
+static int rc5t583_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
+        unsigned char alarm_data[NUM_YAL_REGS];
+        u32 interrupt_enable;
+        int ret;
+
+        ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data,
+                NUM_YAL_REGS);
+        if (ret < 0) {
+                dev_err(dev, "rtc_read_alarm error %d\n", ret);
+                return ret;
+        }
+
+        alm->time.tm_min = bcd2bin(alarm_data[0]);
+        alm->time.tm_hour = bcd2bin(alarm_data[1]);
+        alm->time.tm_mday = bcd2bin(alarm_data[2]);
+        alm->time.tm_mon = bcd2bin(alarm_data[3]) - 1;
+        alm->time.tm_year = bcd2bin(alarm_data[4]) + 100;
+
+        ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1, &interrupt_enable);
+        if (ret < 0)
+                return ret;
+
+        /* check if YALE is set */
+        if (interrupt_enable & SET_YAL)
+                alm->enabled = 1;
+
+        return ret;
+}
+
+static int rc5t583_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
+        unsigned char alarm_data[NUM_YAL_REGS];
+        int ret;
+
+        ret = rc5t583_rtc_alarm_irq_enable(dev, 0);
+        if (ret)
+                return ret;
+
+        alarm_data[0] = bin2bcd(alm->time.tm_min);
+        alarm_data[1] = bin2bcd(alm->time.tm_hour);
+        alarm_data[2] = bin2bcd(alm->time.tm_mday);
+        alarm_data[3] = bin2bcd(alm->time.tm_mon + 1);
+        alarm_data[4] = bin2bcd(alm->time.tm_year - 100);
+
+        ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data,
+                NUM_YAL_REGS);
+        if (ret) {
+                dev_err(dev, "rtc_set_alarm error %d\n", ret);
+                return ret;
+        }
+
+        if (alm->enabled)
+                ret = rc5t583_rtc_alarm_irq_enable(dev, 1);
+
+        return ret;
+}
+
+static irqreturn_t rc5t583_rtc_interrupt(int irq, void *rtc)
+{
+        struct device *dev = rtc;
+        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
+        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev);
+        unsigned long events = 0;
+        int ret;
+        u32 rtc_reg;
+
+        ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL2, &rtc_reg);
+        if (ret < 0)
+                return IRQ_NONE;
+
+        if (rtc_reg & GET_YAL_STATUS) {
+                events = RTC_IRQF | RTC_AF;
+                /* clear pending Y-alarm interrupt bit */
+                rtc_reg &= ~GET_YAL_STATUS;
+        }
+
+        ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, rtc_reg);
+        if (ret)
+                return IRQ_NONE;
+
+        /* Notify RTC core on event */
+        rtc_update_irq(rc5t583_rtc->rtc, 1, events);
+
+        return IRQ_HANDLED;
+}
+
+static const struct rtc_class_ops rc5t583_rtc_ops = {
+        .read_time      = rc5t583_rtc_read_time,
+        .set_time       = rc5t583_rtc_set_time,
+        .read_alarm     = rc5t583_rtc_read_alarm,
+        .set_alarm      = rc5t583_rtc_set_alarm,
+        .alarm_irq_enable = rc5t583_rtc_alarm_irq_enable,
+};
+
+static int __devinit rc5t583_rtc_probe(struct platform_device *pdev)
+{
+        struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent);
+        struct rc5t583_rtc *ricoh_rtc;
+        struct rc5t583_platform_data *pmic_plat_data;
+        int ret;
+        int irq;
+
+        ricoh_rtc = devm_kzalloc(&pdev->dev, sizeof(struct rc5t583_rtc),
+                        GFP_KERNEL);
+        if (!ricoh_rtc)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, ricoh_rtc);
+
+        /* Clear pending interrupts */
+        ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, 0);
+        if (ret < 0)
+                return ret;
+
+        /* clear RTC Adjust register */
+        ret = regmap_write(rc5t583->regmap, RC5T583_RTC_ADJ, 0);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "unable to program rtc_adjust reg\n");
+                return -EBUSY;
+        }
+
+        pmic_plat_data = dev_get_platdata(rc5t583->dev);
+        irq = pmic_plat_data->irq_base;
+        if (irq <= 0) {
+                dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n",
+                        irq);
+                return ret;
+        }
+
+        irq += RC5T583_IRQ_YALE;
+        ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
+                rc5t583_rtc_interrupt, IRQF_TRIGGER_LOW,
+                "rtc-rc5t583", &pdev->dev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "IRQ is not free.\n");
+                return ret;
+        }
+        device_init_wakeup(&pdev->dev, 1);
+
+        ricoh_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                &rc5t583_rtc_ops, THIS_MODULE);
+        if (IS_ERR(ricoh_rtc->rtc)) {
+                ret = PTR_ERR(ricoh_rtc->rtc);
+                dev_err(&pdev->dev, "RTC device register: err %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+/*
+ * Disable rc5t583 RTC interrupts.
+ * Sets status flag to free.
+ */
+static int __devexit rc5t583_rtc_remove(struct platform_device *pdev)
+{
+        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(&pdev->dev);
+
+        rc5t583_rtc_alarm_irq_enable(&rc5t583_rtc->rtc->dev, 0);
+
+        rtc_device_unregister(rc5t583_rtc->rtc);
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+static int rc5t583_rtc_suspend(struct device *dev)
+{
+        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
+        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev);
+        int ret;
+
+        /* Store current list of enabled interrupts*/
+        ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1,
+                &rc5t583_rtc->irqen);
+        return ret;
+}
+
+static int rc5t583_rtc_resume(struct device *dev)
+{
+        struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
+        struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev);
+
+        /* Restore list of enabled interrupts before suspend */
+        return regmap_write(rc5t583->regmap, RC5T583_RTC_CTL1,
+                rc5t583_rtc->irqen);
+}
+
+static const struct dev_pm_ops rc5t583_rtc_pm_ops = {
+        .suspend        = rc5t583_rtc_suspend,
+        .resume         = rc5t583_rtc_resume,
+};
+
+#define DEV_PM_OPS     (&rc5t583_rtc_pm_ops)
+#else
+#define DEV_PM_OPS     NULL
+#endif
+
+static struct platform_driver rc5t583_rtc_driver = {
+        .probe          = rc5t583_rtc_probe,
+        .remove         = __devexit_p(rc5t583_rtc_remove),
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "rtc-rc5t583",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+module_platform_driver(rc5t583_rtc_driver);
+MODULE_ALIAS("platform:rtc-rc5t583");
+MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
index fb4842c3544e..76f565ae384d 100644
--- a/drivers/rtc/rtc-rs5c372.c
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -104,7 +104,12 @@ static int rs5c_get_regs(struct rs5c372 *rs5c)
 {
         struct i2c_client       *client = rs5c->client;
         struct i2c_msg          msgs[] = {
-                { client->addr, I2C_M_RD, sizeof rs5c->buf, rs5c->buf },
+                {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = sizeof(rs5c->buf),
+                        .buf = rs5c->buf
+                },
         };
 
         /* This implements the third reading method from the datasheet, using
diff --git a/drivers/rtc/rtc-s35390a.c b/drivers/rtc/rtc-s35390a.c
index c9562ceedef3..8a092325188d 100644
--- a/drivers/rtc/rtc-s35390a.c
+++ b/drivers/rtc/rtc-s35390a.c
@@ -19,6 +19,8 @@
 #define S35390A_CMD_STATUS1     0
 #define S35390A_CMD_STATUS2     1
 #define S35390A_CMD_TIME1       2
+#define S35390A_CMD_TIME2       3
+#define S35390A_CMD_INT2_REG1   5
 
 #define S35390A_BYTE_YEAR       0
 #define S35390A_BYTE_MONTH      1
@@ -28,12 +30,23 @@
 #define S35390A_BYTE_MINS       5
 #define S35390A_BYTE_SECS       6
 
+#define S35390A_ALRM_BYTE_WDAY  0
+#define S35390A_ALRM_BYTE_HOURS 1
+#define S35390A_ALRM_BYTE_MINS  2
+
 #define S35390A_FLAG_POC        0x01
 #define S35390A_FLAG_BLD        0x02
 #define S35390A_FLAG_24H        0x40
 #define S35390A_FLAG_RESET      0x80
 #define S35390A_FLAG_TEST       0x01
 
+#define S35390A_INT2_MODE_MASK          0xF0
+
+#define S35390A_INT2_MODE_NOINTR        0x00
+#define S35390A_INT2_MODE_FREQ          0x10
+#define S35390A_INT2_MODE_ALARM         0x40
+#define S35390A_INT2_MODE_PMIN_EDG      0x20
+
 static const struct i2c_device_id s35390a_id[] = {
         { "s35390a", 0 },
         { }
@@ -50,7 +63,11 @@ static int s35390a_set_reg(struct s35390a *s35390a, int reg, char *buf, int len)
 {
         struct i2c_client *client = s35390a->client[reg];
         struct i2c_msg msg[] = {
-                { client->addr, 0, len, buf },
+                {
+                        .addr = client->addr,
+                        .len = len,
+                        .buf = buf
+                },
         };
 
         if ((i2c_transfer(client->adapter, msg, 1)) != 1)
@@ -63,7 +80,12 @@ static int s35390a_get_reg(struct s35390a *s35390a, int reg, char *buf, int len)
 {
         struct i2c_client *client = s35390a->client[reg];
         struct i2c_msg msg[] = {
-                { client->addr, I2C_M_RD, len, buf },
+                {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = len,
+                        .buf = buf
+                },
         };
 
         if ((i2c_transfer(client->adapter, msg, 1)) != 1)
@@ -184,6 +206,104 @@ static int s35390a_get_datetime(struct i2c_client *client, struct rtc_time *tm)
         return rtc_valid_tm(tm);
 }
 
+static int s35390a_set_alarm(struct i2c_client *client, struct rtc_wkalrm *alm)
+{
+        struct s35390a *s35390a = i2c_get_clientdata(client);
+        char buf[3], sts = 0;
+        int err, i;
+
+        dev_dbg(&client->dev, "%s: alm is secs=%d, mins=%d, hours=%d mday=%d, "\
+                "mon=%d, year=%d, wday=%d\n", __func__, alm->time.tm_sec,
+                alm->time.tm_min, alm->time.tm_hour, alm->time.tm_mday,
+                alm->time.tm_mon, alm->time.tm_year, alm->time.tm_wday);
+
+        /* disable interrupt */
+        err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
+        if (err < 0)
+                return err;
+
+        /* clear pending interrupt, if any */
+        err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &sts, sizeof(sts));
+        if (err < 0)
+                return err;
+
+        if (alm->enabled)
+                sts = S35390A_INT2_MODE_ALARM;
+        else
+                sts = S35390A_INT2_MODE_NOINTR;
+
+        /* This chip expects the bits of each byte to be in reverse order */
+        sts = bitrev8(sts);
+
+        /* set interupt mode*/
+        err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
+        if (err < 0)
+                return err;
+
+        if (alm->time.tm_wday != -1)
+                buf[S35390A_ALRM_BYTE_WDAY] = bin2bcd(alm->time.tm_wday) | 0x80;
+
+        buf[S35390A_ALRM_BYTE_HOURS] = s35390a_hr2reg(s35390a,
+                        alm->time.tm_hour) | 0x80;
+        buf[S35390A_ALRM_BYTE_MINS] = bin2bcd(alm->time.tm_min) | 0x80;
+
+        if (alm->time.tm_hour >= 12)
+                buf[S35390A_ALRM_BYTE_HOURS] |= 0x40;
+
+        for (i = 0; i < 3; ++i)
+                buf[i] = bitrev8(buf[i]);
+
+        err = s35390a_set_reg(s35390a, S35390A_CMD_INT2_REG1, buf,
+                                                                sizeof(buf));
+
+        return err;
+}
+
+static int s35390a_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alm)
+{
+        struct s35390a *s35390a = i2c_get_clientdata(client);
+        char buf[3], sts;
+        int i, err;
+
+        err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts));
+        if (err < 0)
+                return err;
+
+        if (bitrev8(sts) != S35390A_INT2_MODE_ALARM)
+                return -EINVAL;
+
+        err = s35390a_get_reg(s35390a, S35390A_CMD_INT2_REG1, buf, sizeof(buf));
+        if (err < 0)
+                return err;
+
+        /* This chip returns the bits of each byte in reverse order */
+        for (i = 0; i < 3; ++i) {
+                buf[i] = bitrev8(buf[i]);
+                buf[i] &= ~0x80;
+        }
+
+        alm->time.tm_wday = bcd2bin(buf[S35390A_ALRM_BYTE_WDAY]);
+        alm->time.tm_hour = s35390a_reg2hr(s35390a,
+                                                buf[S35390A_ALRM_BYTE_HOURS]);
+        alm->time.tm_min = bcd2bin(buf[S35390A_ALRM_BYTE_MINS]);
+
+        dev_dbg(&client->dev, "%s: alm is mins=%d, hours=%d, wday=%d\n",
+                        __func__, alm->time.tm_min, alm->time.tm_hour,
+                        alm->time.tm_wday);
+
+        return 0;
+}
+
+static int s35390a_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        return s35390a_read_alarm(to_i2c_client(dev), alm);
+}
+
+static int s35390a_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        return s35390a_set_alarm(to_i2c_client(dev), alm);
+}
+
 static int s35390a_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
         return s35390a_get_datetime(to_i2c_client(dev), tm);
@@ -197,6 +317,9 @@ static int s35390a_rtc_set_time(struct device *dev, struct rtc_time *tm)
 static const struct rtc_class_ops s35390a_rtc_ops = {
         .read_time      = s35390a_rtc_read_time,
         .set_time       = s35390a_rtc_set_time,
+        .set_alarm      = s35390a_rtc_set_alarm,
+        .read_alarm     = s35390a_rtc_read_alarm,
+
 };
 
 static struct i2c_driver s35390a_driver;
@@ -261,6 +384,8 @@ static int s35390a_probe(struct i2c_client *client,
         if (s35390a_get_datetime(client, &tm) < 0)
                 dev_warn(&client->dev, "clock needs to be set\n");
 
+        device_set_wakeup_capable(&client->dev, 1);
+
         s35390a->rtc = rtc_device_register(s35390a_driver.driver.name,
                                 &client->dev, &s35390a_rtc_ops, THIS_MODULE);
 
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index bfbd92c8d1c9..77823d21d314 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -476,13 +476,13 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
         s3c_rtc_tickno = platform_get_irq(pdev, 1);
         if (s3c_rtc_tickno < 0) {
                 dev_err(&pdev->dev, "no irq for rtc tick\n");
-                return -ENOENT;
+                return s3c_rtc_tickno;
         }
 
         s3c_rtc_alarmno = platform_get_irq(pdev, 0);
         if (s3c_rtc_alarmno < 0) {
                 dev_err(&pdev->dev, "no irq for alarm\n");
-                return -ENOENT;
+                return s3c_rtc_alarmno;
         }
 
         pr_debug("s3c2410_rtc: tick irq %d, alarm irq %d\n",
diff --git a/drivers/rtc/rtc-snvs.c b/drivers/rtc/rtc-snvs.c
new file mode 100644
index 000000000000..3c0da333f465
--- /dev/null
+++ b/drivers/rtc/rtc-snvs.c
@@ -0,0 +1,350 @@
+/*
+ * Copyright (C) 2011-2012 Freescale Semiconductor, Inc.
+ *
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+
+/* These register offsets are relative to LP (Low Power) range */
+#define SNVS_LPCR               0x04
+#define SNVS_LPSR               0x18
+#define SNVS_LPSRTCMR           0x1c
+#define SNVS_LPSRTCLR           0x20
+#define SNVS_LPTAR              0x24
+#define SNVS_LPPGDR             0x30
+
+#define SNVS_LPCR_SRTC_ENV      (1 << 0)
+#define SNVS_LPCR_LPTA_EN       (1 << 1)
+#define SNVS_LPCR_LPWUI_EN      (1 << 3)
+#define SNVS_LPSR_LPTA          (1 << 0)
+
+#define SNVS_LPPGDR_INIT        0x41736166
+#define CNTR_TO_SECS_SH         15
+
+struct snvs_rtc_data {
+        struct rtc_device *rtc;
+        void __iomem *ioaddr;
+        int irq;
+        spinlock_t lock;
+};
+
+static u32 rtc_read_lp_counter(void __iomem *ioaddr)
+{
+        u64 read1, read2;
+
+        do {
+                read1 = readl(ioaddr + SNVS_LPSRTCMR);
+                read1 <<= 32;
+                read1 |= readl(ioaddr + SNVS_LPSRTCLR);
+
+                read2 = readl(ioaddr + SNVS_LPSRTCMR);
+                read2 <<= 32;
+                read2 |= readl(ioaddr + SNVS_LPSRTCLR);
+        } while (read1 != read2);
+
+        /* Convert 47-bit counter to 32-bit raw second count */
+        return (u32) (read1 >> CNTR_TO_SECS_SH);
+}
+
+static void rtc_write_sync_lp(void __iomem *ioaddr)
+{
+        u32 count1, count2, count3;
+        int i;
+
+        /* Wait for 3 CKIL cycles */
+        for (i = 0; i < 3; i++) {
+                do {
+                        count1 = readl(ioaddr + SNVS_LPSRTCLR);
+                        count2 = readl(ioaddr + SNVS_LPSRTCLR);
+                } while (count1 != count2);
+
+                /* Now wait until counter value changes */
+                do {
+                        do {
+                                count2 = readl(ioaddr + SNVS_LPSRTCLR);
+                                count3 = readl(ioaddr + SNVS_LPSRTCLR);
+                        } while (count2 != count3);
+                } while (count3 == count1);
+        }
+}
+
+static int snvs_rtc_enable(struct snvs_rtc_data *data, bool enable)
+{
+        unsigned long flags;
+        int timeout = 1000;
+        u32 lpcr;
+
+        spin_lock_irqsave(&data->lock, flags);
+
+        lpcr = readl(data->ioaddr + SNVS_LPCR);
+        if (enable)
+                lpcr |= SNVS_LPCR_SRTC_ENV;
+        else
+                lpcr &= ~SNVS_LPCR_SRTC_ENV;
+        writel(lpcr, data->ioaddr + SNVS_LPCR);
+
+        spin_unlock_irqrestore(&data->lock, flags);
+
+        while (--timeout) {
+                lpcr = readl(data->ioaddr + SNVS_LPCR);
+
+                if (enable) {
+                        if (lpcr & SNVS_LPCR_SRTC_ENV)
+                                break;
+                } else {
+                        if (!(lpcr & SNVS_LPCR_SRTC_ENV))
+                                break;
+                }
+        }
+
+        if (!timeout)
+                return -ETIMEDOUT;
+
+        return 0;
+}
+
+static int snvs_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct snvs_rtc_data *data = dev_get_drvdata(dev);
+        unsigned long time = rtc_read_lp_counter(data->ioaddr);
+
+        rtc_time_to_tm(time, tm);
+
+        return 0;
+}
+
+static int snvs_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct snvs_rtc_data *data = dev_get_drvdata(dev);
+        unsigned long time;
+
+        rtc_tm_to_time(tm, &time);
+
+        /* Disable RTC first */
+        snvs_rtc_enable(data, false);
+
+        /* Write 32-bit time to 47-bit timer, leaving 15 LSBs blank */
+        writel(time << CNTR_TO_SECS_SH, data->ioaddr + SNVS_LPSRTCLR);
+        writel(time >> (32 - CNTR_TO_SECS_SH), data->ioaddr + SNVS_LPSRTCMR);
+
+        /* Enable RTC again */
+        snvs_rtc_enable(data, true);
+
+        return 0;
+}
+
+static int snvs_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct snvs_rtc_data *data = dev_get_drvdata(dev);
+        u32 lptar, lpsr;
+
+        lptar = readl(data->ioaddr + SNVS_LPTAR);
+        rtc_time_to_tm(lptar, &alrm->time);
+
+        lpsr = readl(data->ioaddr + SNVS_LPSR);
+        alrm->pending = (lpsr & SNVS_LPSR_LPTA) ? 1 : 0;
+
+        return 0;
+}
+
+static int snvs_rtc_alarm_irq_enable(struct device *dev, unsigned int enable)
+{
+        struct snvs_rtc_data *data = dev_get_drvdata(dev);
+        u32 lpcr;
+        unsigned long flags;
+
+        spin_lock_irqsave(&data->lock, flags);
+
+        lpcr = readl(data->ioaddr + SNVS_LPCR);
+        if (enable)
+                lpcr |= (SNVS_LPCR_LPTA_EN | SNVS_LPCR_LPWUI_EN);
+        else
+                lpcr &= ~(SNVS_LPCR_LPTA_EN | SNVS_LPCR_LPWUI_EN);
+        writel(lpcr, data->ioaddr + SNVS_LPCR);
+
+        spin_unlock_irqrestore(&data->lock, flags);
+
+        rtc_write_sync_lp(data->ioaddr);
+
+        return 0;
+}
+
+static int snvs_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct snvs_rtc_data *data = dev_get_drvdata(dev);
+        struct rtc_time *alrm_tm = &alrm->time;
+        unsigned long time;
+        unsigned long flags;
+        u32 lpcr;
+
+        rtc_tm_to_time(alrm_tm, &time);
+
+        spin_lock_irqsave(&data->lock, flags);
+
+        /* Have to clear LPTA_EN before programming new alarm time in LPTAR */
+        lpcr = readl(data->ioaddr + SNVS_LPCR);
+        lpcr &= ~SNVS_LPCR_LPTA_EN;
+        writel(lpcr, data->ioaddr + SNVS_LPCR);
+
+        spin_unlock_irqrestore(&data->lock, flags);
+
+        writel(time, data->ioaddr + SNVS_LPTAR);
+
+        /* Clear alarm interrupt status bit */
+        writel(SNVS_LPSR_LPTA, data->ioaddr + SNVS_LPSR);
+
+        return snvs_rtc_alarm_irq_enable(dev, alrm->enabled);
+}
+
+static const struct rtc_class_ops snvs_rtc_ops = {
+        .read_time = snvs_rtc_read_time,
+        .set_time = snvs_rtc_set_time,
+        .read_alarm = snvs_rtc_read_alarm,
+        .set_alarm = snvs_rtc_set_alarm,
+        .alarm_irq_enable = snvs_rtc_alarm_irq_enable,
+};
+
+static irqreturn_t snvs_rtc_irq_handler(int irq, void *dev_id)
+{
+        struct device *dev = dev_id;
+        struct snvs_rtc_data *data = dev_get_drvdata(dev);
+        u32 lpsr;
+        u32 events = 0;
+
+        lpsr = readl(data->ioaddr + SNVS_LPSR);
+
+        if (lpsr & SNVS_LPSR_LPTA) {
+                events |= (RTC_AF | RTC_IRQF);
+
+                /* RTC alarm should be one-shot */
+                snvs_rtc_alarm_irq_enable(dev, 0);
+
+                rtc_update_irq(data->rtc, 1, events);
+        }
+
+        /* clear interrupt status */
+        writel(lpsr, data->ioaddr + SNVS_LPSR);
+
+        return events ? IRQ_HANDLED : IRQ_NONE;
+}
+
+static int __devinit snvs_rtc_probe(struct platform_device *pdev)
+{
+        struct snvs_rtc_data *data;
+        struct resource *res;
+        int ret;
+
+        data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        data->ioaddr = devm_request_and_ioremap(&pdev->dev, res);
+        if (!data->ioaddr)
+                return -EADDRNOTAVAIL;
+
+        data->irq = platform_get_irq(pdev, 0);
+        if (data->irq < 0)
+                return data->irq;
+
+        platform_set_drvdata(pdev, data);
+
+        spin_lock_init(&data->lock);
+
+        /* Initialize glitch detect */
+        writel(SNVS_LPPGDR_INIT, data->ioaddr + SNVS_LPPGDR);
+
+        /* Clear interrupt status */
+        writel(0xffffffff, data->ioaddr + SNVS_LPSR);
+
+        /* Enable RTC */
+        snvs_rtc_enable(data, true);
+
+        device_init_wakeup(&pdev->dev, true);
+
+        ret = devm_request_irq(&pdev->dev, data->irq, snvs_rtc_irq_handler,
+                               IRQF_SHARED, "rtc alarm", &pdev->dev);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to request irq %d: %d\n",
+                        data->irq, ret);
+                return ret;
+        }
+
+        data->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                        &snvs_rtc_ops, THIS_MODULE);
+        if (IS_ERR(data->rtc)) {
+                ret = PTR_ERR(data->rtc);
+                dev_err(&pdev->dev, "failed to register rtc: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int __devexit snvs_rtc_remove(struct platform_device *pdev)
+{
+        struct snvs_rtc_data *data = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(data->rtc);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int snvs_rtc_suspend(struct device *dev)
+{
+        struct snvs_rtc_data *data = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                enable_irq_wake(data->irq);
+
+        return 0;
+}
+
+static int snvs_rtc_resume(struct device *dev)
+{
+        struct snvs_rtc_data *data = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                disable_irq_wake(data->irq);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(snvs_rtc_pm_ops, snvs_rtc_suspend, snvs_rtc_resume);
+
+static const struct of_device_id __devinitconst snvs_dt_ids[] = {
+        { .compatible = "fsl,sec-v4.0-mon-rtc-lp", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, snvs_dt_ids);
+
+static struct platform_driver snvs_rtc_driver = {
+        .driver = {
+                .name   = "snvs_rtc",
+                .owner  = THIS_MODULE,
+                .pm     = &snvs_rtc_pm_ops,
+                .of_match_table = snvs_dt_ids,
+        },
+        .probe          = snvs_rtc_probe,
+        .remove         = __devexit_p(snvs_rtc_remove),
+};
+module_platform_driver(snvs_rtc_driver);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("Freescale SNVS RTC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-spear.c b/drivers/rtc/rtc-spear.c
index e2785479113c..bb507d23f6ce 100644
--- a/drivers/rtc/rtc-spear.c
+++ b/drivers/rtc/rtc-spear.c
@@ -235,7 +235,7 @@ static int spear_rtc_read_time(struct device *dev, struct rtc_time *tm)
 static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
         struct spear_rtc_config *config = dev_get_drvdata(dev);
-        unsigned int time, date, err = 0;
+        unsigned int time, date;
 
         if (tm2bcd(tm) < 0)
                 return -EINVAL;
@@ -247,11 +247,8 @@ static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm)
                 (tm->tm_year << YEAR_SHIFT);
         writel(time, config->ioaddr + TIME_REG);
         writel(date, config->ioaddr + DATE_REG);
-        err = is_write_complete(config);
-        if (err < 0)
-                return err;
 
-        return 0;
+        return is_write_complete(config);
 }
 
 /*
@@ -295,7 +292,8 @@ static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 {
         struct spear_rtc_config *config = dev_get_drvdata(dev);
-        unsigned int time, date, err = 0;
+        unsigned int time, date;
+        int err;
 
         if (tm2bcd(&alm->time) < 0)
                 return -EINVAL;
@@ -357,7 +355,7 @@ static int __devinit spear_rtc_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct spear_rtc_config *config;
-        unsigned int status = 0;
+        int status = 0;
         int irq;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
index 380083ca572f..b70e2bb63645 100644
--- a/drivers/rtc/rtc-sysfs.c
+++ b/drivers/rtc/rtc-sysfs.c
@@ -102,6 +102,12 @@ rtc_sysfs_set_max_user_freq(struct device *dev, struct device_attribute *attr,
         return n;
 }
 
+/**
+ * rtc_sysfs_show_hctosys - indicate if the given RTC set the system time
+ *
+ * Returns 1 if the system clock was set by this RTC at the last
+ * boot or resume event.
+ */
 static ssize_t
 rtc_sysfs_show_hctosys(struct device *dev, struct device_attribute *attr,
                 char *buf)
diff --git a/drivers/rtc/rtc-tps65910.c b/drivers/rtc/rtc-tps65910.c
new file mode 100644
index 000000000000..7a82337e4dee
--- /dev/null
+++ b/drivers/rtc/rtc-tps65910.c
@@ -0,0 +1,349 @@
+/*
+ * rtc-tps65910.c -- TPS65910 Real Time Clock interface
+ *
+ * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
+ * Author: Venu Byravarasu <vbyravarasu@nvidia.com>
+ *
+ * Based on original TI driver rtc-twl.c
+ *   Copyright (C) 2007 MontaVista Software, Inc
+ *   Author: Alexandre Rusev <source@mvista.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/tps65910.h>
+
+struct tps65910_rtc {
+        struct rtc_device       *rtc;
+        /* To store the list of enabled interrupts */
+        u32 irqstat;
+};
+
+/* Total number of RTC registers needed to set time*/
+#define NUM_TIME_REGS   (TPS65910_YEARS - TPS65910_SECONDS + 1)
+
+static int tps65910_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
+{
+        struct tps65910 *tps = dev_get_drvdata(dev->parent);
+        u8 val = 0;
+
+        if (enabled)
+                val = TPS65910_RTC_INTERRUPTS_IT_ALARM;
+
+        return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS, val);
+}
+
+/*
+ * Gets current tps65910 RTC time and date parameters.
+ *
+ * The RTC's time/alarm representation is not what gmtime(3) requires
+ * Linux to use:
+ *
+ *  - Months are 1..12 vs Linux 0-11
+ *  - Years are 0..99 vs Linux 1900..N (we assume 21st century)
+ */
+static int tps65910_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned char rtc_data[NUM_TIME_REGS];
+        struct tps65910 *tps = dev_get_drvdata(dev->parent);
+        int ret;
+
+        /* Copy RTC counting registers to static registers or latches */
+        ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
+                TPS65910_RTC_CTRL_GET_TIME, TPS65910_RTC_CTRL_GET_TIME);
+        if (ret < 0) {
+                dev_err(dev, "RTC CTRL reg update failed with err:%d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, rtc_data,
+                NUM_TIME_REGS);
+        if (ret < 0) {
+                dev_err(dev, "reading from RTC failed with err:%d\n", ret);
+                return ret;
+        }
+
+        tm->tm_sec = bcd2bin(rtc_data[0]);
+        tm->tm_min = bcd2bin(rtc_data[1]);
+        tm->tm_hour = bcd2bin(rtc_data[2]);
+        tm->tm_mday = bcd2bin(rtc_data[3]);
+        tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
+        tm->tm_year = bcd2bin(rtc_data[5]) + 100;
+
+        return ret;
+}
+
+static int tps65910_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned char rtc_data[NUM_TIME_REGS];
+        struct tps65910 *tps = dev_get_drvdata(dev->parent);
+        int ret;
+
+        rtc_data[0] = bin2bcd(tm->tm_sec);
+        rtc_data[1] = bin2bcd(tm->tm_min);
+        rtc_data[2] = bin2bcd(tm->tm_hour);
+        rtc_data[3] = bin2bcd(tm->tm_mday);
+        rtc_data[4] = bin2bcd(tm->tm_mon + 1);
+        rtc_data[5] = bin2bcd(tm->tm_year - 100);
+
+        /* Stop RTC while updating the RTC time registers */
+        ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
+                TPS65910_RTC_CTRL_STOP_RTC, 0);
+        if (ret < 0) {
+                dev_err(dev, "RTC stop failed with err:%d\n", ret);
+                return ret;
+        }
+
+        /* update all the time registers in one shot */
+        ret = regmap_bulk_write(tps->regmap, TPS65910_SECONDS, rtc_data,
+                NUM_TIME_REGS);
+        if (ret < 0) {
+                dev_err(dev, "rtc_set_time error %d\n", ret);
+                return ret;
+        }
+
+        /* Start back RTC */
+        ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
+                TPS65910_RTC_CTRL_STOP_RTC, 1);
+        if (ret < 0)
+                dev_err(dev, "RTC start failed with err:%d\n", ret);
+
+        return ret;
+}
+
+/*
+ * Gets current tps65910 RTC alarm time.
+ */
+static int tps65910_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        unsigned char alarm_data[NUM_TIME_REGS];
+        u32 int_val;
+        struct tps65910 *tps = dev_get_drvdata(dev->parent);
+        int ret;
+
+        ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, alarm_data,
+                NUM_TIME_REGS);
+        if (ret < 0) {
+                dev_err(dev, "rtc_read_alarm error %d\n", ret);
+                return ret;
+        }
+
+        alm->time.tm_sec = bcd2bin(alarm_data[0]);
+        alm->time.tm_min = bcd2bin(alarm_data[1]);
+        alm->time.tm_hour = bcd2bin(alarm_data[2]);
+        alm->time.tm_mday = bcd2bin(alarm_data[3]);
+        alm->time.tm_mon = bcd2bin(alarm_data[4]) - 1;
+        alm->time.tm_year = bcd2bin(alarm_data[5]) + 100;
+
+        ret = regmap_read(tps->regmap, TPS65910_RTC_INTERRUPTS, &int_val);
+        if (ret < 0)
+                return ret;
+
+        if (int_val & TPS65910_RTC_INTERRUPTS_IT_ALARM)
+                alm->enabled = 1;
+
+        return ret;
+}
+
+static int tps65910_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
+{
+        unsigned char alarm_data[NUM_TIME_REGS];
+        struct tps65910 *tps = dev_get_drvdata(dev->parent);
+        int ret;
+
+        ret = tps65910_rtc_alarm_irq_enable(dev, 0);
+        if (ret)
+                return ret;
+
+        alarm_data[0] = bin2bcd(alm->time.tm_sec);
+        alarm_data[1] = bin2bcd(alm->time.tm_min);
+        alarm_data[2] = bin2bcd(alm->time.tm_hour);
+        alarm_data[3] = bin2bcd(alm->time.tm_mday);
+        alarm_data[4] = bin2bcd(alm->time.tm_mon + 1);
+        alarm_data[5] = bin2bcd(alm->time.tm_year - 100);
+
+        /* update all the alarm registers in one shot */
+        ret = regmap_bulk_write(tps->regmap, TPS65910_ALARM_SECONDS,
+                alarm_data, NUM_TIME_REGS);
+        if (ret) {
+                dev_err(dev, "rtc_set_alarm error %d\n", ret);
+                return ret;
+        }
+
+        if (alm->enabled)
+                ret = tps65910_rtc_alarm_irq_enable(dev, 1);
+
+        return ret;
+}
+
+static irqreturn_t tps65910_rtc_interrupt(int irq, void *rtc)
+{
+        struct device *dev = rtc;
+        unsigned long events = 0;
+        struct tps65910 *tps = dev_get_drvdata(dev->parent);
+        struct tps65910_rtc *tps_rtc = dev_get_drvdata(dev);
+        int ret;
+        u32 rtc_reg;
+
+        ret = regmap_read(tps->regmap, TPS65910_RTC_STATUS, &rtc_reg);
+        if (ret)
+                return IRQ_NONE;
+
+        if (rtc_reg & TPS65910_RTC_STATUS_ALARM)
+                events = RTC_IRQF | RTC_AF;
+
+        ret = regmap_write(tps->regmap, TPS65910_RTC_STATUS, rtc_reg);
+        if (ret)
+                return IRQ_NONE;
+
+        /* Notify RTC core on event */
+        rtc_update_irq(tps_rtc->rtc, 1, events);
+
+        return IRQ_HANDLED;
+}
+
+static const struct rtc_class_ops tps65910_rtc_ops = {
+        .read_time      = tps65910_rtc_read_time,
+        .set_time       = tps65910_rtc_set_time,
+        .read_alarm     = tps65910_rtc_read_alarm,
+        .set_alarm      = tps65910_rtc_set_alarm,
+        .alarm_irq_enable = tps65910_rtc_alarm_irq_enable,
+};
+
+static int __devinit tps65910_rtc_probe(struct platform_device *pdev)
+{
+        struct tps65910 *tps65910 = NULL;
+        struct tps65910_rtc *tps_rtc = NULL;
+        int ret;
+        int irq;
+        u32 rtc_reg;
+
+        tps65910 = dev_get_drvdata(pdev->dev.parent);
+
+        tps_rtc = devm_kzalloc(&pdev->dev, sizeof(struct tps65910_rtc),
+                        GFP_KERNEL);
+        if (!tps_rtc)
+                return -ENOMEM;
+
+        /* Clear pending interrupts */
+        ret = regmap_read(tps65910->regmap, TPS65910_RTC_STATUS, &rtc_reg);
+        if (ret < 0)
+                return ret;
+
+        ret = regmap_write(tps65910->regmap, TPS65910_RTC_STATUS, rtc_reg);
+        if (ret < 0)
+                return ret;
+
+        dev_dbg(&pdev->dev, "Enabling rtc-tps65910.\n");
+        rtc_reg = TPS65910_RTC_CTRL_STOP_RTC;
+        ret = regmap_write(tps65910->regmap, TPS65910_RTC_CTRL, rtc_reg);
+        if (ret < 0)
+                return ret;
+
+        irq  = platform_get_irq(pdev, 0);
+        if (irq <= 0) {
+                dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n",
+                        irq);
+                return ret;
+        }
+
+        ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
+                tps65910_rtc_interrupt, IRQF_TRIGGER_LOW,
+                "rtc-tps65910", &pdev->dev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "IRQ is not free.\n");
+                return ret;
+        }
+        device_init_wakeup(&pdev->dev, 1);
+
+        tps_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
+                &tps65910_rtc_ops, THIS_MODULE);
+        if (IS_ERR(tps_rtc->rtc)) {
+                ret = PTR_ERR(tps_rtc->rtc);
+                dev_err(&pdev->dev, "RTC device register: err %d\n", ret);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, tps_rtc);
+
+        return 0;
+}
+
+/*
+ * Disable tps65910 RTC interrupts.
+ * Sets status flag to free.
+ */
+static int __devexit tps65910_rtc_remove(struct platform_device *pdev)
+{
+        /* leave rtc running, but disable irqs */
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+
+        tps65910_rtc_alarm_irq_enable(&rtc->dev, 0);
+
+        rtc_device_unregister(rtc);
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+static int tps65910_rtc_suspend(struct device *dev)
+{
+        struct tps65910 *tps = dev_get_drvdata(dev->parent);
+        u8 alarm = TPS65910_RTC_INTERRUPTS_IT_ALARM;
+        int ret;
+
+        /* Store current list of enabled interrupts*/
+        ret = regmap_read(tps->regmap, TPS65910_RTC_INTERRUPTS,
+                &tps->rtc->irqstat);
+        if (ret < 0)
+                return ret;
+
+        /* Enable RTC ALARM interrupt only */
+        return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS, alarm);
+}
+
+static int tps65910_rtc_resume(struct device *dev)
+{
+        struct tps65910 *tps = dev_get_drvdata(dev->parent);
+
+        /* Restore list of enabled interrupts before suspend */
+        return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS,
+                tps->rtc->irqstat);
+}
+
+static const struct dev_pm_ops tps65910_rtc_pm_ops = {
+        .suspend        = tps65910_rtc_suspend,
+        .resume         = tps65910_rtc_resume,
+};
+
+#define DEV_PM_OPS     (&tps65910_rtc_pm_ops)
+#else
+#define DEV_PM_OPS     NULL
+#endif
+
+static struct platform_driver tps65910_rtc_driver = {
+        .probe          = tps65910_rtc_probe,
+        .remove         = __devexit_p(tps65910_rtc_remove),
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "tps65910-rtc",
+                .pm     = DEV_PM_OPS,
+        },
+};
+
+module_platform_driver(tps65910_rtc_driver);
+MODULE_ALIAS("platform:rtc-tps65910");
+MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-x1205.c b/drivers/rtc/rtc-x1205.c
index 403b3d41d101..f36e59c6bc01 100644
--- a/drivers/rtc/rtc-x1205.c
+++ b/drivers/rtc/rtc-x1205.c
@@ -97,8 +97,17 @@ static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
         int i;
 
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 2, dt_addr },        /* setup read ptr */
-                { client->addr, I2C_M_RD, 8, buf },     /* read date */
+                {/* setup read ptr */
+                        .addr = client->addr,
+                        .len = 2,
+                        .buf = dt_addr
+                },
+                {/* read date */
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 8,
+                        .buf = buf
+                },
         };
 
         /* read date registers */
@@ -142,8 +151,17 @@ static int x1205_get_status(struct i2c_client *client, unsigned char *sr)
         static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
 
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 2, sr_addr },        /* setup read ptr */
-                { client->addr, I2C_M_RD, 1, sr },      /* read status */
+                {     /* setup read ptr */
+                        .addr = client->addr,
+                        .len = 2,
+                        .buf = sr_addr
+                },
+                {    /* read status */
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = sr
+                },
         };
 
         /* read status register */
@@ -279,8 +297,17 @@ static int x1205_get_dtrim(struct i2c_client *client, int *trim)
         static unsigned char dtr_addr[2] = { 0, X1205_REG_DTR };
 
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 2, dtr_addr },       /* setup read ptr */
-                { client->addr, I2C_M_RD, 1, &dtr },    /* read dtr */
+                {       /* setup read ptr */
+                        .addr = client->addr,
+                        .len = 2,
+                        .buf = dtr_addr
+                },
+                {      /* read dtr */
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = &dtr
+                },
         };
 
         /* read dtr register */
@@ -311,8 +338,17 @@ static int x1205_get_atrim(struct i2c_client *client, int *trim)
         static unsigned char atr_addr[2] = { 0, X1205_REG_ATR };
 
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 2, atr_addr },       /* setup read ptr */
-                { client->addr, I2C_M_RD, 1, &atr },    /* read atr */
+                {/* setup read ptr */
+                        .addr = client->addr,
+                        .len = 2,
+                        .buf = atr_addr
+                },
+                {/* read atr */
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = &atr
+                },
         };
 
         /* read atr register */
@@ -381,8 +417,17 @@ static int x1205_validate_client(struct i2c_client *client)
                 unsigned char addr[2] = { 0, probe_zero_pattern[i] };
 
                 struct i2c_msg msgs[2] = {
-                        { client->addr, 0, 2, addr },
-                        { client->addr, I2C_M_RD, 1, &buf },
+                        {
+                                .addr = client->addr,
+                                .len = 2,
+                                .buf = addr
+                        },
+                        {
+                                .addr = client->addr,
+                                .flags = I2C_M_RD,
+                                .len = 1,
+                                .buf = &buf
+                        },
                 };
 
                 if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
@@ -409,8 +454,17 @@ static int x1205_validate_client(struct i2c_client *client)
                 unsigned char addr[2] = { 0, probe_limits_pattern[i].reg };
 
                 struct i2c_msg msgs[2] = {
-                        { client->addr, 0, 2, addr },
-                        { client->addr, I2C_M_RD, 1, &reg },
+                        {
+                                .addr = client->addr,
+                                .len = 2,
+                                .buf = addr
+                        },
+                        {
+                                .addr = client->addr,
+                                .flags = I2C_M_RD,
+                                .len = 1,
+                                .buf = &reg
+                        },
                 };
 
                 if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
@@ -444,8 +498,18 @@ static int x1205_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
         static unsigned char int_addr[2] = { 0, X1205_REG_INT };
         struct i2c_client *client = to_i2c_client(dev);
         struct i2c_msg msgs[] = {
-                { client->addr, 0, 2, int_addr },        /* setup read ptr */
-                { client->addr, I2C_M_RD, 1, &intreg },  /* read INT register */
+                { /* setup read ptr */
+                        .addr = client->addr,
+                        .len = 2,
+                        .buf = int_addr
+                },
+                {/* read INT register */
+
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = &intreg
+                },
         };
 
         /* read interrupt register and status register */
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 7199534cd07d..cb7f1582a6d1 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -93,7 +93,7 @@ static DECLARE_PCI_DEVICE_TABLE(aac_pci_tbl) = {
 #elif defined(__devinitconst)
 static const struct pci_device_id aac_pci_tbl[] __devinitconst = {
 #else
-static const struct pci_device_id aac_pci_tbl[] __devinitdata = {
+static const struct pci_device_id aac_pci_tbl[] __devinitconst = {
 #endif
         { 0x1028, 0x0001, 0x1028, 0x0001, 0, 0, 0 }, /* PERC 2/Si (Iguana/PERC2Si) */
         { 0x1028, 0x0002, 0x1028, 0x0002, 0, 0, 1 }, /* PERC 3/Di (Opal/PERC3Di) */
diff --git a/drivers/scsi/aic94xx/aic94xx_init.c b/drivers/scsi/aic94xx/aic94xx_init.c
index ff80552ead84..1c4120c3db41 100644
--- a/drivers/scsi/aic94xx/aic94xx_init.c
+++ b/drivers/scsi/aic94xx/aic94xx_init.c
@@ -1012,7 +1012,7 @@ static struct sas_domain_function_template aic94xx_transport_functions = {
         .lldd_ata_set_dmamode   = asd_set_dmamode,
 };
 
-static const struct pci_device_id aic94xx_pci_table[] __devinitdata = {
+static const struct pci_device_id aic94xx_pci_table[] __devinitconst = {
         {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x410),0, 0, 1},
         {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x412),0, 0, 1},
         {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x416),0, 0, 1},
diff --git a/drivers/scsi/atp870u.c b/drivers/scsi/atp870u.c
index 68ce08552f69..a540162ac59c 100644
--- a/drivers/scsi/atp870u.c
+++ b/drivers/scsi/atp870u.c
@@ -1173,7 +1173,16 @@ wait_io1:
         outw(val, tmport);
         outb(2, 0x80);
 TCM_SYNC:
-        udelay(0x800);
+        /*
+         * The funny division into multiple delays is to accomodate
+         * arches like ARM where udelay() multiplies its argument by
+         * a large number to initialize a loop counter.  To avoid
+         * overflow, the maximum supported udelay is 2000 microseconds.
+         *
+         * XXX it would be more polite to find a way to use msleep()
+         */
+        mdelay(2);
+        udelay(48);
         if ((inb(tmport) & 0x80) == 0x00) {     /* bsy ? */
                 outw(0, tmport--);
                 outb(0, tmport);
diff --git a/drivers/thermal/thermal_sys.c b/drivers/thermal/thermal_sys.c
index 67789b8345d2..efd81bb25e01 100644
--- a/drivers/thermal/thermal_sys.c
+++ b/drivers/thermal/thermal_sys.c
@@ -78,7 +78,7 @@ again:
         else if (unlikely(err))
                 return err;
 
-        *id = *id & MAX_ID_MASK;
+        *id = *id & MAX_IDR_MASK;
         return 0;
 }
 
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index 747442d2c0f6..0fefa84ed9ae 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -149,7 +149,7 @@ enum {
 };
 
 /* Must match above enum */
-static const char *r128_family[] __devinitdata = {
+static char * const r128_family[] __devinitconst = {
         "AGP",
         "PCI",
         "PRO AGP",
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 63cee2e9d622..c101697a4ba7 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -229,13 +229,6 @@ config BACKLIGHT_HP700
           If you have an HP Jornada 700 series,
           say Y to include backlight control driver.
 
-config BACKLIGHT_PROGEAR
-        tristate "Frontpath ProGear Backlight Driver"
-        depends on PCI && X86
-        help
-          If you have a Frontpath ProGear say Y to enable the
-          backlight driver.
-
 config BACKLIGHT_CARILLO_RANCH
         tristate "Intel Carillo Ranch Backlight Driver"
         depends on LCD_CLASS_DEVICE && PCI && X86 && FB_LE80578
@@ -352,6 +345,22 @@ config BACKLIGHT_AAT2870
           If you have a AnalogicTech AAT2870 say Y to enable the
           backlight driver.
 
+config BACKLIGHT_LM3630
+        tristate "Backlight Driver for LM3630"
+        depends on BACKLIGHT_CLASS_DEVICE && I2C
+        select REGMAP_I2C
+        help
+          This supports TI LM3630 Backlight Driver
+
+config BACKLIGHT_LM3639
+        tristate "Backlight Driver for LM3639"
+        depends on BACKLIGHT_CLASS_DEVICE && I2C
+        select REGMAP_I2C
+        select NEW_LEDS
+        select LEDS_CLASS
+        help
+          This supports TI LM3639 Backlight + 1.5A Flash LED Driver
+
 config BACKLIGHT_LP855X
         tristate "Backlight driver for TI LP855X"
         depends on BACKLIGHT_CLASS_DEVICE && I2C
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 00223a62ec12..e7ce7291635d 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -23,10 +23,11 @@ obj-$(CONFIG_BACKLIGHT_HP700)	+= jornada720_bl.o
 obj-$(CONFIG_BACKLIGHT_HP680)   += hp680_bl.o
 obj-$(CONFIG_BACKLIGHT_LM3533)  += lm3533_bl.o
 obj-$(CONFIG_BACKLIGHT_LOCOMO)  += locomolcd.o
+obj-$(CONFIG_BACKLIGHT_LM3630)  += lm3630_bl.o
+obj-$(CONFIG_BACKLIGHT_LM3639)  += lm3639_bl.o
 obj-$(CONFIG_BACKLIGHT_LP855X)  += lp855x_bl.o
 obj-$(CONFIG_BACKLIGHT_OMAP1)   += omap1_bl.o
 obj-$(CONFIG_BACKLIGHT_PANDORA) += pandora_bl.o
-obj-$(CONFIG_BACKLIGHT_PROGEAR) += progear_bl.o
 obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o
 obj-$(CONFIG_BACKLIGHT_PWM)     += pwm_bl.o
 obj-$(CONFIG_BACKLIGHT_DA903X)  += da903x_bl.o
diff --git a/drivers/video/backlight/da9052_bl.c b/drivers/video/backlight/da9052_bl.c
index b628d68f5162..ac196181fe45 100644
--- a/drivers/video/backlight/da9052_bl.c
+++ b/drivers/video/backlight/da9052_bl.c
@@ -72,7 +72,7 @@ static int da9052_adjust_wled_brightness(struct da9052_bl *wleds)
         if (ret < 0)
                 return ret;
 
-        msleep(10);
+        usleep_range(10000, 11000);
 
         if (wleds->brightness) {
                 ret = da9052_reg_write(wleds->da9052, wled_bank[wleds->led_reg],
@@ -129,7 +129,6 @@ static int da9052_backlight_probe(struct platform_device *pdev)
                                        &da9052_backlight_ops, &props);
         if (IS_ERR(bl)) {
                 dev_err(&pdev->dev, "Failed to register backlight\n");
-                devm_kfree(&pdev->dev, wleds);
                 return PTR_ERR(bl);
         }
 
@@ -149,7 +148,6 @@ static int da9052_backlight_remove(struct platform_device *pdev)
         wleds->state = DA9052_WLEDS_OFF;
         da9052_adjust_wled_brightness(wleds);
         backlight_device_unregister(bl);
-        devm_kfree(&pdev->dev, wleds);
 
         return 0;
 }
diff --git a/drivers/video/backlight/kb3886_bl.c b/drivers/video/backlight/kb3886_bl.c
index 72dd5556a35b..6c5ed6b242cc 100644
--- a/drivers/video/backlight/kb3886_bl.c
+++ b/drivers/video/backlight/kb3886_bl.c
@@ -34,9 +34,9 @@ static void kb3886_bl_set_intensity(int intensity)
         mutex_lock(&bl_mutex);
         intensity = intensity&0xff;
         outb(KB3886_ADC_DAC_PWM, KB3886_PARENT);
-        msleep(10);
+        usleep_range(10000, 11000);
         outb(KB3886_PWM0_WRITE, KB3886_IO);
-        msleep(10);
+        usleep_range(10000, 11000);
         outb(intensity, KB3886_IO);
         mutex_unlock(&bl_mutex);
 }
diff --git a/drivers/video/backlight/lm3630_bl.c b/drivers/video/backlight/lm3630_bl.c
new file mode 100644
index 000000000000..dc191441796f
--- /dev/null
+++ b/drivers/video/backlight/lm3630_bl.c
@@ -0,0 +1,475 @@
+/*
+* Simple driver for Texas Instruments LM3630 Backlight driver chip
+* Copyright (C) 2012 Texas Instruments
+*
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+*/
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/backlight.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/uaccess.h>
+#include <linux/interrupt.h>
+#include <linux/regmap.h>
+#include <linux/platform_data/lm3630_bl.h>
+
+#define REG_CTRL        0x00
+#define REG_CONFIG      0x01
+#define REG_BRT_A       0x03
+#define REG_BRT_B       0x04
+#define REG_INT_STATUS  0x09
+#define REG_INT_EN      0x0A
+#define REG_FAULT       0x0B
+#define REG_PWM_OUTLOW  0x12
+#define REG_PWM_OUTHIGH 0x13
+#define REG_MAX         0x1F
+
+#define INT_DEBOUNCE_MSEC       10
+
+enum lm3630_leds {
+        BLED_ALL = 0,
+        BLED_1,
+        BLED_2
+};
+
+static const char *bled_name[] = {
+        [BLED_ALL] = "lm3630_bled",     /*Bank1 controls all string */
+        [BLED_1] = "lm3630_bled1",      /*Bank1 controls bled1 */
+        [BLED_2] = "lm3630_bled2",      /*Bank1 or 2 controls bled2 */
+};
+
+struct lm3630_chip_data {
+        struct device *dev;
+        struct delayed_work work;
+        int irq;
+        struct workqueue_struct *irqthread;
+        struct lm3630_platform_data *pdata;
+        struct backlight_device *bled1;
+        struct backlight_device *bled2;
+        struct regmap *regmap;
+};
+
+/* initialize chip */
+static int __devinit lm3630_chip_init(struct lm3630_chip_data *pchip)
+{
+        int ret;
+        unsigned int reg_val;
+        struct lm3630_platform_data *pdata = pchip->pdata;
+
+        /*pwm control */
+        reg_val = ((pdata->pwm_active & 0x01) << 2) | (pdata->pwm_ctrl & 0x03);
+        ret = regmap_update_bits(pchip->regmap, REG_CONFIG, 0x07, reg_val);
+        if (ret < 0)
+                goto out;
+
+        /* bank control */
+        reg_val = ((pdata->bank_b_ctrl & 0x01) << 1) |
+                        (pdata->bank_a_ctrl & 0x07);
+        ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x07, reg_val);
+        if (ret < 0)
+                goto out;
+
+        ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00);
+        if (ret < 0)
+                goto out;
+
+        /* set initial brightness */
+        if (pdata->bank_a_ctrl != BANK_A_CTRL_DISABLE) {
+                ret = regmap_write(pchip->regmap,
+                                   REG_BRT_A, pdata->init_brt_led1);
+                if (ret < 0)
+                        goto out;
+        }
+
+        if (pdata->bank_b_ctrl != BANK_B_CTRL_DISABLE) {
+                ret = regmap_write(pchip->regmap,
+                                   REG_BRT_B, pdata->init_brt_led2);
+                if (ret < 0)
+                        goto out;
+        }
+        return ret;
+
+out:
+        dev_err(pchip->dev, "i2c failed to access register\n");
+        return ret;
+}
+
+/* interrupt handling */
+static void lm3630_delayed_func(struct work_struct *work)
+{
+        int ret;
+        unsigned int reg_val;
+        struct lm3630_chip_data *pchip;
+
+        pchip = container_of(work, struct lm3630_chip_data, work.work);
+
+        ret = regmap_read(pchip->regmap, REG_INT_STATUS, &reg_val);
+        if (ret < 0) {
+                dev_err(pchip->dev,
+                        "i2c failed to access REG_INT_STATUS Register\n");
+                return;
+        }
+
+        dev_info(pchip->dev, "REG_INT_STATUS Register is 0x%x\n", reg_val);
+}
+
+static irqreturn_t lm3630_isr_func(int irq, void *chip)
+{
+        int ret;
+        struct lm3630_chip_data *pchip = chip;
+        unsigned long delay = msecs_to_jiffies(INT_DEBOUNCE_MSEC);
+
+        queue_delayed_work(pchip->irqthread, &pchip->work, delay);
+
+        ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00);
+        if (ret < 0)
+                goto out;
+
+        return IRQ_HANDLED;
+out:
+        dev_err(pchip->dev, "i2c failed to access register\n");
+        return IRQ_HANDLED;
+}
+
+static int lm3630_intr_config(struct lm3630_chip_data *pchip)
+{
+        INIT_DELAYED_WORK(&pchip->work, lm3630_delayed_func);
+        pchip->irqthread = create_singlethread_workqueue("lm3630-irqthd");
+        if (!pchip->irqthread) {
+                dev_err(pchip->dev, "create irq thread fail...\n");
+                return -1;
+        }
+        if (request_threaded_irq
+            (pchip->irq, NULL, lm3630_isr_func,
+             IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "lm3630_irq", pchip)) {
+                dev_err(pchip->dev, "request threaded irq fail..\n");
+                return -1;
+        }
+        return 0;
+}
+
+static bool
+set_intensity(struct backlight_device *bl, struct lm3630_chip_data *pchip)
+{
+        if (!pchip->pdata->pwm_set_intensity)
+                return false;
+        pchip->pdata->pwm_set_intensity(bl->props.brightness - 1,
+                                        pchip->pdata->pwm_period);
+        return true;
+}
+
+/* update and get brightness */
+static int lm3630_bank_a_update_status(struct backlight_device *bl)
+{
+        int ret;
+        struct lm3630_chip_data *pchip = bl_get_data(bl);
+        enum lm3630_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
+
+        /* brightness 0 means disable */
+        if (!bl->props.brightness) {
+                ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x04, 0x00);
+                if (ret < 0)
+                        goto out;
+                return bl->props.brightness;
+        }
+
+        /* pwm control */
+        if (pwm_ctrl == PWM_CTRL_BANK_A || pwm_ctrl == PWM_CTRL_BANK_ALL) {
+                if (!set_intensity(bl, pchip))
+                        dev_err(pchip->dev, "No pwm control func. in plat-data\n");
+        } else {
+
+                /* i2c control */
+                ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00);
+                if (ret < 0)
+                        goto out;
+                mdelay(1);
+                ret = regmap_write(pchip->regmap,
+                                   REG_BRT_A, bl->props.brightness - 1);
+                if (ret < 0)
+                        goto out;
+        }
+        return bl->props.brightness;
+out:
+        dev_err(pchip->dev, "i2c failed to access REG_CTRL\n");
+        return bl->props.brightness;
+}
+
+static int lm3630_bank_a_get_brightness(struct backlight_device *bl)
+{
+        unsigned int reg_val;
+        int brightness, ret;
+        struct lm3630_chip_data *pchip = bl_get_data(bl);
+        enum lm3630_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
+
+        if (pwm_ctrl == PWM_CTRL_BANK_A || pwm_ctrl == PWM_CTRL_BANK_ALL) {
+                ret = regmap_read(pchip->regmap, REG_PWM_OUTHIGH, &reg_val);
+                if (ret < 0)
+                        goto out;
+                brightness = reg_val & 0x01;
+                ret = regmap_read(pchip->regmap, REG_PWM_OUTLOW, &reg_val);
+                if (ret < 0)
+                        goto out;
+                brightness = ((brightness << 8) | reg_val) + 1;
+        } else {
+                ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00);
+                if (ret < 0)
+                        goto out;
+                mdelay(1);
+                ret = regmap_read(pchip->regmap, REG_BRT_A, &reg_val);
+                if (ret < 0)
+                        goto out;
+                brightness = reg_val + 1;
+        }
+        bl->props.brightness = brightness;
+        return bl->props.brightness;
+out:
+        dev_err(pchip->dev, "i2c failed to access register\n");
+        return 0;
+}
+
+static const struct backlight_ops lm3630_bank_a_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
+        .update_status = lm3630_bank_a_update_status,
+        .get_brightness = lm3630_bank_a_get_brightness,
+};
+
+static int lm3630_bank_b_update_status(struct backlight_device *bl)
+{
+        int ret;
+        struct lm3630_chip_data *pchip = bl_get_data(bl);
+        enum lm3630_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
+
+        if (pwm_ctrl == PWM_CTRL_BANK_B || pwm_ctrl == PWM_CTRL_BANK_ALL) {
+                if (!set_intensity(bl, pchip))
+                        dev_err(pchip->dev,
+                                "no pwm control func. in plat-data\n");
+        } else {
+                ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00);
+                if (ret < 0)
+                        goto out;
+                mdelay(1);
+                ret = regmap_write(pchip->regmap,
+                                   REG_BRT_B, bl->props.brightness - 1);
+        }
+        return bl->props.brightness;
+out:
+        dev_err(pchip->dev, "i2c failed to access register\n");
+        return bl->props.brightness;
+}
+
+static int lm3630_bank_b_get_brightness(struct backlight_device *bl)
+{
+        unsigned int reg_val;
+        int brightness, ret;
+        struct lm3630_chip_data *pchip = bl_get_data(bl);
+        enum lm3630_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
+
+        if (pwm_ctrl == PWM_CTRL_BANK_B || pwm_ctrl == PWM_CTRL_BANK_ALL) {
+                ret = regmap_read(pchip->regmap, REG_PWM_OUTHIGH, &reg_val);
+                if (ret < 0)
+                        goto out;
+                brightness = reg_val & 0x01;
+                ret = regmap_read(pchip->regmap, REG_PWM_OUTLOW, &reg_val);
+                if (ret < 0)
+                        goto out;
+                brightness = ((brightness << 8) | reg_val) + 1;
+        } else {
+                ret = regmap_update_bits(pchip->regmap, REG_CTRL, 0x80, 0x00);
+                if (ret < 0)
+                        goto out;
+                mdelay(1);
+                ret = regmap_read(pchip->regmap, REG_BRT_B, &reg_val);
+                if (ret < 0)
+                        goto out;
+                brightness = reg_val + 1;
+        }
+        bl->props.brightness = brightness;
+
+        return bl->props.brightness;
+out:
+        dev_err(pchip->dev, "i2c failed to access register\n");
+        return bl->props.brightness;
+}
+
+static const struct backlight_ops lm3630_bank_b_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
+        .update_status = lm3630_bank_b_update_status,
+        .get_brightness = lm3630_bank_b_get_brightness,
+};
+
+static int lm3630_backlight_register(struct lm3630_chip_data *pchip,
+                                     enum lm3630_leds ledno)
+{
+        const char *name = bled_name[ledno];
+        struct backlight_properties props;
+        struct lm3630_platform_data *pdata = pchip->pdata;
+
+        props.type = BACKLIGHT_RAW;
+        switch (ledno) {
+        case BLED_1:
+        case BLED_ALL:
+                props.brightness = pdata->init_brt_led1;
+                props.max_brightness = pdata->max_brt_led1;
+                pchip->bled1 =
+                    backlight_device_register(name, pchip->dev, pchip,
+                                              &lm3630_bank_a_ops, &props);
+                if (IS_ERR(pchip->bled1))
+                        return -EIO;
+                break;
+        case BLED_2:
+                props.brightness = pdata->init_brt_led2;
+                props.max_brightness = pdata->max_brt_led2;
+                pchip->bled2 =
+                    backlight_device_register(name, pchip->dev, pchip,
+                                              &lm3630_bank_b_ops, &props);
+                if (IS_ERR(pchip->bled2))
+                        return -EIO;
+                break;
+        }
+        return 0;
+}
+
+static void lm3630_backlight_unregister(struct lm3630_chip_data *pchip)
+{
+        if (pchip->bled1)
+                backlight_device_unregister(pchip->bled1);
+        if (pchip->bled2)
+                backlight_device_unregister(pchip->bled2);
+}
+
+static const struct regmap_config lm3630_regmap = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = REG_MAX,
+};
+
+static int __devinit lm3630_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
+{
+        struct lm3630_platform_data *pdata = client->dev.platform_data;
+        struct lm3630_chip_data *pchip;
+        int ret;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+                dev_err(&client->dev, "fail : i2c functionality check...\n");
+                return -EOPNOTSUPP;
+        }
+
+        if (pdata == NULL) {
+                dev_err(&client->dev, "fail : no platform data.\n");
+                return -ENODATA;
+        }
+
+        pchip = devm_kzalloc(&client->dev, sizeof(struct lm3630_chip_data),
+                             GFP_KERNEL);
+        if (!pchip)
+                return -ENOMEM;
+        pchip->pdata = pdata;
+        pchip->dev = &client->dev;
+
+        pchip->regmap = devm_regmap_init_i2c(client, &lm3630_regmap);
+        if (IS_ERR(pchip->regmap)) {
+                ret = PTR_ERR(pchip->regmap);
+                dev_err(&client->dev, "fail : allocate register map: %d\n",
+                        ret);
+                return ret;
+        }
+        i2c_set_clientdata(client, pchip);
+
+        /* chip initialize */
+        ret = lm3630_chip_init(pchip);
+        if (ret < 0) {
+                dev_err(&client->dev, "fail : init chip\n");
+                goto err_chip_init;
+        }
+
+        switch (pdata->bank_a_ctrl) {
+        case BANK_A_CTRL_ALL:
+                ret = lm3630_backlight_register(pchip, BLED_ALL);
+                pdata->bank_b_ctrl = BANK_B_CTRL_DISABLE;
+                break;
+        case BANK_A_CTRL_LED1:
+                ret = lm3630_backlight_register(pchip, BLED_1);
+                break;
+        case BANK_A_CTRL_LED2:
+                ret = lm3630_backlight_register(pchip, BLED_2);
+                pdata->bank_b_ctrl = BANK_B_CTRL_DISABLE;
+                break;
+        default:
+                break;
+        }
+
+        if (ret < 0)
+                goto err_bl_reg;
+
+        if (pdata->bank_b_ctrl && pchip->bled2 == NULL) {
+                ret = lm3630_backlight_register(pchip, BLED_2);
+                if (ret < 0)
+                        goto err_bl_reg;
+        }
+
+        /* interrupt enable  : irq 0 is not allowed for lm3630 */
+        pchip->irq = client->irq;
+        if (pchip->irq)
+                lm3630_intr_config(pchip);
+
+        dev_info(&client->dev, "LM3630 backlight register OK.\n");
+        return 0;
+
+err_bl_reg:
+        dev_err(&client->dev, "fail : backlight register.\n");
+        lm3630_backlight_unregister(pchip);
+err_chip_init:
+        return ret;
+}
+
+static int __devexit lm3630_remove(struct i2c_client *client)
+{
+        int ret;
+        struct lm3630_chip_data *pchip = i2c_get_clientdata(client);
+
+        ret = regmap_write(pchip->regmap, REG_BRT_A, 0);
+        if (ret < 0)
+                dev_err(pchip->dev, "i2c failed to access register\n");
+
+        ret = regmap_write(pchip->regmap, REG_BRT_B, 0);
+        if (ret < 0)
+                dev_err(pchip->dev, "i2c failed to access register\n");
+
+        lm3630_backlight_unregister(pchip);
+        if (pchip->irq) {
+                free_irq(pchip->irq, pchip);
+                flush_workqueue(pchip->irqthread);
+                destroy_workqueue(pchip->irqthread);
+        }
+        return 0;
+}
+
+static const struct i2c_device_id lm3630_id[] = {
+        {LM3630_NAME, 0},
+        {}
+};
+
+MODULE_DEVICE_TABLE(i2c, lm3630_id);
+
+static struct i2c_driver lm3630_i2c_driver = {
+        .driver = {
+                   .name = LM3630_NAME,
+                   },
+        .probe = lm3630_probe,
+        .remove = __devexit_p(lm3630_remove),
+        .id_table = lm3630_id,
+};
+
+module_i2c_driver(lm3630_i2c_driver);
+
+MODULE_DESCRIPTION("Texas Instruments Backlight driver for LM3630");
+MODULE_AUTHOR("G.Shark Jeong <gshark.jeong@gmail.com>");
+MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/video/backlight/lm3639_bl.c b/drivers/video/backlight/lm3639_bl.c
new file mode 100644
index 000000000000..c6915c6c3cd1
--- /dev/null
+++ b/drivers/video/backlight/lm3639_bl.c
@@ -0,0 +1,437 @@
+/*
+* Simple driver for Texas Instruments LM3639 Backlight + Flash LED driver chip
+* Copyright (C) 2012 Texas Instruments
+*
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+*/
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/leds.h>
+#include <linux/backlight.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/uaccess.h>
+#include <linux/interrupt.h>
+#include <linux/regmap.h>
+#include <linux/platform_data/lm3639_bl.h>
+
+#define REG_DEV_ID      0x00
+#define REG_CHECKSUM    0x01
+#define REG_BL_CONF_1   0x02
+#define REG_BL_CONF_2   0x03
+#define REG_BL_CONF_3   0x04
+#define REG_BL_CONF_4   0x05
+#define REG_FL_CONF_1   0x06
+#define REG_FL_CONF_2   0x07
+#define REG_FL_CONF_3   0x08
+#define REG_IO_CTRL     0x09
+#define REG_ENABLE      0x0A
+#define REG_FLAG        0x0B
+#define REG_MAX         REG_FLAG
+
+struct lm3639_chip_data {
+        struct device *dev;
+        struct lm3639_platform_data *pdata;
+
+        struct backlight_device *bled;
+        struct led_classdev cdev_flash;
+        struct led_classdev cdev_torch;
+        struct regmap *regmap;
+
+        unsigned int bled_mode;
+        unsigned int bled_map;
+        unsigned int last_flag;
+};
+
+/* initialize chip */
+static int __devinit lm3639_chip_init(struct lm3639_chip_data *pchip)
+{
+        int ret;
+        unsigned int reg_val;
+        struct lm3639_platform_data *pdata = pchip->pdata;
+
+        /* input pins config. */
+        ret =
+            regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x08,
+                               pdata->pin_pwm);
+        if (ret < 0)
+                goto out;
+
+        reg_val = (pdata->pin_pwm & 0x40) | pdata->pin_strobe | pdata->pin_tx;
+        ret = regmap_update_bits(pchip->regmap, REG_IO_CTRL, 0x7C, reg_val);
+        if (ret < 0)
+                goto out;
+
+        /* init brightness */
+        ret = regmap_write(pchip->regmap, REG_BL_CONF_4, pdata->init_brt_led);
+        if (ret < 0)
+                goto out;
+
+        ret = regmap_write(pchip->regmap, REG_BL_CONF_3, pdata->init_brt_led);
+        if (ret < 0)
+                goto out;
+
+        /* output pins config. */
+        if (!pdata->init_brt_led)
+                reg_val = pdata->fled_pins | pdata->bled_pins;
+        else
+                reg_val = pdata->fled_pins | pdata->bled_pins | 0x01;
+
+        ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x79, reg_val);
+        if (ret < 0)
+                goto out;
+
+        return ret;
+out:
+        dev_err(pchip->dev, "i2c failed to access register\n");
+        return ret;
+}
+
+/* update and get brightness */
+static int lm3639_bled_update_status(struct backlight_device *bl)
+{
+        int ret;
+        unsigned int reg_val;
+        struct lm3639_chip_data *pchip = bl_get_data(bl);
+        struct lm3639_platform_data *pdata = pchip->pdata;
+
+        ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val);
+        if (ret < 0)
+                goto out;
+
+        if (reg_val != 0)
+                dev_info(pchip->dev, "last flag is 0x%x\n", reg_val);
+
+        /* pwm control */
+        if (pdata->pin_pwm) {
+                if (pdata->pwm_set_intensity)
+                        pdata->pwm_set_intensity(bl->props.brightness,
+                                                 pdata->max_brt_led);
+                else
+                        dev_err(pchip->dev,
+                                "No pwm control func. in plat-data\n");
+                return bl->props.brightness;
+        }
+
+        /* i2c control and set brigtness */
+        ret = regmap_write(pchip->regmap, REG_BL_CONF_4, bl->props.brightness);
+        if (ret < 0)
+                goto out;
+        ret = regmap_write(pchip->regmap, REG_BL_CONF_3, bl->props.brightness);
+        if (ret < 0)
+                goto out;
+
+        if (!bl->props.brightness)
+                ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x00);
+        else
+                ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x01);
+        if (ret < 0)
+                goto out;
+
+        return bl->props.brightness;
+out:
+        dev_err(pchip->dev, "i2c failed to access registers\n");
+        return bl->props.brightness;
+}
+
+static int lm3639_bled_get_brightness(struct backlight_device *bl)
+{
+        int ret;
+        unsigned int reg_val;
+        struct lm3639_chip_data *pchip = bl_get_data(bl);
+        struct lm3639_platform_data *pdata = pchip->pdata;
+
+        if (pdata->pin_pwm) {
+                if (pdata->pwm_get_intensity)
+                        bl->props.brightness = pdata->pwm_get_intensity();
+                else
+                        dev_err(pchip->dev,
+                                "No pwm control func. in plat-data\n");
+                return bl->props.brightness;
+        }
+
+        ret = regmap_read(pchip->regmap, REG_BL_CONF_1, &reg_val);
+        if (ret < 0)
+                goto out;
+        if (reg_val & 0x10)
+                ret = regmap_read(pchip->regmap, REG_BL_CONF_4, &reg_val);
+        else
+                ret = regmap_read(pchip->regmap, REG_BL_CONF_3, &reg_val);
+        if (ret < 0)
+                goto out;
+        bl->props.brightness = reg_val;
+
+        return bl->props.brightness;
+out:
+        dev_err(pchip->dev, "i2c failed to access register\n");
+        return bl->props.brightness;
+}
+
+static const struct backlight_ops lm3639_bled_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
+        .update_status = lm3639_bled_update_status,
+        .get_brightness = lm3639_bled_get_brightness,
+};
+
+/* backlight mapping mode */
+static ssize_t lm3639_bled_mode_store(struct device *dev,
+                                      struct device_attribute *devAttr,
+                                      const char *buf, size_t size)
+{
+        ssize_t ret;
+        struct lm3639_chip_data *pchip = dev_get_drvdata(dev);
+        unsigned int state;
+
+        ret = kstrtouint(buf, 10, &state);
+        if (ret)
+                goto out_input;
+
+        if (!state)
+                ret =
+                    regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10,
+                                       0x00);
+        else
+                ret =
+                    regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10,
+                                       0x10);
+
+        if (ret < 0)
+                goto out;
+
+        return size;
+
+out:
+        dev_err(pchip->dev, "%s:i2c access fail to register\n", __func__);
+        return size;
+
+out_input:
+        dev_err(pchip->dev, "%s:input conversion fail\n", __func__);
+        return size;
+
+}
+
+static DEVICE_ATTR(bled_mode, 0666, NULL, lm3639_bled_mode_store);
+
+/* torch */
+static void lm3639_torch_brightness_set(struct led_classdev *cdev,
+                                        enum led_brightness brightness)
+{
+        int ret;
+        unsigned int reg_val;
+        struct lm3639_chip_data *pchip;
+
+        pchip = container_of(cdev, struct lm3639_chip_data, cdev_torch);
+
+        ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val);
+        if (ret < 0)
+                goto out;
+        if (reg_val != 0)
+                dev_info(pchip->dev, "last flag is 0x%x\n", reg_val);
+
+        /* brightness 0 means off state */
+        if (!brightness) {
+                ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00);
+                if (ret < 0)
+                        goto out;
+                return;
+        }
+
+        ret = regmap_update_bits(pchip->regmap,
+                                 REG_FL_CONF_1, 0x70, (brightness - 1) << 4);
+        if (ret < 0)
+                goto out;
+        ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x02);
+        if (ret < 0)
+                goto out;
+
+        return;
+out:
+        dev_err(pchip->dev, "i2c failed to access register\n");
+        return;
+}
+
+/* flash */
+static void lm3639_flash_brightness_set(struct led_classdev *cdev,
+                                        enum led_brightness brightness)
+{
+        int ret;
+        unsigned int reg_val;
+        struct lm3639_chip_data *pchip;
+
+        pchip = container_of(cdev, struct lm3639_chip_data, cdev_flash);
+
+        ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val);
+        if (ret < 0)
+                goto out;
+        if (reg_val != 0)
+                dev_info(pchip->dev, "last flag is 0x%x\n", reg_val);
+
+        /* torch off before flash control */
+        ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00);
+        if (ret < 0)
+                goto out;
+
+        /* brightness 0 means off state */
+        if (!brightness)
+                return;
+
+        ret = regmap_update_bits(pchip->regmap,
+                                 REG_FL_CONF_1, 0x0F, brightness - 1);
+        if (ret < 0)
+                goto out;
+        ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x06);
+        if (ret < 0)
+                goto out;
+
+        return;
+out:
+        dev_err(pchip->dev, "i2c failed to access register\n");
+        return;
+}
+
+static const struct regmap_config lm3639_regmap = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = REG_MAX,
+};
+
+static int __devinit lm3639_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
+{
+        int ret;
+        struct lm3639_chip_data *pchip;
+        struct lm3639_platform_data *pdata = client->dev.platform_data;
+        struct backlight_properties props;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+                dev_err(&client->dev, "i2c functionality check fail.\n");
+                return -EOPNOTSUPP;
+        }
+
+        if (pdata == NULL) {
+                dev_err(&client->dev, "Needs Platform Data.\n");
+                return -ENODATA;
+        }
+
+        pchip = devm_kzalloc(&client->dev,
+                             sizeof(struct lm3639_chip_data), GFP_KERNEL);
+        if (!pchip)
+                return -ENOMEM;
+
+        pchip->pdata = pdata;
+        pchip->dev = &client->dev;
+
+        pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap);
+        if (IS_ERR(pchip->regmap)) {
+                ret = PTR_ERR(pchip->regmap);
+                dev_err(&client->dev, "fail : allocate register map: %d\n",
+                        ret);
+                return ret;
+        }
+        i2c_set_clientdata(client, pchip);
+
+        /* chip initialize */
+        ret = lm3639_chip_init(pchip);
+        if (ret < 0) {
+                dev_err(&client->dev, "fail : chip init\n");
+                goto err_out;
+        }
+
+        /* backlight */
+        props.type = BACKLIGHT_RAW;
+        props.brightness = pdata->init_brt_led;
+        props.max_brightness = pdata->max_brt_led;
+        pchip->bled =
+            backlight_device_register("lm3639_bled", pchip->dev, pchip,
+                                      &lm3639_bled_ops, &props);
+        if (IS_ERR(pchip->bled)) {
+                dev_err(&client->dev, "fail : backlight register\n");
+                ret = -EIO;
+                goto err_out;
+        }
+
+        ret = device_create_file(&(pchip->bled->dev), &dev_attr_bled_mode);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed : add sysfs entries\n");
+                ret = -EIO;
+                goto err_bled_mode;
+        }
+
+        /* flash */
+        pchip->cdev_flash.name = "lm3639_flash";
+        pchip->cdev_flash.max_brightness = 16;
+        pchip->cdev_flash.brightness_set = lm3639_flash_brightness_set;
+        ret = led_classdev_register((struct device *)
+                                    &client->dev, &pchip->cdev_flash);
+        if (ret < 0) {
+                dev_err(&client->dev, "fail : flash register\n");
+                ret = -EIO;
+                goto err_flash;
+        }
+
+        /* torch */
+        pchip->cdev_torch.name = "lm3639_torch";
+        pchip->cdev_torch.max_brightness = 8;
+        pchip->cdev_torch.brightness_set = lm3639_torch_brightness_set;
+        ret = led_classdev_register((struct device *)
+                                    &client->dev, &pchip->cdev_torch);
+        if (ret < 0) {
+                dev_err(&client->dev, "fail : torch register\n");
+                ret = -EIO;
+                goto err_torch;
+        }
+
+        return 0;
+
+err_torch:
+        led_classdev_unregister(&pchip->cdev_flash);
+err_flash:
+        device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode);
+err_bled_mode:
+        backlight_device_unregister(pchip->bled);
+err_out:
+        return ret;
+}
+
+static int __devexit lm3639_remove(struct i2c_client *client)
+{
+        struct lm3639_chip_data *pchip = i2c_get_clientdata(client);
+
+        regmap_write(pchip->regmap, REG_ENABLE, 0x00);
+
+        if (&pchip->cdev_torch)
+                led_classdev_unregister(&pchip->cdev_torch);
+        if (&pchip->cdev_flash)
+                led_classdev_unregister(&pchip->cdev_flash);
+        if (pchip->bled) {
+                device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode);
+                backlight_device_unregister(pchip->bled);
+        }
+        return 0;
+}
+
+static const struct i2c_device_id lm3639_id[] = {
+        {LM3639_NAME, 0},
+        {}
+};
+
+MODULE_DEVICE_TABLE(i2c, lm3639_id);
+static struct i2c_driver lm3639_i2c_driver = {
+        .driver = {
+                   .name = LM3639_NAME,
+                   },
+        .probe = lm3639_probe,
+        .remove = __devexit_p(lm3639_remove),
+        .id_table = lm3639_id,
+};
+
+module_i2c_driver(lm3639_i2c_driver);
+
+MODULE_DESCRIPTION("Texas Instruments Backlight+Flash LED driver for LM3639");
+MODULE_AUTHOR("Daniel Jeong <daniel.jeong@ti.com>");
+MODULE_AUTHOR("G.Shark Jeong <gshark.jeong@gmail.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/video/backlight/ltv350qv.c b/drivers/video/backlight/ltv350qv.c
index 6c0f1ac0d32a..4066a5bbd826 100644
--- a/drivers/video/backlight/ltv350qv.c
+++ b/drivers/video/backlight/ltv350qv.c
@@ -75,7 +75,7 @@ static int ltv350qv_power_on(struct ltv350qv *lcd)
         /* Power On Reset Display off State */
         if (ltv350qv_write_reg(lcd, LTV_PWRCTL1, 0x0000))
                 goto err;
-        msleep(15);
+        usleep_range(15000, 16000);
 
         /* Power Setting Function 1 */
         if (ltv350qv_write_reg(lcd, LTV_PWRCTL1, LTV_VCOM_DISABLE))
@@ -153,7 +153,7 @@ err_settings:
 err_power2:
 err_power1:
         ltv350qv_write_reg(lcd, LTV_PWRCTL2, 0x0000);
-        msleep(1);
+        usleep_range(1000, 1100);
 err:
         ltv350qv_write_reg(lcd, LTV_PWRCTL1, LTV_VCOM_DISABLE);
         return -EIO;
@@ -175,7 +175,7 @@ static int ltv350qv_power_off(struct ltv350qv *lcd)
         ret |= ltv350qv_write_reg(lcd, LTV_PWRCTL2, 0x0000);
 
         /* Wait at least 1 ms */
-        msleep(1);
+        usleep_range(1000, 1100);
 
         /* Power down setting 2 */
         ret |= ltv350qv_write_reg(lcd, LTV_PWRCTL1, LTV_VCOM_DISABLE);
diff --git a/drivers/video/backlight/platform_lcd.c b/drivers/video/backlight/platform_lcd.c
index b6672340d6c7..ca4f5d70fe10 100644
--- a/drivers/video/backlight/platform_lcd.c
+++ b/drivers/video/backlight/platform_lcd.c
@@ -16,6 +16,7 @@
 #include <linux/fb.h>
 #include <linux/backlight.h>
 #include <linux/lcd.h>
+#include <linux/of.h>
 #include <linux/slab.h>
 
 #include <video/platform_lcd.h>
@@ -145,6 +146,14 @@ static SIMPLE_DEV_PM_OPS(platform_lcd_pm_ops, platform_lcd_suspend,
                         platform_lcd_resume);
 #endif
 
+#ifdef CONFIG_OF
+static const struct of_device_id platform_lcd_of_match[] = {
+        { .compatible = "platform-lcd" },
+        {},
+};
+MODULE_DEVICE_TABLE(of, platform_lcd_of_match);
+#endif
+
 static struct platform_driver platform_lcd_driver = {
         .driver         = {
                 .name   = "platform-lcd",
@@ -152,6 +161,7 @@ static struct platform_driver platform_lcd_driver = {
 #ifdef CONFIG_PM
                 .pm     = &platform_lcd_pm_ops,
 #endif
+                .of_match_table = of_match_ptr(platform_lcd_of_match),
         },
         .probe          = platform_lcd_probe,
         .remove         = __devexit_p(platform_lcd_remove),
diff --git a/drivers/video/backlight/progear_bl.c b/drivers/video/backlight/progear_bl.c
deleted file mode 100644
index 69b35f02929e..000000000000
--- a/drivers/video/backlight/progear_bl.c
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- *  Backlight Driver for Frontpath ProGear HX1050+
- *
- *  Copyright (c) 2006 Marcin Juszkiewicz
- *
- *  Based on Progear LCD driver by M Schacht
- *  <mschacht at alumni dot washington dot edu>
- *
- *  Based on Sharp's Corgi Backlight Driver
- *  Based on Backlight Driver for HP Jornada 680
- *
- *  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.
- *
- */
-
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/mutex.h>
-#include <linux/fb.h>
-#include <linux/backlight.h>
-#include <linux/pci.h>
-
-#define PMU_LPCR               0xB0
-#define SB_MPS1                0x61
-#define HW_LEVEL_MAX           0x77
-#define HW_LEVEL_MIN           0x4f
-
-static struct pci_dev *pmu_dev = NULL;
-static struct pci_dev *sb_dev = NULL;
-
-static int progearbl_set_intensity(struct backlight_device *bd)
-{
-        int intensity = bd->props.brightness;
-
-        if (bd->props.power != FB_BLANK_UNBLANK)
-                intensity = 0;
-        if (bd->props.fb_blank != FB_BLANK_UNBLANK)
-                intensity = 0;
-
-        pci_write_config_byte(pmu_dev, PMU_LPCR, intensity + HW_LEVEL_MIN);
-
-        return 0;
-}
-
-static int progearbl_get_intensity(struct backlight_device *bd)
-{
-        u8 intensity;
-        pci_read_config_byte(pmu_dev, PMU_LPCR, &intensity);
-
-        return intensity - HW_LEVEL_MIN;
-}
-
-static const struct backlight_ops progearbl_ops = {
-        .get_brightness = progearbl_get_intensity,
-        .update_status = progearbl_set_intensity,
-};
-
-static int progearbl_probe(struct platform_device *pdev)
-{
-        struct backlight_properties props;
-        u8 temp;
-        struct backlight_device *progear_backlight_device;
-        int ret;
-
-        pmu_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101, NULL);
-        if (!pmu_dev) {
-                pr_err("ALI M7101 PMU not found.\n");
-                return -ENODEV;
-        }
-
-        sb_dev = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
-        if (!sb_dev) {
-                pr_err("ALI 1533 SB not found.\n");
-                ret = -ENODEV;
-                goto put_pmu;
-        }
-
-        /*     Set SB_MPS1 to enable brightness control. */
-        pci_read_config_byte(sb_dev, SB_MPS1, &temp);
-        pci_write_config_byte(sb_dev, SB_MPS1, temp | 0x20);
-
-        memset(&props, 0, sizeof(struct backlight_properties));
-        props.type = BACKLIGHT_RAW;
-        props.max_brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
-        progear_backlight_device = backlight_device_register("progear-bl",
-                                                             &pdev->dev, NULL,
-                                                             &progearbl_ops,
-                                                             &props);
-        if (IS_ERR(progear_backlight_device)) {
-                ret = PTR_ERR(progear_backlight_device);
-                goto put_sb;
-        }
-
-        platform_set_drvdata(pdev, progear_backlight_device);
-
-        progear_backlight_device->props.power = FB_BLANK_UNBLANK;
-        progear_backlight_device->props.brightness = HW_LEVEL_MAX - HW_LEVEL_MIN;
-        progearbl_set_intensity(progear_backlight_device);
-
-        return 0;
-put_sb:
-        pci_dev_put(sb_dev);
-put_pmu:
-        pci_dev_put(pmu_dev);
-        return ret;
-}
-
-static int progearbl_remove(struct platform_device *pdev)
-{
-        struct backlight_device *bd = platform_get_drvdata(pdev);
-        backlight_device_unregister(bd);
-
-        return 0;
-}
-
-static struct platform_driver progearbl_driver = {
-        .probe = progearbl_probe,
-        .remove = progearbl_remove,
-        .driver = {
-                   .name = "progear-bl",
-                   },
-};
-
-static struct platform_device *progearbl_device;
-
-static int __init progearbl_init(void)
-{
-        int ret = platform_driver_register(&progearbl_driver);
-
-        if (ret)
-                return ret;
-        progearbl_device = platform_device_register_simple("progear-bl", -1,
-                                                                NULL, 0);
-        if (IS_ERR(progearbl_device)) {
-                platform_driver_unregister(&progearbl_driver);
-                return PTR_ERR(progearbl_device);
-        }
-
-        return 0;
-}
-
-static void __exit progearbl_exit(void)
-{
-        pci_dev_put(pmu_dev);
-        pci_dev_put(sb_dev);
-
-        platform_device_unregister(progearbl_device);
-        platform_driver_unregister(&progearbl_driver);
-}
-
-module_init(progearbl_init);
-module_exit(progearbl_exit);
-
-MODULE_AUTHOR("Marcin Juszkiewicz <linux@hrw.one.pl>");
-MODULE_DESCRIPTION("ProGear Backlight Driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/video/geode/gx1fb_core.c b/drivers/video/geode/gx1fb_core.c
index 5a5d0928df33..265c5ed59ade 100644
--- a/drivers/video/geode/gx1fb_core.c
+++ b/drivers/video/geode/gx1fb_core.c
@@ -29,7 +29,7 @@ static int  crt_option = 1;
 static char panel_option[32] = "";
 
 /* Modes relevant to the GX1 (taken from modedb.c) */
-static const struct fb_videomode __devinitdata gx1_modedb[] = {
+static const struct fb_videomode __devinitconst gx1_modedb[] = {
         /* 640x480-60 VESA */
         { NULL, 60, 640, 480, 39682,  48, 16, 33, 10, 96, 2,
           0, FB_VMODE_NONINTERLACED, FB_MODE_IS_VESA },
diff --git a/drivers/video/gxt4500.c b/drivers/video/gxt4500.c
index 0fad23f810a3..0e9afa41d163 100644
--- a/drivers/video/gxt4500.c
+++ b/drivers/video/gxt4500.c
@@ -156,7 +156,7 @@ struct gxt4500_par {
 static char *mode_option;
 
 /* default mode: 1280x1024 @ 60 Hz, 8 bpp */
-static const struct fb_videomode defaultmode __devinitdata = {
+static const struct fb_videomode defaultmode __devinitconst = {
         .refresh = 60,
         .xres = 1280,
         .yres = 1024,
@@ -581,7 +581,7 @@ static int gxt4500_blank(int blank, struct fb_info *info)
         return 0;
 }
 
-static const struct fb_fix_screeninfo gxt4500_fix __devinitdata = {
+static const struct fb_fix_screeninfo gxt4500_fix __devinitconst = {
         .id = "IBM GXT4500P",
         .type = FB_TYPE_PACKED_PIXELS,
         .visual = FB_VISUAL_PSEUDOCOLOR,
diff --git a/drivers/video/i810/i810_main.c b/drivers/video/i810/i810_main.c
index b83f36190cae..5c067816a81d 100644
--- a/drivers/video/i810/i810_main.c
+++ b/drivers/video/i810/i810_main.c
@@ -97,7 +97,7 @@ static int i810fb_blank      (int blank_mode, struct fb_info *info);
 static void i810fb_release_resource       (struct fb_info *info, struct i810fb_par *par);
 
 /* PCI */
-static const char *i810_pci_list[] __devinitdata = {
+static const char * const i810_pci_list[] __devinitconst = {
         "Intel(R) 810 Framebuffer Device"                                 ,
         "Intel(R) 810-DC100 Framebuffer Device"                           ,
         "Intel(R) 810E Framebuffer Device"                                ,
diff --git a/drivers/video/jz4740_fb.c b/drivers/video/jz4740_fb.c
index de366937c933..3c63fc24bb1f 100644
--- a/drivers/video/jz4740_fb.c
+++ b/drivers/video/jz4740_fb.c
@@ -136,7 +136,7 @@ struct jzfb {
         uint32_t pseudo_palette[16];
 };
 
-static const struct fb_fix_screeninfo jzfb_fix __devinitdata = {
+static const struct fb_fix_screeninfo jzfb_fix __devinitconst = {
         .id             = "JZ4740 FB",
         .type           = FB_TYPE_PACKED_PIXELS,
         .visual         = FB_VISUAL_TRUECOLOR,