Automatic merge with /usr/src/ntfs-2.6.git

author: Anton Altaparmakov <aia21@cantab.net> 2005-06-08 10:45:45 -0400
committer: Anton Altaparmakov <aia21@cantab.net> 2005-06-08 10:45:45 -0400
commit: 364f6c717deef4a3ac4982e670fa9846b43cd060 (patch)
tree: 47e3967d6e2220130f2c070e300c97709143b28f /drivers
parent: 4ff4258a3e558814a3d48c50a59cd22f56bbea2f (diff)
parent: 1d6757fbff5bc86e94e59ab0d7bdd7e71351d839 (diff)
64 files changed, 3594 insertions, 1360 deletions
diff --git a/drivers/atm/Makefile b/drivers/atm/Makefile
index d1dcd8eae3c9..5b77188527a9 100644
--- a/drivers/atm/Makefile
+++ b/drivers/atm/Makefile
@@ -39,7 +39,8 @@ ifeq ($(CONFIG_ATM_FORE200E_PCA),y)
  fore_200e-objs                += fore200e_pca_fw.o
  # guess the target endianess to choose the right PCA-200E firmware image
  ifeq ($(CONFIG_ATM_FORE200E_PCA_DEFAULT_FW),y)
-    CONFIG_ATM_FORE200E_PCA_FW = $(shell if test -n "`$(CC) -E -dM $(src)/../../include/asm/byteorder.h | grep ' __LITTLE_ENDIAN '`"; then echo $(obj)/pca200e.bin; else echo $(obj)/pca200e_ecd.bin2; fi)
+    byteorder.h                 := include$(if $(patsubst $(srctree),,$(objtree)),2)/asm/byteorder.h
+    CONFIG_ATM_FORE200E_PCA_FW  := $(obj)/pca200e$(if $(shell $(CC) -E -dM $(byteorder.h) | grep ' __LITTLE_ENDIAN '),.bin,_ecd.bin2)
  endif
 endif
diff --git a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c
index 9e65bfb85ba3..5f702199543a 100644
--- a/drivers/atm/fore200e.c
+++ b/drivers/atm/fore200e.c
@@ -383,8 +383,7 @@ fore200e_shutdown(struct fore200e* fore200e)
    switch(fore200e->state) {
    case FORE200E_STATE_COMPLETE:
-        if (fore200e->stats)
+        kfree(fore200e->stats);
-            kfree(fore200e->stats);
    case FORE200E_STATE_IRQ:
        free_irq(fore200e->irq, fore200e->atm_dev);
@@ -963,8 +962,7 @@ fore200e_tx_irq(struct fore200e* fore200e)
                entry, txq->tail, entry->vc_map, entry->skb);
        /* free copy of misaligned data */
-        if (entry->data)
+        kfree(entry->data);
-            kfree(entry->data);
        
        /* remove DMA mapping */
        fore200e->bus->dma_unmap(fore200e, entry->tpd->tsd[ 0 ].buffer, entry->tpd->tsd[ 0 ].length,
diff --git a/drivers/atm/he.c b/drivers/atm/he.c
index 3022c548a132..df2c83fd5496 100644
--- a/drivers/atm/he.c
+++ b/drivers/atm/he.c
@@ -412,8 +412,7 @@ he_init_one(struct pci_dev *pci_dev, const struct pci_device_id *pci_ent)
 init_one_failure:
        if (atm_dev)
                atm_dev_deregister(atm_dev);
-        if (he_dev)
+        kfree(he_dev);
-                kfree(he_dev);
        pci_disable_device(pci_dev);
        return err;
 }
@@ -2534,8 +2533,7 @@ he_open(struct atm_vcc *vcc)
 open_failed:
        if (err) {
-                if (he_vcc)
+                kfree(he_vcc);
-                        kfree(he_vcc);
                clear_bit(ATM_VF_ADDR, &vcc->flags);
        }
        else
diff --git a/drivers/atm/nicstar.c b/drivers/atm/nicstar.c
index 85bf5c8442b0..b2a7b754fd14 100644
--- a/drivers/atm/nicstar.c
+++ b/drivers/atm/nicstar.c
@@ -676,10 +676,10 @@ static int __devinit ns_init_card(int i, struct pci_dev *pcidev)
   PRINTK("nicstar%d: RSQ base at 0x%x.\n", i, (u32) card->rsq.base);
      
   /* Initialize SCQ0, the only VBR SCQ used */
-   card->scq1 = (scq_info *) NULL;
+   card->scq1 = NULL;
-   card->scq2 = (scq_info *) NULL;
+   card->scq2 = NULL;
   card->scq0 = get_scq(VBR_SCQSIZE, NS_VRSCD0);
-   if (card->scq0 == (scq_info *) NULL)
+   if (card->scq0 == NULL)
   {
      printk("nicstar%d: can't get SCQ0.\n", i);
      error = 12;
@@ -993,24 +993,24 @@ static scq_info *get_scq(int size, u32 scd)
   int i;
   if (size != VBR_SCQSIZE && size != CBR_SCQSIZE)
-      return (scq_info *) NULL;
+      return NULL;
   scq = (scq_info *) kmalloc(sizeof(scq_info), GFP_KERNEL);
-   if (scq == (scq_info *) NULL)
+   if (scq == NULL)
-      return (scq_info *) NULL;
+      return NULL;
   scq->org = kmalloc(2 * size, GFP_KERNEL);
   if (scq->org == NULL)
   {
      kfree(scq);
-      return (scq_info *) NULL;
+      return NULL;
   }
   scq->skb = (struct sk_buff **) kmalloc(sizeof(struct sk_buff *) *
                                          (size / NS_SCQE_SIZE), GFP_KERNEL);
-   if (scq->skb == (struct sk_buff **) NULL)
+   if (scq->skb == NULL)
   {
      kfree(scq->org);
      kfree(scq);
-      return (scq_info *) NULL;
+      return NULL;
   }
   scq->num_entries = size / NS_SCQE_SIZE;
   scq->base = (ns_scqe *) ALIGN_ADDRESS(scq->org, size);
@@ -1498,7 +1498,7 @@ static int ns_open(struct atm_vcc *vcc)
         vc->cbr_scd = NS_FRSCD + frscdi * NS_FRSCD_SIZE;
         scq = get_scq(CBR_SCQSIZE, vc->cbr_scd);
-         if (scq == (scq_info *) NULL)
+         if (scq == NULL)
         {
            PRINTK("nicstar%d: can't get fixed rate SCQ.\n", card->index);
            card->scd2vc[frscdi] = NULL;
diff --git a/drivers/atm/zatm.c b/drivers/atm/zatm.c
index 47a800519ad0..8d5e65cb9755 100644
--- a/drivers/atm/zatm.c
+++ b/drivers/atm/zatm.c
@@ -902,7 +902,7 @@ static void close_tx(struct atm_vcc *vcc)
                zatm_dev->tx_bw += vcc->qos.txtp.min_pcr;
                dealloc_shaper(vcc->dev,zatm_vcc->shaper);
        }
-        if (zatm_vcc->ring) kfree(zatm_vcc->ring);
+        kfree(zatm_vcc->ring);
 }
@@ -1339,12 +1339,9 @@ static int __init zatm_start(struct atm_dev *dev)
        return 0;
    out:
        for (i = 0; i < NR_MBX; i++)
-                if (zatm_dev->mbx_start[i] != 0)
+                kfree(zatm_dev->mbx_start[i]);
-                        kfree((void *) zatm_dev->mbx_start[i]);
+        kfree(zatm_dev->rx_map);
-        if (zatm_dev->rx_map != NULL)
+        kfree(zatm_dev->tx_map);
-                kfree(zatm_dev->rx_map);
-        if (zatm_dev->tx_map != NULL)
-                kfree(zatm_dev->tx_map);
        free_irq(zatm_dev->irq, dev);
        return error;
 }
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index ce42889f98fb..adc4dcc306f4 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -8,13 +8,12 @@
 * and is not licensed separately. See file COPYING for details.
 *
 * TODO (sorted by decreasing priority)
+ *  -- Kill first_open (Al Viro fixed the block layer now)
 *  -- Do resets with usb_device_reset (needs a thread context, use khubd)
 *  -- set readonly flag for CDs, set removable flag for CF readers
 *  -- do inquiry and verify we got a disk and not a tape (for LUN mismatch)
- *  -- support pphaneuf's SDDR-75 with two LUNs (also broken capacity...)
 *  -- special case some senses, e.g. 3a/0 -> no media present, reduce retries
 *  -- verify the 13 conditions and do bulk resets
- *  -- normal pool of commands instead of cmdv[]?
 *  -- kill last_pipe and simply do two-state clearing on both pipes
 *  -- verify protocol (bulk) from USB descriptors (maybe...)
 *  -- highmem and sg
@@ -49,7 +48,14 @@
 #define US_SC_SCSI      0x06            /* Transparent */
 /*
+ * This many LUNs per USB device.
+ * Every one of them takes a host, see UB_MAX_HOSTS.
 */
+#define UB_MAX_LUNS   4
+/*
+ */
 #define UB_MINORS_PER_MAJOR     8
 #define UB_MAX_CDB_SIZE      16         /* Corresponds to Bulk */
@@ -65,7 +71,7 @@ struct bulk_cb_wrap {
        u32     Tag;                    /* unique per command id */
        __le32  DataTransferLength;     /* size of data */
        u8      Flags;                  /* direction in bit 0 */
-        u8      Lun;                    /* LUN normally 0 */
+        u8      Lun;                    /* LUN */
        u8      Length;                 /* of of the CDB */
        u8      CDB[UB_MAX_CDB_SIZE];   /* max command */
 };
@@ -168,6 +174,7 @@ struct ub_scsi_cmd {
        unsigned int len;               /* Requested length */
        // struct scatterlist sgv[UB_MAX_REQ_SG];
+        struct ub_lun *lun;
        void (*done)(struct ub_dev *, struct ub_scsi_cmd *);
        void *back;
 };
@@ -252,25 +259,47 @@ struct ub_scsi_cmd_queue {
 };
 /*
- * The UB device instance.
+ * The block device instance (one per LUN).
+ */
+struct ub_lun {
+        struct ub_dev *udev;
+        struct list_head link;
+        struct gendisk *disk;
+        int id;                         /* Host index */
+        int num;                        /* LUN number */
+        char name[16];
+        int changed;                    /* Media was changed */
+        int removable;
+        int readonly;
+        int first_open;                 /* Kludge. See ub_bd_open. */
+        /* Use Ingo's mempool if or when we have more than one command. */
+        /*
+         * Currently we never need more than one command for the whole device.
+         * However, giving every LUN a command is a cheap and automatic way
+         * to enforce fairness between them.
+         */
+        int cmda[1];
+        struct ub_scsi_cmd cmdv[1];
+        struct ub_capacity capacity; 
+};
+/*
+ * The USB device instance.
 */
 struct ub_dev {
        spinlock_t lock;
-        int id;                         /* Number among ub's */
        atomic_t poison;                /* The USB device is disconnected */
        int openc;                      /* protected by ub_lock! */
                                        /* kref is too implicit for our taste */
        unsigned int tagcnt;
-        int changed;                    /* Media was changed */
+        char name[12];
-        int removable;
-        int readonly;
-        int first_open;                 /* Kludge. See ub_bd_open. */
-        char name[8];
        struct usb_device *dev;
        struct usb_interface *intf;
-        struct ub_capacity capacity; 
+        struct list_head luns;
-        struct gendisk *disk;
        unsigned int send_bulk_pipe;    /* cached pipe values */
        unsigned int recv_bulk_pipe;
@@ -279,10 +308,6 @@ struct ub_dev {
        struct tasklet_struct tasklet;
-        /* XXX Use Ingo's mempool (once we have more than one) */
-        int cmda[1];
-        struct ub_scsi_cmd cmdv[1];
        struct ub_scsi_cmd_queue cmd_queue;
        struct ub_scsi_cmd top_rqs_cmd; /* REQUEST SENSE */
        unsigned char top_sense[UB_SENSE_SIZE];
@@ -301,9 +326,9 @@ struct ub_dev {
 /*
 */
 static void ub_cleanup(struct ub_dev *sc);
-static int ub_bd_rq_fn_1(struct ub_dev *sc, struct request *rq);
+static int ub_bd_rq_fn_1(struct ub_lun *lun, struct request *rq);
-static int ub_cmd_build_block(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
+static int ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
-    struct request *rq);
+    struct ub_scsi_cmd *cmd, struct request *rq);
 static int ub_cmd_build_packet(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
    struct request *rq);
 static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
@@ -320,8 +345,10 @@ static void ub_state_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
 static int ub_submit_clear_stall(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
    int stalled_pipe);
 static void ub_top_sense_done(struct ub_dev *sc, struct ub_scsi_cmd *scmd);
-static int ub_sync_tur(struct ub_dev *sc);
+static int ub_sync_tur(struct ub_dev *sc, struct ub_lun *lun);
-static int ub_sync_read_cap(struct ub_dev *sc, struct ub_capacity *ret);
+static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun,
+    struct ub_capacity *ret);
+static int ub_probe_lun(struct ub_dev *sc, int lnum);
 /*
 */
@@ -342,6 +369,7 @@ MODULE_DEVICE_TABLE(usb, ub_usb_ids);
 */
 #define UB_MAX_HOSTS  26
 static char ub_hostv[UB_MAX_HOSTS];
 static DEFINE_SPINLOCK(ub_lock);        /* Locks globals and ->openc */
 /*
@@ -406,6 +434,8 @@ static ssize_t ub_diag_show(struct device *dev, char *page)
 {
        struct usb_interface *intf;
        struct ub_dev *sc;
+        struct list_head *p;
+        struct ub_lun *lun;
        int cnt;
        unsigned long flags;
        int nc, nh;
@@ -421,9 +451,15 @@ static ssize_t ub_diag_show(struct device *dev, char *page)
        spin_lock_irqsave(&sc->lock, flags);
        cnt += sprintf(page + cnt,
-            "qlen %d qmax %d changed %d removable %d readonly %d\n",
+            "qlen %d qmax %d\n",
-            sc->cmd_queue.qlen, sc->cmd_queue.qmax,
+            sc->cmd_queue.qlen, sc->cmd_queue.qmax);
-            sc->changed, sc->removable, sc->readonly);
+        list_for_each (p, &sc->luns) {
+                lun = list_entry(p, struct ub_lun, link);
+                cnt += sprintf(page + cnt,
+                    "lun %u changed %d removable %d readonly %d\n",
+                    lun->num, lun->changed, lun->removable, lun->readonly);
+        }
        if ((nc = sc->tr.cur + 1) == SCMD_TRACE_SZ) nc = 0;
        for (j = 0; j < SCMD_TRACE_SZ; j++) {
@@ -523,53 +559,63 @@ static void ub_put(struct ub_dev *sc)
 */
 static void ub_cleanup(struct ub_dev *sc)
 {
+        struct list_head *p;
+        struct ub_lun *lun;
        request_queue_t *q;
-        /* I don't think queue can be NULL. But... Stolen from sx8.c */
+        while (!list_empty(&sc->luns)) {
-        if ((q = sc->disk->queue) != NULL)
+                p = sc->luns.next;
-                blk_cleanup_queue(q);
+                lun = list_entry(p, struct ub_lun, link);
+                list_del(p);
-        /*
+                /* I don't think queue can be NULL. But... Stolen from sx8.c */
-         * If we zero disk->private_data BEFORE put_disk, we have to check
+                if ((q = lun->disk->queue) != NULL)
-         * for NULL all over the place in open, release, check_media and
+                        blk_cleanup_queue(q);
-         * revalidate, because the block level semaphore is well inside the
+                /*
-         * put_disk. But we cannot zero after the call, because *disk is gone.
+                 * If we zero disk->private_data BEFORE put_disk, we have
-         * The sd.c is blatantly racy in this area.
+                 * to check for NULL all over the place in open, release,
-         */
+                 * check_media and revalidate, because the block level
-        /* disk->private_data = NULL; */
+                 * semaphore is well inside the put_disk.
-        put_disk(sc->disk);
+                 * But we cannot zero after the call, because *disk is gone.
-        sc->disk = NULL;
+                 * The sd.c is blatantly racy in this area.
+                 */
+                /* disk->private_data = NULL; */
+                put_disk(lun->disk);
+                lun->disk = NULL;
+                ub_id_put(lun->id);
+                kfree(lun);
+        }
-        ub_id_put(sc->id);
        kfree(sc);
 }
 /*
 * The "command allocator".
 */
-static struct ub_scsi_cmd *ub_get_cmd(struct ub_dev *sc)
+static struct ub_scsi_cmd *ub_get_cmd(struct ub_lun *lun)
 {
        struct ub_scsi_cmd *ret;
-        if (sc->cmda[0])
+        if (lun->cmda[0])
                return NULL;
-        ret = &sc->cmdv[0];
+        ret = &lun->cmdv[0];
-        sc->cmda[0] = 1;
+        lun->cmda[0] = 1;
        return ret;
 }
-static void ub_put_cmd(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
+static void ub_put_cmd(struct ub_lun *lun, struct ub_scsi_cmd *cmd)
 {
-        if (cmd != &sc->cmdv[0]) {
+        if (cmd != &lun->cmdv[0]) {
                printk(KERN_WARNING "%s: releasing a foreign cmd %p\n",
-                    sc->name, cmd);
+                    lun->name, cmd);
                return;
        }
-        if (!sc->cmda[0]) {
+        if (!lun->cmda[0]) {
-                printk(KERN_WARNING "%s: releasing a free cmd\n", sc->name);
+                printk(KERN_WARNING "%s: releasing a free cmd\n", lun->name);
                return;
        }
-        sc->cmda[0] = 0;
+        lun->cmda[0] = 0;
 }
 /*
@@ -630,29 +676,30 @@ static struct ub_scsi_cmd *ub_cmdq_pop(struct ub_dev *sc)
 static void ub_bd_rq_fn(request_queue_t *q)
 {
-        struct ub_dev *sc = q->queuedata;
+        struct ub_lun *lun = q->queuedata;
        struct request *rq;
        while ((rq = elv_next_request(q)) != NULL) {
-                if (ub_bd_rq_fn_1(sc, rq) != 0) {
+                if (ub_bd_rq_fn_1(lun, rq) != 0) {
                        blk_stop_queue(q);
                        break;
                }
        }
 }
-static int ub_bd_rq_fn_1(struct ub_dev *sc, struct request *rq)
+static int ub_bd_rq_fn_1(struct ub_lun *lun, struct request *rq)
 {
+        struct ub_dev *sc = lun->udev;
        struct ub_scsi_cmd *cmd;
        int rc;
-        if (atomic_read(&sc->poison) || sc->changed) {
+        if (atomic_read(&sc->poison) || lun->changed) {
                blkdev_dequeue_request(rq);
                ub_end_rq(rq, 0);
                return 0;
        }
-        if ((cmd = ub_get_cmd(sc)) == NULL)
+        if ((cmd = ub_get_cmd(lun)) == NULL)
                return -1;
        memset(cmd, 0, sizeof(struct ub_scsi_cmd));
@@ -661,32 +708,30 @@ static int ub_bd_rq_fn_1(struct ub_dev *sc, struct request *rq)
        if (blk_pc_request(rq)) {
                rc = ub_cmd_build_packet(sc, cmd, rq);
        } else {
-                rc = ub_cmd_build_block(sc, cmd, rq);
+                rc = ub_cmd_build_block(sc, lun, cmd, rq);
        }
        if (rc != 0) {
-                ub_put_cmd(sc, cmd);
+                ub_put_cmd(lun, cmd);
                ub_end_rq(rq, 0);
-                blk_start_queue(sc->disk->queue);
                return 0;
        }
        cmd->state = UB_CMDST_INIT;
+        cmd->lun = lun;
        cmd->done = ub_rw_cmd_done;
        cmd->back = rq;
        cmd->tag = sc->tagcnt++;
        if ((rc = ub_submit_scsi(sc, cmd)) != 0) {
-                ub_put_cmd(sc, cmd);
+                ub_put_cmd(lun, cmd);
                ub_end_rq(rq, 0);
-                blk_start_queue(sc->disk->queue);
                return 0;
        }
        return 0;
 }
-static int ub_cmd_build_block(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
+static int ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
-    struct request *rq)
+    struct ub_scsi_cmd *cmd, struct request *rq)
 {
        int ub_dir;
 #if 0 /* We use rq->buffer for now */
@@ -707,7 +752,7 @@ static int ub_cmd_build_block(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
        sg = &cmd->sgv[0];
        n_elem = blk_rq_map_sg(q, rq, sg);
        if (n_elem <= 0) {
-                ub_put_cmd(sc, cmd);
+                ub_put_cmd(lun, cmd);
                ub_end_rq(rq, 0);
                blk_start_queue(q);
                return 0;               /* request with no s/g entries? */
@@ -716,7 +761,7 @@ static int ub_cmd_build_block(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
        if (n_elem != 1) {              /* Paranoia */
                printk(KERN_WARNING "%s: request with %d segments\n",
                    sc->name, n_elem);
-                ub_put_cmd(sc, cmd);
+                ub_put_cmd(lun, cmd);
                ub_end_rq(rq, 0);
                blk_start_queue(q);
                return 0;
@@ -748,8 +793,8 @@ static int ub_cmd_build_block(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
         * The call to blk_queue_hardsect_size() guarantees that request
         * is aligned, but it is given in terms of 512 byte units, always.
         */
-        block = rq->sector >> sc->capacity.bshift;
+        block = rq->sector >> lun->capacity.bshift;
-        nblks = rq->nr_sectors >> sc->capacity.bshift;
+        nblks = rq->nr_sectors >> lun->capacity.bshift;
        cmd->cdb[0] = (ub_dir == UB_DIR_READ)? READ_10: WRITE_10;
        /* 10-byte uses 4 bytes of LBA: 2147483648KB, 2097152MB, 2048GB */
@@ -803,7 +848,8 @@ static int ub_cmd_build_packet(struct ub_dev *sc, struct ub_scsi_cmd *cmd,
 static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
 {
        struct request *rq = cmd->back;
-        struct gendisk *disk = sc->disk;
+        struct ub_lun *lun = cmd->lun;
+        struct gendisk *disk = lun->disk;
        request_queue_t *q = disk->queue;
        int uptodate;
@@ -818,7 +864,7 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
        else
                uptodate = 0;
-        ub_put_cmd(sc, cmd);
+        ub_put_cmd(lun, cmd);
        ub_end_rq(rq, uptodate);
        blk_start_queue(q);
 }
@@ -887,7 +933,7 @@ static int ub_scsi_cmd_start(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
        bcb->Tag = cmd->tag;            /* Endianness is not important */
        bcb->DataTransferLength = cpu_to_le32(cmd->len);
        bcb->Flags = (cmd->dir == UB_DIR_READ) ? 0x80 : 0;
-        bcb->Lun = 0;                   /* No multi-LUN yet */
+        bcb->Lun = (cmd->lun != NULL) ? cmd->lun->num : 0;
        bcb->Length = cmd->cdb_len;
        /* copy the command payload */
@@ -1002,9 +1048,8 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
                         * The control pipe clears itself - nothing to do.
                         * XXX Might try to reset the device here and retry.
                         */
-                        printk(KERN_NOTICE "%s: "
+                        printk(KERN_NOTICE "%s: stall on control pipe\n",
-                            "stall on control pipe for device %u\n",
+                            sc->name);
-                            sc->name, sc->dev->devnum);
                        goto Bad_End;
                }
@@ -1025,9 +1070,8 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
                         * The control pipe clears itself - nothing to do.
                         * XXX Might try to reset the device here and retry.
                         */
-                        printk(KERN_NOTICE "%s: "
+                        printk(KERN_NOTICE "%s: stall on control pipe\n",
-                            "stall on control pipe for device %u\n",
+                            sc->name);
-                            sc->name, sc->dev->devnum);
                        goto Bad_End;
                }
@@ -1046,9 +1090,8 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
                        rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe);
                        if (rc != 0) {
                                printk(KERN_NOTICE "%s: "
-                                    "unable to submit clear for device %u"
+                                    "unable to submit clear (%d)\n",
-                                    " (code %d)\n",
+                                    sc->name, rc);
-                                    sc->name, sc->dev->devnum, rc);
                                /*
                                 * This is typically ENOMEM or some other such shit.
                                 * Retrying is pointless. Just do Bad End on it...
@@ -1107,9 +1150,8 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
                        rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe);
                        if (rc != 0) {
                                printk(KERN_NOTICE "%s: "
-                                    "unable to submit clear for device %u"
+                                    "unable to submit clear (%d)\n",
-                                    " (code %d)\n",
+                                    sc->name, rc);
-                                    sc->name, sc->dev->devnum, rc);
                                /*
                                 * This is typically ENOMEM or some other such shit.
                                 * Retrying is pointless. Just do Bad End on it...
@@ -1140,9 +1182,8 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
                        rc = ub_submit_clear_stall(sc, cmd, sc->last_pipe);
                        if (rc != 0) {
                                printk(KERN_NOTICE "%s: "
-                                    "unable to submit clear for device %u"
+                                    "unable to submit clear (%d)\n",
-                                    " (code %d)\n",
+                                    sc->name, rc);
-                                    sc->name, sc->dev->devnum, rc);
                                /*
                                 * This is typically ENOMEM or some other such shit.
                                 * Retrying is pointless. Just do Bad End on it...
@@ -1164,9 +1205,8 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
                         * encounter such a thing, try to read the CSW again.
                         */
                        if (++cmd->stat_count >= 4) {
-                                printk(KERN_NOTICE "%s: "
+                                printk(KERN_NOTICE "%s: unable to get CSW\n",
-                                    "unable to get CSW on device %u\n",
+                                    sc->name);
-                                    sc->name, sc->dev->devnum);
                                goto Bad_End;
                        }
                        __ub_state_stat(sc, cmd);
@@ -1207,10 +1247,8 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
                         */
                        if (++cmd->stat_count >= 4) {
                                printk(KERN_NOTICE "%s: "
-                                    "tag mismatch orig 0x%x reply 0x%x "
+                                    "tag mismatch orig 0x%x reply 0x%x\n",
-                                    "on device %u\n",
+                                    sc->name, cmd->tag, bcs->Tag);
-                                    sc->name, cmd->tag, bcs->Tag,
-                                    sc->dev->devnum);
                                goto Bad_End;
                        }
                        __ub_state_stat(sc, cmd);
@@ -1244,8 +1282,8 @@ static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
        } else {
                printk(KERN_WARNING "%s: "
-                    "wrong command state %d on device %u\n",
+                    "wrong command state %d\n",
-                    sc->name, cmd->state, sc->dev->devnum);
+                    sc->name, cmd->state);
                goto Bad_End;
        }
        return;
@@ -1288,7 +1326,6 @@ static void __ub_state_stat(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
        if ((rc = usb_submit_urb(&sc->work_urb, GFP_ATOMIC)) != 0) {
                /* XXX Clear stalls */
-                printk("%s: CSW #%d submit failed (%d)\n", sc->name, cmd->tag, rc); /* P3 */
                ub_complete(&sc->work_done);
                ub_state_done(sc, cmd, rc);
                return;
@@ -1333,6 +1370,7 @@ static void ub_state_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
        scmd->state = UB_CMDST_INIT;
        scmd->data = sc->top_sense;
        scmd->len = UB_SENSE_SIZE;
+        scmd->lun = cmd->lun;
        scmd->done = ub_top_sense_done;
        scmd->back = cmd;
@@ -1411,14 +1449,14 @@ static void ub_top_sense_done(struct ub_dev *sc, struct ub_scsi_cmd *scmd)
        }
        if (cmd != scmd->back) {
                printk(KERN_WARNING "%s: "
-                    "sense done for wrong command 0x%x on device %u\n",
+                    "sense done for wrong command 0x%x\n",
-                    sc->name, cmd->tag, sc->dev->devnum);
+                    sc->name, cmd->tag);
                return;
        }
        if (cmd->state != UB_CMDST_SENSE) {
                printk(KERN_WARNING "%s: "
-                    "sense done with bad cmd state %d on device %u\n",
+                    "sense done with bad cmd state %d\n",
-                    sc->name, cmd->state, sc->dev->devnum);
+                    sc->name, cmd->state);
                return;
        }
@@ -1429,68 +1467,32 @@ static void ub_top_sense_done(struct ub_dev *sc, struct ub_scsi_cmd *scmd)
        ub_scsi_urb_compl(sc, cmd);
 }
-#if 0
-/* Determine what the maximum LUN supported is */
-int usb_stor_Bulk_max_lun(struct us_data *us)
-{
-        int result;
-        /* issue the command */
-        result = usb_stor_control_msg(us, us->recv_ctrl_pipe,
-                                 US_BULK_GET_MAX_LUN, 
-                                 USB_DIR_IN | USB_TYPE_CLASS | 
-                                 USB_RECIP_INTERFACE,
-                                 0, us->ifnum, us->iobuf, 1, HZ);
-        /* 
-         * Some devices (i.e. Iomega Zip100) need this -- apparently
-         * the bulk pipes get STALLed when the GetMaxLUN request is
-         * processed.   This is, in theory, harmless to all other devices
-         * (regardless of if they stall or not).
-         */
-        if (result < 0) {
-                usb_stor_clear_halt(us, us->recv_bulk_pipe);
-                usb_stor_clear_halt(us, us->send_bulk_pipe);
-        }
-        US_DEBUGP("GetMaxLUN command result is %d, data is %d\n", 
-                  result, us->iobuf[0]);
-        /* if we have a successful request, return the result */
-        if (result == 1)
-                return us->iobuf[0];
-        /* return the default -- no LUNs */
-        return 0;
-}
-#endif
 /*
 * This is called from a process context.
 */
-static void ub_revalidate(struct ub_dev *sc)
+static void ub_revalidate(struct ub_dev *sc, struct ub_lun *lun)
 {
-        sc->readonly = 0;       /* XXX Query this from the device */
+        lun->readonly = 0;      /* XXX Query this from the device */
-        sc->capacity.nsec = 0;
+        lun->capacity.nsec = 0;
-        sc->capacity.bsize = 512;
+        lun->capacity.bsize = 512;
-        sc->capacity.bshift = 0;
+        lun->capacity.bshift = 0;
-        if (ub_sync_tur(sc) != 0)
+        if (ub_sync_tur(sc, lun) != 0)
                return;                 /* Not ready */
-        sc->changed = 0;
+        lun->changed = 0;
-        if (ub_sync_read_cap(sc, &sc->capacity) != 0) {
+        if (ub_sync_read_cap(sc, lun, &lun->capacity) != 0) {
                /*
                 * The retry here means something is wrong, either with the
                 * device, with the transport, or with our code.
                 * We keep this because sd.c has retries for capacity.
                 */
-                if (ub_sync_read_cap(sc, &sc->capacity) != 0) {
+                if (ub_sync_read_cap(sc, lun, &lun->capacity) != 0) {
-                        sc->capacity.nsec = 0;
+                        lun->capacity.nsec = 0;
-                        sc->capacity.bsize = 512;
+                        lun->capacity.bsize = 512;
-                        sc->capacity.bshift = 0;
+                        lun->capacity.bshift = 0;
                }
        }
 }
@@ -1503,12 +1505,15 @@ static void ub_revalidate(struct ub_dev *sc)
 static int ub_bd_open(struct inode *inode, struct file *filp)
 {
        struct gendisk *disk = inode->i_bdev->bd_disk;
+        struct ub_lun *lun;
        struct ub_dev *sc;
        unsigned long flags;
        int rc;
-        if ((sc = disk->private_data) == NULL)
+        if ((lun = disk->private_data) == NULL)
                return -ENXIO;
+        sc = lun->udev;
        spin_lock_irqsave(&ub_lock, flags);
        if (atomic_read(&sc->poison)) {
                spin_unlock_irqrestore(&ub_lock, flags);
@@ -1529,15 +1534,15 @@ static int ub_bd_open(struct inode *inode, struct file *filp)
         * The bottom line is, Al Viro says that we should not allow
         * bdev->bd_invalidated to be set when doing add_disk no matter what.
         */
-        if (sc->first_open) {
+        if (lun->first_open) {
-                if (sc->changed) {
+                lun->first_open = 0;
-                        sc->first_open = 0;
+                if (lun->changed) {
                        rc = -ENOMEDIUM;
                        goto err_open;
                }
        }
-        if (sc->removable || sc->readonly)
+        if (lun->removable || lun->readonly)
                check_disk_change(inode->i_bdev);
        /*
@@ -1545,12 +1550,12 @@ static int ub_bd_open(struct inode *inode, struct file *filp)
         * under some pretty murky conditions (a failure of READ CAPACITY).
         * We may need it one day.
         */
-        if (sc->removable && sc->changed && !(filp->f_flags & O_NDELAY)) {
+        if (lun->removable && lun->changed && !(filp->f_flags & O_NDELAY)) {
                rc = -ENOMEDIUM;
                goto err_open;
        }
-        if (sc->readonly && (filp->f_mode & FMODE_WRITE)) {
+        if (lun->readonly && (filp->f_mode & FMODE_WRITE)) {
                rc = -EROFS;
                goto err_open;
        }
@@ -1567,7 +1572,8 @@ err_open:
 static int ub_bd_release(struct inode *inode, struct file *filp)
 {
        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ub_dev *sc = disk->private_data;
+        struct ub_lun *lun = disk->private_data;
+        struct ub_dev *sc = lun->udev;
        ub_put(sc);
        return 0;
@@ -1597,20 +1603,14 @@ static int ub_bd_ioctl(struct inode *inode, struct file *filp,
 */
 static int ub_bd_revalidate(struct gendisk *disk)
 {
-        struct ub_dev *sc = disk->private_data;
+        struct ub_lun *lun = disk->private_data;
-        ub_revalidate(sc);
+        ub_revalidate(lun->udev, lun);
-        /* This is pretty much a long term P3 */
-        if (!atomic_read(&sc->poison)) {                /* Cover sc->dev */
-                printk(KERN_INFO "%s: device %u capacity nsec %ld bsize %u\n",
-                    sc->name, sc->dev->devnum,
-                    sc->capacity.nsec, sc->capacity.bsize);
-        }
        /* XXX Support sector size switching like in sr.c */
-        blk_queue_hardsect_size(disk->queue, sc->capacity.bsize);
+        blk_queue_hardsect_size(disk->queue, lun->capacity.bsize);
-        set_capacity(disk, sc->capacity.nsec);
+        set_capacity(disk, lun->capacity.nsec);
-        // set_disk_ro(sdkp->disk, sc->readonly);
+        // set_disk_ro(sdkp->disk, lun->readonly);
        return 0;
 }
@@ -1626,9 +1626,9 @@ static int ub_bd_revalidate(struct gendisk *disk)
 */
 static int ub_bd_media_changed(struct gendisk *disk)
 {
-        struct ub_dev *sc = disk->private_data;
+        struct ub_lun *lun = disk->private_data;
-        if (!sc->removable)
+        if (!lun->removable)
                return 0;
        /*
@@ -1640,12 +1640,12 @@ static int ub_bd_media_changed(struct gendisk *disk)
         * will fail, then block layer discards the data. Since we never
         * spin drives up, such devices simply cannot be used with ub anyway.
         */
-        if (ub_sync_tur(sc) != 0) {
+        if (ub_sync_tur(lun->udev, lun) != 0) {
-                sc->changed = 1;
+                lun->changed = 1;
                return 1;
        }
-        return sc->changed;
+        return lun->changed;
 }
 static struct block_device_operations ub_bd_fops = {
@@ -1669,7 +1669,7 @@ static void ub_probe_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
 /*
 * Test if the device has a check condition on it, synchronously.
 */
-static int ub_sync_tur(struct ub_dev *sc)
+static int ub_sync_tur(struct ub_dev *sc, struct ub_lun *lun)
 {
        struct ub_scsi_cmd *cmd;
        enum { ALLOC_SIZE = sizeof(struct ub_scsi_cmd) };
@@ -1688,6 +1688,7 @@ static int ub_sync_tur(struct ub_dev *sc)
        cmd->cdb_len = 6;
        cmd->dir = UB_DIR_NONE;
        cmd->state = UB_CMDST_INIT;
+        cmd->lun = lun;                 /* This may be NULL, but that's ok */
        cmd->done = ub_probe_done;
        cmd->back = &compl;
@@ -1718,7 +1719,8 @@ err_alloc:
 /*
 * Read the SCSI capacity synchronously (for probing).
 */
-static int ub_sync_read_cap(struct ub_dev *sc, struct ub_capacity *ret)
+static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun,
+    struct ub_capacity *ret)
 {
        struct ub_scsi_cmd *cmd;
        char *p;
@@ -1743,6 +1745,7 @@ static int ub_sync_read_cap(struct ub_dev *sc, struct ub_capacity *ret)
        cmd->state = UB_CMDST_INIT;
        cmd->data = p;
        cmd->len = 8;
+        cmd->lun = lun;
        cmd->done = ub_probe_done;
        cmd->back = &compl;
@@ -1812,6 +1815,90 @@ static void ub_probe_timeout(unsigned long arg)
 }
 /*
+ * Get number of LUNs by the way of Bulk GetMaxLUN command.
+ */
+static int ub_sync_getmaxlun(struct ub_dev *sc)
+{
+        int ifnum = sc->intf->cur_altsetting->desc.bInterfaceNumber;
+        unsigned char *p;
+        enum { ALLOC_SIZE = 1 };
+        struct usb_ctrlrequest *cr;
+        struct completion compl;
+        struct timer_list timer;
+        int nluns;
+        int rc;
+        init_completion(&compl);
+        rc = -ENOMEM;
+        if ((p = kmalloc(ALLOC_SIZE, GFP_KERNEL)) == NULL)
+                goto err_alloc;
+        *p = 55;
+        cr = &sc->work_cr;
+        cr->bRequestType = USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
+        cr->bRequest = US_BULK_GET_MAX_LUN;
+        cr->wValue = cpu_to_le16(0);
+        cr->wIndex = cpu_to_le16(ifnum);
+        cr->wLength = cpu_to_le16(1);
+        usb_fill_control_urb(&sc->work_urb, sc->dev, sc->recv_ctrl_pipe,
+            (unsigned char*) cr, p, 1, ub_probe_urb_complete, &compl);
+        sc->work_urb.transfer_flags = 0;
+        sc->work_urb.actual_length = 0;
+        sc->work_urb.error_count = 0;
+        sc->work_urb.status = 0;
+        if ((rc = usb_submit_urb(&sc->work_urb, GFP_KERNEL)) != 0) {
+                if (rc == -EPIPE) {
+                        printk("%s: Stall at GetMaxLUN, using 1 LUN\n",
+                             sc->name); /* P3 */
+                } else {
+                        printk(KERN_WARNING
+                             "%s: Unable to submit GetMaxLUN (%d)\n",
+                             sc->name, rc);
+                }
+                goto err_submit;
+        }
+        init_timer(&timer);
+        timer.function = ub_probe_timeout;
+        timer.data = (unsigned long) &compl;
+        timer.expires = jiffies + UB_CTRL_TIMEOUT;
+        add_timer(&timer);
+        wait_for_completion(&compl);
+        del_timer_sync(&timer);
+        usb_kill_urb(&sc->work_urb);
+        if (sc->work_urb.actual_length != 1) {
+                printk("%s: GetMaxLUN returned %d bytes\n", sc->name,
+                    sc->work_urb.actual_length); /* P3 */
+                nluns = 0;
+        } else {
+                if ((nluns = *p) == 55) {
+                        nluns = 0;
+                } else {
+                        /* GetMaxLUN returns the maximum LUN number */
+                        nluns += 1;
+                        if (nluns > UB_MAX_LUNS)
+                                nluns = UB_MAX_LUNS;
+                }
+                printk("%s: GetMaxLUN returned %d, using %d LUNs\n", sc->name,
+                    *p, nluns); /* P3 */
+        }
+        kfree(p);
+        return nluns;
+err_submit:
+        kfree(p);
+err_alloc:
+        return rc;
+}
+/*
 * Clear initial stalls.
 */
 static int ub_probe_clear_stall(struct ub_dev *sc, int stalled_pipe)
@@ -1897,8 +1984,8 @@ static int ub_get_pipes(struct ub_dev *sc, struct usb_device *dev,
        }
        if (ep_in == NULL || ep_out == NULL) {
-                printk(KERN_NOTICE "%s: device %u failed endpoint check\n",
+                printk(KERN_NOTICE "%s: failed endpoint check\n",
-                    sc->name, sc->dev->devnum);
+                    sc->name);
                return -EIO;
        }
@@ -1921,8 +2008,7 @@ static int ub_probe(struct usb_interface *intf,
    const struct usb_device_id *dev_id)
 {
        struct ub_dev *sc;
-        request_queue_t *q;
+        int nluns;
-        struct gendisk *disk;
        int rc;
        int i;
@@ -1931,6 +2017,7 @@ static int ub_probe(struct usb_interface *intf,
                goto err_core;
        memset(sc, 0, sizeof(struct ub_dev));
        spin_lock_init(&sc->lock);
+        INIT_LIST_HEAD(&sc->luns);
        usb_init_urb(&sc->work_urb);
        tasklet_init(&sc->tasklet, ub_scsi_action, (unsigned long)sc);
        atomic_set(&sc->poison, 0);
@@ -1942,19 +2029,16 @@ static int ub_probe(struct usb_interface *intf,
        ub_init_completion(&sc->work_done);
        sc->work_done.done = 1;         /* A little yuk, but oh well... */
-        rc = -ENOSR;
-        if ((sc->id = ub_id_get()) == -1)
-                goto err_id;
-        snprintf(sc->name, 8, DRV_NAME "%c", sc->id + 'a');
        sc->dev = interface_to_usbdev(intf);
        sc->intf = intf;
        // sc->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
        usb_set_intfdata(intf, sc);
        usb_get_dev(sc->dev);
        // usb_get_intf(sc->intf);      /* Do we need this? */
+        snprintf(sc->name, 12, DRV_NAME "(%d.%d)",
+            sc->dev->bus->busnum, sc->dev->devnum);
        /* XXX Verify that we can handle the device (from descriptors) */
        ub_get_pipes(sc, sc->dev, intf);
@@ -1992,35 +2076,88 @@ static int ub_probe(struct usb_interface *intf,
         * In any case it's not our business how revaliadation is implemented.
         */
        for (i = 0; i < 3; i++) {       /* Retries for benh's key */
-                if ((rc = ub_sync_tur(sc)) <= 0) break;
+                if ((rc = ub_sync_tur(sc, NULL)) <= 0) break;
                if (rc != 0x6) break;
                msleep(10);
        }
-        sc->removable = 1;              /* XXX Query this from the device */
+        nluns = 1;
-        sc->changed = 1;                /* ub_revalidate clears only */
+        for (i = 0; i < 3; i++) {
-        sc->first_open = 1;
+                if ((rc = ub_sync_getmaxlun(sc)) < 0) {
+                        /* 
+                         * Some devices (i.e. Iomega Zip100) need this --
+                         * apparently the bulk pipes get STALLed when the
+                         * GetMaxLUN request is processed.
+                         * XXX I have a ZIP-100, verify it does this.
+                         */
+                        if (rc == -EPIPE) {
+                                ub_probe_clear_stall(sc, sc->recv_bulk_pipe);
+                                ub_probe_clear_stall(sc, sc->send_bulk_pipe);
+                        }
+                        break;
+                }
+                if (rc != 0) {
+                        nluns = rc;
+                        break;
+                }
+                mdelay(100);
+        }
-        ub_revalidate(sc);
+        for (i = 0; i < nluns; i++) {
-        /* This is pretty much a long term P3 */
+                ub_probe_lun(sc, i);
-        printk(KERN_INFO "%s: device %u capacity nsec %ld bsize %u\n",
+        }
-            sc->name, sc->dev->devnum, sc->capacity.nsec, sc->capacity.bsize);
+        return 0;
+        /* device_remove_file(&sc->intf->dev, &dev_attr_diag); */
+err_diag:
+        usb_set_intfdata(intf, NULL);
+        // usb_put_intf(sc->intf);
+        usb_put_dev(sc->dev);
+        kfree(sc);
+err_core:
+        return rc;
+}
+static int ub_probe_lun(struct ub_dev *sc, int lnum)
+{
+        struct ub_lun *lun;
+        request_queue_t *q;
+        struct gendisk *disk;
+        int rc;
+        rc = -ENOMEM;
+        if ((lun = kmalloc(sizeof(struct ub_lun), GFP_KERNEL)) == NULL)
+                goto err_alloc;
+        memset(lun, 0, sizeof(struct ub_lun));
+        lun->num = lnum;
+        rc = -ENOSR;
+        if ((lun->id = ub_id_get()) == -1)
+                goto err_id;
+        lun->udev = sc;
+        list_add(&lun->link, &sc->luns);
+        snprintf(lun->name, 16, DRV_NAME "%c(%d.%d.%d)",
+            lun->id + 'a', sc->dev->bus->busnum, sc->dev->devnum, lun->num);
+        lun->removable = 1;             /* XXX Query this from the device */
+        lun->changed = 1;               /* ub_revalidate clears only */
+        lun->first_open = 1;
+        ub_revalidate(sc, lun);
-        /*
-         * Just one disk per sc currently, but maybe more.
-         */
        rc = -ENOMEM;
        if ((disk = alloc_disk(UB_MINORS_PER_MAJOR)) == NULL)
                goto err_diskalloc;
-        sc->disk = disk;
+        lun->disk = disk;
-        sprintf(disk->disk_name, DRV_NAME "%c", sc->id + 'a');
+        sprintf(disk->disk_name, DRV_NAME "%c", lun->id + 'a');
-        sprintf(disk->devfs_name, DEVFS_NAME "/%c", sc->id + 'a');
+        sprintf(disk->devfs_name, DEVFS_NAME "/%c", lun->id + 'a');
        disk->major = UB_MAJOR;
-        disk->first_minor = sc->id * UB_MINORS_PER_MAJOR;
+        disk->first_minor = lun->id * UB_MINORS_PER_MAJOR;
        disk->fops = &ub_bd_fops;
-        disk->private_data = sc;
+        disk->private_data = lun;
-        disk->driverfs_dev = &intf->dev;
+        disk->driverfs_dev = &sc->intf->dev;    /* XXX Many to one ok? */
        rc = -ENOMEM;
        if ((q = blk_init_queue(ub_bd_rq_fn, &sc->lock)) == NULL)
@@ -2028,28 +2165,17 @@ static int ub_probe(struct usb_interface *intf,
        disk->queue = q;
-        // blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
+        blk_queue_bounce_limit(q, BLK_BOUNCE_HIGH);
        blk_queue_max_hw_segments(q, UB_MAX_REQ_SG);
        blk_queue_max_phys_segments(q, UB_MAX_REQ_SG);
-        // blk_queue_segment_boundary(q, CARM_SG_BOUNDARY);
+        blk_queue_segment_boundary(q, 0xffffffff);      /* Dubious. */
        blk_queue_max_sectors(q, UB_MAX_SECTORS);
-        blk_queue_hardsect_size(q, sc->capacity.bsize);
+        blk_queue_hardsect_size(q, lun->capacity.bsize);
-        /*
-         * This is a serious infraction, caused by a deficiency in the
-         * USB sg interface (usb_sg_wait()). We plan to remove this once
-         * we get mileage on the driver and can justify a change to USB API.
-         * See blk_queue_bounce_limit() to understand this part.
-         *
-         * XXX And I still need to be aware of the DMA mask in the HC.
-         */
-        q->bounce_pfn = blk_max_low_pfn;
-        q->bounce_gfp = GFP_NOIO;
-        q->queuedata = sc;
+        q->queuedata = lun;
-        set_capacity(disk, sc->capacity.nsec);
+        set_capacity(disk, lun->capacity.nsec);
-        if (sc->removable)
+        if (lun->removable)
                disk->flags |= GENHD_FL_REMOVABLE;
        add_disk(disk);
@@ -2059,22 +2185,20 @@ static int ub_probe(struct usb_interface *intf,
 err_blkqinit:
        put_disk(disk);
 err_diskalloc:
-        device_remove_file(&sc->intf->dev, &dev_attr_diag);
+        list_del(&lun->link);
-err_diag:
+        ub_id_put(lun->id);
-        usb_set_intfdata(intf, NULL);
-        // usb_put_intf(sc->intf);
-        usb_put_dev(sc->dev);
-        ub_id_put(sc->id);
 err_id:
-        kfree(sc);
+        kfree(lun);
-err_core:
+err_alloc:
        return rc;
 }
 static void ub_disconnect(struct usb_interface *intf)
 {
        struct ub_dev *sc = usb_get_intfdata(intf);
-        struct gendisk *disk = sc->disk;
+        struct list_head *p;
+        struct ub_lun *lun;
+        struct gendisk *disk;
        unsigned long flags;
        /*
@@ -2124,14 +2248,18 @@ static void ub_disconnect(struct usb_interface *intf)
        /*
         * Unregister the upper layer.
         */
-        if (disk->flags & GENHD_FL_UP)
+        list_for_each (p, &sc->luns) {
-                del_gendisk(disk);
+                lun = list_entry(p, struct ub_lun, link);
-        /*
+                disk = lun->disk;
-         * I wish I could do:
+                if (disk->flags & GENHD_FL_UP)
-         *    set_bit(QUEUE_FLAG_DEAD, &q->queue_flags);
+                        del_gendisk(disk);
-         * As it is, we rely on our internal poisoning and let
+                /*
-         * the upper levels to spin furiously failing all the I/O.
+                 * I wish I could do:
-         */
+                 *    set_bit(QUEUE_FLAG_DEAD, &q->queue_flags);
+                 * As it is, we rely on our internal poisoning and let
+                 * the upper levels to spin furiously failing all the I/O.
+                 */
+        }
        /*
         * Taking a lock on a structure which is about to be freed
@@ -2182,8 +2310,8 @@ static int __init ub_init(void)
 {
        int rc;
-        /* P3 */ printk("ub: sizeof ub_scsi_cmd %zu ub_dev %zu\n",
+        /* P3 */ printk("ub: sizeof ub_scsi_cmd %zu ub_dev %zu ub_lun %zu\n",
-                        sizeof(struct ub_scsi_cmd), sizeof(struct ub_dev));
+                        sizeof(struct ub_scsi_cmd), sizeof(struct ub_dev), sizeof(struct ub_lun));
        if ((rc = register_blkdev(UB_MAJOR, DRV_NAME)) != 0)
                goto err_regblkdev;
diff --git a/drivers/char/agp/agp.h b/drivers/char/agp/agp.h
index ad9c11391d81..c1fe013c64f3 100644
--- a/drivers/char/agp/agp.h
+++ b/drivers/char/agp/agp.h
@@ -278,6 +278,8 @@ void agp3_generic_cleanup(void);
 #define AGP_GENERIC_SIZES_ENTRIES 11
 extern struct aper_size_info_16 agp3_generic_sizes[];
+#define virt_to_gart(x) (phys_to_gart(virt_to_phys(x)))
+#define gart_to_virt(x) (phys_to_virt(gart_to_phys(x)))
 extern int agp_off;
 extern int agp_try_unsupported_boot;
diff --git a/drivers/char/agp/ali-agp.c b/drivers/char/agp/ali-agp.c
index 0212febda654..9c9c9c2247ce 100644
--- a/drivers/char/agp/ali-agp.c
+++ b/drivers/char/agp/ali-agp.c
@@ -150,7 +150,7 @@ static void *m1541_alloc_page(struct agp_bridge_data *bridge)
        pci_read_config_dword(agp_bridge->dev, ALI_CACHE_FLUSH_CTRL, &temp);
        pci_write_config_dword(agp_bridge->dev, ALI_CACHE_FLUSH_CTRL,
                        (((temp & ALI_CACHE_FLUSH_ADDR_MASK) |
-                          virt_to_phys(addr)) | ALI_CACHE_FLUSH_EN ));
+                          virt_to_gart(addr)) | ALI_CACHE_FLUSH_EN ));
        return addr;
 }
@@ -174,7 +174,7 @@ static void m1541_destroy_page(void * addr)
        pci_read_config_dword(agp_bridge->dev, ALI_CACHE_FLUSH_CTRL, &temp);
        pci_write_config_dword(agp_bridge->dev, ALI_CACHE_FLUSH_CTRL,
                        (((temp & ALI_CACHE_FLUSH_ADDR_MASK) |
-                          virt_to_phys(addr)) | ALI_CACHE_FLUSH_EN));
+                          virt_to_gart(addr)) | ALI_CACHE_FLUSH_EN));
        agp_generic_destroy_page(addr);
 }
diff --git a/drivers/char/agp/amd-k7-agp.c b/drivers/char/agp/amd-k7-agp.c
index e62a3c2c44a9..3a41672e4d66 100644
--- a/drivers/char/agp/amd-k7-agp.c
+++ b/drivers/char/agp/amd-k7-agp.c
@@ -43,7 +43,7 @@ static int amd_create_page_map(struct amd_page_map *page_map)
        SetPageReserved(virt_to_page(page_map->real));
        global_cache_flush();
-        page_map->remapped = ioremap_nocache(virt_to_phys(page_map->real),
+        page_map->remapped = ioremap_nocache(virt_to_gart(page_map->real),
                                            PAGE_SIZE);
        if (page_map->remapped == NULL) {
                ClearPageReserved(virt_to_page(page_map->real));
@@ -154,7 +154,7 @@ static int amd_create_gatt_table(struct agp_bridge_data *bridge)
        agp_bridge->gatt_table_real = (u32 *)page_dir.real;
        agp_bridge->gatt_table = (u32 __iomem *)page_dir.remapped;
-        agp_bridge->gatt_bus_addr = virt_to_phys(page_dir.real);
+        agp_bridge->gatt_bus_addr = virt_to_gart(page_dir.real);
        /* Get the address for the gart region.
         * This is a bus address even on the alpha, b/c its
@@ -167,7 +167,7 @@ static int amd_create_gatt_table(struct agp_bridge_data *bridge)
        /* Calculate the agp offset */
        for (i = 0; i < value->num_entries / 1024; i++, addr += 0x00400000) {
-                writel(virt_to_phys(amd_irongate_private.gatt_pages[i]->real) | 1,
+                writel(virt_to_gart(amd_irongate_private.gatt_pages[i]->real) | 1,
                        page_dir.remapped+GET_PAGE_DIR_OFF(addr));
                readl(page_dir.remapped+GET_PAGE_DIR_OFF(addr));        /* PCI Posting. */
        }
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 399c042f68f0..1407945a5892 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -219,7 +219,7 @@ static struct aper_size_info_32 amd_8151_sizes[7] =
 static int amd_8151_configure(void)
 {
-        unsigned long gatt_bus = virt_to_phys(agp_bridge->gatt_table_real);
+        unsigned long gatt_bus = virt_to_gart(agp_bridge->gatt_table_real);
        /* Configure AGP regs in each x86-64 host bridge. */
        for_each_nb() {
@@ -591,7 +591,7 @@ static void __devexit agp_amd64_remove(struct pci_dev *pdev)
 {
        struct agp_bridge_data *bridge = pci_get_drvdata(pdev);
-        release_mem_region(virt_to_phys(bridge->gatt_table_real),
+        release_mem_region(virt_to_gart(bridge->gatt_table_real),
                           amd64_aperture_sizes[bridge->aperture_size_idx].size);
        agp_remove_bridge(bridge);
        agp_put_bridge(bridge);
diff --git a/drivers/char/agp/ati-agp.c b/drivers/char/agp/ati-agp.c
index a65f8827c283..e572ced9100a 100644
--- a/drivers/char/agp/ati-agp.c
+++ b/drivers/char/agp/ati-agp.c
@@ -61,7 +61,7 @@ static int ati_create_page_map(ati_page_map *page_map)
        SetPageReserved(virt_to_page(page_map->real));
        err = map_page_into_agp(virt_to_page(page_map->real));
-        page_map->remapped = ioremap_nocache(virt_to_phys(page_map->real),
+        page_map->remapped = ioremap_nocache(virt_to_gart(page_map->real),
                                            PAGE_SIZE);
        if (page_map->remapped == NULL || err) {
                ClearPageReserved(virt_to_page(page_map->real));
@@ -343,7 +343,7 @@ static int ati_create_gatt_table(struct agp_bridge_data *bridge)
        agp_bridge->gatt_table_real = (u32 *)page_dir.real;
        agp_bridge->gatt_table = (u32 __iomem *) page_dir.remapped;
-        agp_bridge->gatt_bus_addr = virt_to_bus(page_dir.real);
+        agp_bridge->gatt_bus_addr = virt_to_gart(page_dir.real);
        /* Write out the size register */
        current_size = A_SIZE_LVL2(agp_bridge->current_size);
@@ -373,7 +373,7 @@ static int ati_create_gatt_table(struct agp_bridge_data *bridge)
        /* Calculate the agp offset */
        for(i = 0; i < value->num_entries / 1024; i++, addr += 0x00400000) {
-                writel(virt_to_bus(ati_generic_private.gatt_pages[i]->real) | 1,
+                writel(virt_to_gart(ati_generic_private.gatt_pages[i]->real) | 1,
                        page_dir.remapped+GET_PAGE_DIR_OFF(addr));
                readl(page_dir.remapped+GET_PAGE_DIR_OFF(addr));        /* PCI Posting. */
        }
diff --git a/drivers/char/agp/backend.c b/drivers/char/agp/backend.c
index 2f3dfb63bdc6..4d4e602fdc7e 100644
--- a/drivers/char/agp/backend.c
+++ b/drivers/char/agp/backend.c
@@ -148,7 +148,7 @@ static int agp_backend_initialize(struct agp_bridge_data *bridge)
                        return -ENOMEM;
                }
-                bridge->scratch_page_real = virt_to_phys(addr);
+                bridge->scratch_page_real = virt_to_gart(addr);
                bridge->scratch_page =
                    bridge->driver->mask_memory(bridge, bridge->scratch_page_real, 0);
        }
@@ -189,7 +189,7 @@ static int agp_backend_initialize(struct agp_bridge_data *bridge)
 err_out:
        if (bridge->driver->needs_scratch_page)
                bridge->driver->agp_destroy_page(
-                                phys_to_virt(bridge->scratch_page_real));
+                                gart_to_virt(bridge->scratch_page_real));
        if (got_gatt)
                bridge->driver->free_gatt_table(bridge);
        if (got_keylist) {
@@ -214,7 +214,7 @@ static void agp_backend_cleanup(struct agp_bridge_data *bridge)
        if (bridge->driver->agp_destroy_page &&
            bridge->driver->needs_scratch_page)
                bridge->driver->agp_destroy_page(
-                                phys_to_virt(bridge->scratch_page_real));
+                                gart_to_virt(bridge->scratch_page_real));
 }
 /* When we remove the global variable agp_bridge from all drivers
diff --git a/drivers/char/agp/efficeon-agp.c b/drivers/char/agp/efficeon-agp.c
index 1383c3165ea1..ac19fdcd21c1 100644
--- a/drivers/char/agp/efficeon-agp.c
+++ b/drivers/char/agp/efficeon-agp.c
@@ -219,7 +219,7 @@ static int efficeon_create_gatt_table(struct agp_bridge_data *bridge)
                efficeon_private.l1_table[index] = page;
-                value = __pa(page) | pati | present | index;
+                value = virt_to_gart(page) | pati | present | index;
                pci_write_config_dword(agp_bridge->dev,
                        EFFICEON_ATTPAGE, value);
diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c
index c321a924e38a..f0079e991bdc 100644
--- a/drivers/char/agp/generic.c
+++ b/drivers/char/agp/generic.c
@@ -153,7 +153,7 @@ void agp_free_memory(struct agp_memory *curr)
        }
        if (curr->page_count != 0) {
                for (i = 0; i < curr->page_count; i++) {
-                        curr->bridge->driver->agp_destroy_page(phys_to_virt(curr->memory[i]));
+                        curr->bridge->driver->agp_destroy_page(gart_to_virt(curr->memory[i]));
                }
        }
        agp_free_key(curr->key);
@@ -209,7 +209,7 @@ struct agp_memory *agp_allocate_memory(struct agp_bridge_data *bridge,
                        agp_free_memory(new);
                        return NULL;
                }
-                new->memory[i] = virt_to_phys(addr);
+                new->memory[i] = virt_to_gart(addr);
                new->page_count++;
        }
       new->bridge = bridge;
@@ -295,19 +295,6 @@ int agp_num_entries(void)
 EXPORT_SYMBOL_GPL(agp_num_entries);
-static int check_bridge_mode(struct pci_dev *dev)
-{
-        u32 agp3;
-        u8 cap_ptr;
-        cap_ptr = pci_find_capability(dev, PCI_CAP_ID_AGP);
-        pci_read_config_dword(dev, cap_ptr+AGPSTAT, &agp3);
-        if (agp3 & AGPSTAT_MODE_3_0)
-                return 1;
-        return 0;
-}
 /**
 *      agp_copy_info  -  copy bridge state information
 *
@@ -328,7 +315,7 @@ int agp_copy_info(struct agp_bridge_data *bridge, struct agp_kern_info *info)
        info->version.minor = bridge->version->minor;
        info->chipset = SUPPORTED;
        info->device = bridge->dev;
-        if (check_bridge_mode(bridge->dev))
+        if (bridge->mode & AGPSTAT_MODE_3_0)
                info->mode = bridge->mode & ~AGP3_RESERVED_MASK;
        else
                info->mode = bridge->mode & ~AGP2_RESERVED_MASK;
@@ -661,7 +648,7 @@ u32 agp_collect_device_status(struct agp_bridge_data *bridge, u32 requested_mode
                bridge_agpstat &= ~AGPSTAT_FW;
        /* Check to see if we are operating in 3.0 mode */
-        if (check_bridge_mode(agp_bridge->dev))
+        if (agp_bridge->mode & AGPSTAT_MODE_3_0)
                agp_v3_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
        else
                agp_v2_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
@@ -732,7 +719,7 @@ void agp_generic_enable(struct agp_bridge_data *bridge, u32 requested_mode)
        /* Do AGP version specific frobbing. */
        if (bridge->major_version >= 3) {
-                if (check_bridge_mode(bridge->dev)) {
+                if (bridge->mode & AGPSTAT_MODE_3_0) {
                        /* If we have 3.5, we can do the isoch stuff. */
                        if (bridge->minor_version >= 5)
                                agp_3_5_enable(bridge);
@@ -806,8 +793,7 @@ int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
                                break;
                        }
-                        table = (char *) __get_free_pages(GFP_KERNEL,
+                        table = alloc_gatt_pages(page_order);
-                                                          page_order);
                        if (table == NULL) {
                                i++;
@@ -838,7 +824,7 @@ int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
                size = ((struct aper_size_info_fixed *) temp)->size;
                page_order = ((struct aper_size_info_fixed *) temp)->page_order;
                num_entries = ((struct aper_size_info_fixed *) temp)->num_entries;
-                table = (char *) __get_free_pages(GFP_KERNEL, page_order);
+                table = alloc_gatt_pages(page_order);
        }
        if (table == NULL)
@@ -853,7 +839,7 @@ int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
        agp_gatt_table = (void *)table;
        bridge->driver->cache_flush();
-        bridge->gatt_table = ioremap_nocache(virt_to_phys(table),
+        bridge->gatt_table = ioremap_nocache(virt_to_gart(table),
                                        (PAGE_SIZE * (1 << page_order)));
        bridge->driver->cache_flush();
@@ -861,11 +847,11 @@ int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
                for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
                        ClearPageReserved(page);
-                free_pages((unsigned long) table, page_order);
+                free_gatt_pages(table, page_order);
                return -ENOMEM;
        }
-        bridge->gatt_bus_addr = virt_to_phys(bridge->gatt_table_real);
+        bridge->gatt_bus_addr = virt_to_gart(bridge->gatt_table_real);
        /* AK: bogus, should encode addresses > 4GB */
        for (i = 0; i < num_entries; i++) {
@@ -919,7 +905,7 @@ int agp_generic_free_gatt_table(struct agp_bridge_data *bridge)
        for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
                ClearPageReserved(page);
-        free_pages((unsigned long) bridge->gatt_table_real, page_order);
+        free_gatt_pages(bridge->gatt_table_real, page_order);
        agp_gatt_table = NULL;
        bridge->gatt_table = NULL;
diff --git a/drivers/char/agp/hp-agp.c b/drivers/char/agp/hp-agp.c
index 6052bfa04c72..99762b6c19ae 100644
--- a/drivers/char/agp/hp-agp.c
+++ b/drivers/char/agp/hp-agp.c
@@ -110,7 +110,7 @@ static int __init hp_zx1_ioc_shared(void)
        hp->gart_size = HP_ZX1_GART_SIZE;
        hp->gatt_entries = hp->gart_size / hp->io_page_size;
-        hp->io_pdir = phys_to_virt(readq(hp->ioc_regs+HP_ZX1_PDIR_BASE));
+        hp->io_pdir = gart_to_virt(readq(hp->ioc_regs+HP_ZX1_PDIR_BASE));
        hp->gatt = &hp->io_pdir[HP_ZX1_IOVA_TO_PDIR(hp->gart_base)];
        if (hp->gatt[0] != HP_ZX1_SBA_IOMMU_COOKIE) {
@@ -248,7 +248,7 @@ hp_zx1_configure (void)
        agp_bridge->mode = readl(hp->lba_regs+hp->lba_cap_offset+PCI_AGP_STATUS);
        if (hp->io_pdir_owner) {
-                writel(virt_to_phys(hp->io_pdir), hp->ioc_regs+HP_ZX1_PDIR_BASE);
+                writel(virt_to_gart(hp->io_pdir), hp->ioc_regs+HP_ZX1_PDIR_BASE);
                readl(hp->ioc_regs+HP_ZX1_PDIR_BASE);
                writel(hp->io_tlb_ps, hp->ioc_regs+HP_ZX1_TCNFG);
                readl(hp->ioc_regs+HP_ZX1_TCNFG);
diff --git a/drivers/char/agp/i460-agp.c b/drivers/char/agp/i460-agp.c
index adbea896c0d2..94943298c03e 100644
--- a/drivers/char/agp/i460-agp.c
+++ b/drivers/char/agp/i460-agp.c
@@ -372,7 +372,7 @@ static int i460_alloc_large_page (struct lp_desc *lp)
        }
        memset(lp->alloced_map, 0, map_size);
-        lp->paddr = virt_to_phys(lpage);
+        lp->paddr = virt_to_gart(lpage);
        lp->refcount = 0;
        atomic_add(I460_KPAGES_PER_IOPAGE, &agp_bridge->current_memory_agp);
        return 0;
@@ -383,7 +383,7 @@ static void i460_free_large_page (struct lp_desc *lp)
        kfree(lp->alloced_map);
        lp->alloced_map = NULL;
-        free_pages((unsigned long) phys_to_virt(lp->paddr), I460_IO_PAGE_SHIFT - PAGE_SHIFT);
+        free_pages((unsigned long) gart_to_virt(lp->paddr), I460_IO_PAGE_SHIFT - PAGE_SHIFT);
        atomic_sub(I460_KPAGES_PER_IOPAGE, &agp_bridge->current_memory_agp);
 }
diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
index 8c7d727432bb..51266d6b4d78 100644
--- a/drivers/char/agp/intel-agp.c
+++ b/drivers/char/agp/intel-agp.c
@@ -286,7 +286,7 @@ static struct agp_memory *alloc_agpphysmem_i8xx(size_t pg_count, int type)
        if (new == NULL)
                return NULL;
-        new->memory[0] = virt_to_phys(addr);
+        new->memory[0] = virt_to_gart(addr);
        if (pg_count == 4) {
                /* kludge to get 4 physical pages for ARGB cursor */
                new->memory[1] = new->memory[0] + PAGE_SIZE;
@@ -329,10 +329,10 @@ static void intel_i810_free_by_type(struct agp_memory *curr)
        agp_free_key(curr->key);
        if(curr->type == AGP_PHYS_MEMORY) {
                if (curr->page_count == 4)
-                        i8xx_destroy_pages(phys_to_virt(curr->memory[0]));
+                        i8xx_destroy_pages(gart_to_virt(curr->memory[0]));
                else
                        agp_bridge->driver->agp_destroy_page(
-                                 phys_to_virt(curr->memory[0]));
+                                 gart_to_virt(curr->memory[0]));
                vfree(curr->memory);
        }
        kfree(curr);
@@ -418,7 +418,8 @@ static void intel_i830_init_gtt_entries(void)
                case I915_GMCH_GMS_STOLEN_48M:
                        /* Check it's really I915G */
                        if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915G_HB ||
-                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB)
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB ||
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB)
                                gtt_entries = MB(48) - KB(size);
                        else
                                gtt_entries = 0;
@@ -426,7 +427,8 @@ static void intel_i830_init_gtt_entries(void)
                case I915_GMCH_GMS_STOLEN_64M:
                        /* Check it's really I915G */
                        if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915G_HB ||
-                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB)
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB ||
+                            agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82945G_HB)
                                gtt_entries = MB(64) - KB(size);
                        else
                                gtt_entries = 0;
@@ -1662,6 +1664,14 @@ static int __devinit agp_intel_probe(struct pci_dev *pdev,
                }
                name = "915GM";
                break;
+        case PCI_DEVICE_ID_INTEL_82945G_HB:
+                if (find_i830(PCI_DEVICE_ID_INTEL_82945G_IG)) {
+                        bridge->driver = &intel_915_driver;
+                } else {
+                        bridge->driver = &intel_845_driver;
+                }
+                name = "945G";
+                break;
        case PCI_DEVICE_ID_INTEL_7505_0:
                bridge->driver = &intel_7505_driver;
                name = "E7505";
@@ -1801,6 +1811,7 @@ static struct pci_device_id agp_intel_pci_table[] = {
        ID(PCI_DEVICE_ID_INTEL_7205_0),
        ID(PCI_DEVICE_ID_INTEL_82915G_HB),
        ID(PCI_DEVICE_ID_INTEL_82915GM_HB),
+        ID(PCI_DEVICE_ID_INTEL_82945G_HB),
        { }
 };
diff --git a/drivers/char/agp/sgi-agp.c b/drivers/char/agp/sgi-agp.c
index 4b3eda267976..d3aa159c9dec 100644
--- a/drivers/char/agp/sgi-agp.c
+++ b/drivers/char/agp/sgi-agp.c
@@ -133,11 +133,14 @@ static int sgi_tioca_insert_memory(struct agp_memory *mem, off_t pg_start,
        off_t j;
        void *temp;
        struct agp_bridge_data *bridge;
+        u64 *table;
        bridge = mem->bridge;
        if (!bridge)
                return -EINVAL;
+        table = (u64 *)bridge->gatt_table;
        temp = bridge->current_size;
        switch (bridge->driver->size_type) {
@@ -175,7 +178,7 @@ static int sgi_tioca_insert_memory(struct agp_memory *mem, off_t pg_start,
        j = pg_start;
        while (j < (pg_start + mem->page_count)) {
-                if (*(bridge->gatt_table + j))
+                if (table[j])
                        return -EBUSY;
                j++;
        }
@@ -186,7 +189,7 @@ static int sgi_tioca_insert_memory(struct agp_memory *mem, off_t pg_start,
        }
        for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
-                *(bridge->gatt_table + j) =
+                table[j] =
                    bridge->driver->mask_memory(bridge, mem->memory[i],
                                                mem->type);
        }
@@ -200,6 +203,7 @@ static int sgi_tioca_remove_memory(struct agp_memory *mem, off_t pg_start,
 {
        size_t i;
        struct agp_bridge_data *bridge;
+        u64 *table;
        bridge = mem->bridge;
        if (!bridge)
@@ -209,8 +213,10 @@ static int sgi_tioca_remove_memory(struct agp_memory *mem, off_t pg_start,
                return -EINVAL;
        }
+        table = (u64 *)bridge->gatt_table;
        for (i = pg_start; i < (mem->page_count + pg_start); i++) {
-                *(bridge->gatt_table + i) = 0;
+                table[i] = 0;
        }
        bridge->driver->tlb_flush(mem);
diff --git a/drivers/char/agp/sworks-agp.c b/drivers/char/agp/sworks-agp.c
index 10c23302dd84..a9fb12c20eb7 100644
--- a/drivers/char/agp/sworks-agp.c
+++ b/drivers/char/agp/sworks-agp.c
@@ -51,7 +51,7 @@ static int serverworks_create_page_map(struct serverworks_page_map *page_map)
        }
        SetPageReserved(virt_to_page(page_map->real));
        global_cache_flush();
-        page_map->remapped = ioremap_nocache(virt_to_phys(page_map->real), 
+        page_map->remapped = ioremap_nocache(virt_to_gart(page_map->real),
                                            PAGE_SIZE);
        if (page_map->remapped == NULL) {
                ClearPageReserved(virt_to_page(page_map->real));
@@ -162,7 +162,7 @@ static int serverworks_create_gatt_table(struct agp_bridge_data *bridge)
        /* Create a fake scratch directory */
        for(i = 0; i < 1024; i++) {
                writel(agp_bridge->scratch_page, serverworks_private.scratch_dir.remapped+i);
-                writel(virt_to_phys(serverworks_private.scratch_dir.real) | 1, page_dir.remapped+i);
+                writel(virt_to_gart(serverworks_private.scratch_dir.real) | 1, page_dir.remapped+i);
        }
        retval = serverworks_create_gatt_pages(value->num_entries / 1024);
@@ -174,7 +174,7 @@ static int serverworks_create_gatt_table(struct agp_bridge_data *bridge)
        agp_bridge->gatt_table_real = (u32 *)page_dir.real;
        agp_bridge->gatt_table = (u32 __iomem *)page_dir.remapped;
-        agp_bridge->gatt_bus_addr = virt_to_phys(page_dir.real);
+        agp_bridge->gatt_bus_addr = virt_to_gart(page_dir.real);
        /* Get the address for the gart region.
         * This is a bus address even on the alpha, b/c its
@@ -187,7 +187,7 @@ static int serverworks_create_gatt_table(struct agp_bridge_data *bridge)
        /* Calculate the agp offset */  
        for(i = 0; i < value->num_entries / 1024; i++)
-                writel(virt_to_phys(serverworks_private.gatt_pages[i]->real)|1, page_dir.remapped+i);
+                writel(virt_to_gart(serverworks_private.gatt_pages[i]->real)|1, page_dir.remapped+i);
        return 0;
 }
diff --git a/drivers/char/agp/uninorth-agp.c b/drivers/char/agp/uninorth-agp.c
index a673971f2a90..c8255312b8c1 100644
--- a/drivers/char/agp/uninorth-agp.c
+++ b/drivers/char/agp/uninorth-agp.c
@@ -407,7 +407,7 @@ static int uninorth_create_gatt_table(struct agp_bridge_data *bridge)
        bridge->gatt_table_real = (u32 *) table;
        bridge->gatt_table = (u32 *)table;
-        bridge->gatt_bus_addr = virt_to_phys(table);
+        bridge->gatt_bus_addr = virt_to_gart(table);
        for (i = 0; i < num_entries; i++)
                bridge->gatt_table[i] = 0;
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 7a245068e3e5..f022f0944434 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -1995,9 +1995,6 @@ static void mxser_receive_chars(struct mxser_struct *info, int *status)
        unsigned char ch, gdl;
        int ignored = 0;
        int cnt = 0;
-        unsigned char *cp;
-        char *fp;
-        int count;
        int recv_room;
        int max = 256;
        unsigned long flags;
@@ -2011,10 +2008,6 @@ static void mxser_receive_chars(struct mxser_struct *info, int *status)
                //return;
        }
-        cp = tty->flip.char_buf;
-        fp = tty->flip.flag_buf;
-        count = 0;
        // following add by Victor Yu. 09-02-2002
        if (info->IsMoxaMustChipFlag != MOXA_OTHER_UART) {
@@ -2041,12 +2034,10 @@ static void mxser_receive_chars(struct mxser_struct *info, int *status)
                }
                while (gdl--) {
                        ch = inb(info->base + UART_RX);
-                        count++;
+                        tty_insert_flip_char(tty, ch, 0);
-                        *cp++ = ch;
-                        *fp++ = 0;
                        cnt++;
                        /*
-                           if((count>=HI_WATER) && (info->stop_rx==0)){
+                           if((cnt>=HI_WATER) && (info->stop_rx==0)){
                           mxser_stoprx(tty);
                           info->stop_rx=1;
                           break;
@@ -2061,7 +2052,7 @@ intr_old:
                if (max-- < 0)
                        break;
                /*
-                   if((count>=HI_WATER) && (info->stop_rx==0)){
+                   if((cnt>=HI_WATER) && (info->stop_rx==0)){
                   mxser_stoprx(tty);
                   info->stop_rx=1;
                   break;
@@ -2078,36 +2069,33 @@ intr_old:
                        if (++ignored > 100)
                                break;
                } else {
-                        count++;
+                        char flag = 0;
                        if (*status & UART_LSR_SPECIAL) {
                                if (*status & UART_LSR_BI) {
-                                        *fp++ = TTY_BREAK;
+                                        flag = TTY_BREAK;
 /* added by casper 1/11/2000 */
                                        info->icount.brk++;
 /* */
                                        if (info->flags & ASYNC_SAK)
                                                do_SAK(tty);
                                } else if (*status & UART_LSR_PE) {
-                                        *fp++ = TTY_PARITY;
+                                        flag = TTY_PARITY;
 /* added by casper 1/11/2000 */
                                        info->icount.parity++;
 /* */
                                } else if (*status & UART_LSR_FE) {
-                                        *fp++ = TTY_FRAME;
+                                        flag = TTY_FRAME;
 /* added by casper 1/11/2000 */
                                        info->icount.frame++;
 /* */
                                } else if (*status & UART_LSR_OE) {
-                                        *fp++ = TTY_OVERRUN;
+                                        flag = TTY_OVERRUN;
 /* added by casper 1/11/2000 */
                                        info->icount.overrun++;
 /* */
-                                } else
+                                }
-                                        *fp++ = 0;
+                        }
-                        } else
+                        tty_insert_flip_char(tty, ch, flag);
-                                *fp++ = 0;
-                        *cp++ = ch;
                        cnt++;
                        if (cnt >= recv_room) {
                                if (!info->ldisc_stop_rx) {
@@ -2132,13 +2120,13 @@ intr_old:
                // above add by Victor Yu. 09-02-2002
        } while (*status & UART_LSR_DR);
-      end_intr:         // add by Victor Yu. 09-02-2002
+end_intr:               // add by Victor Yu. 09-02-2002
        mxvar_log.rxcnt[info->port] += cnt;
        info->mon_data.rxcnt += cnt;
        info->mon_data.up_rxcnt += cnt;
        spin_unlock_irqrestore(&info->slock, flags);
-        
        tty_flip_buffer_push(tty);
 }
diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig
index 95882bb1950e..60c9be99c6d9 100644
--- a/drivers/cpufreq/Kconfig
+++ b/drivers/cpufreq/Kconfig
@@ -46,6 +46,10 @@ config CPU_FREQ_STAT_DETAILS
         This will show detail CPU frequency translation table in sysfs file
         system
+# Note that it is not currently possible to set the other governors (such as ondemand)
+# as the default, since if they fail to initialise, cpufreq will be
+# left in an undefined state.
 choice
        prompt "Default CPUFreq governor"
        default CPU_FREQ_DEFAULT_GOV_USERSPACE if CPU_FREQ_SA1100 || CPU_FREQ_SA1110
@@ -115,4 +119,24 @@ config CPU_FREQ_GOV_ONDEMAND
          If in doubt, say N.
+config CPU_FREQ_GOV_CONSERVATIVE
+        tristate "'conservative' cpufreq governor"
+        depends on CPU_FREQ
+        help
+          'conservative' - this driver is rather similar to the 'ondemand'
+          governor both in its source code and its purpose, the difference is
+          its optimisation for better suitability in a battery powered
+          environment.  The frequency is gracefully increased and decreased
+          rather than jumping to 100% when speed is required.
+          If you have a desktop machine then you should really be considering
+          the 'ondemand' governor instead, however if you are using a laptop,
+          PDA or even an AMD64 based computer (due to the unacceptable
+          step-by-step latency issues between the minimum and maximum frequency
+          transitions in the CPU) you will probably want to use this governor.
+          For details, take a look at linux/Documentation/cpu-freq.
+          If in doubt, say N.
 endif   # CPU_FREQ
diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile
index 67b16e5a41a7..71fc3b4173f1 100644
--- a/drivers/cpufreq/Makefile
+++ b/drivers/cpufreq/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_CPU_FREQ_GOV_PERFORMANCE)	+= cpufreq_performance.o
 obj-$(CONFIG_CPU_FREQ_GOV_POWERSAVE)    += cpufreq_powersave.o
 obj-$(CONFIG_CPU_FREQ_GOV_USERSPACE)    += cpufreq_userspace.o
 obj-$(CONFIG_CPU_FREQ_GOV_ONDEMAND)     += cpufreq_ondemand.o
+obj-$(CONFIG_CPU_FREQ_GOV_CONSERVATIVE) += cpufreq_conservative.o
 # CPUfreq cross-arch helpers
 obj-$(CONFIG_CPU_FREQ_TABLE)            += freq_table.o
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 8e561313d094..03b5fb2ddcf4 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -258,7 +258,7 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
                            (likely(cpufreq_cpu_data[freqs->cpu]->cur)) &&
                            (unlikely(freqs->old != cpufreq_cpu_data[freqs->cpu]->cur)))
                        {
-                                printk(KERN_WARNING "Warning: CPU frequency is %u, "
+                                dprintk(KERN_WARNING "Warning: CPU frequency is %u, "
                                       "cpufreq assumed %u kHz.\n", freqs->old, cpufreq_cpu_data[freqs->cpu]->cur);
                                freqs->old = cpufreq_cpu_data[freqs->cpu]->cur;
                        }
@@ -814,7 +814,7 @@ static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq, unsigne
 {
        struct cpufreq_freqs freqs;
-        printk(KERN_WARNING "Warning: CPU frequency out of sync: cpufreq and timing "
+        dprintk(KERN_WARNING "Warning: CPU frequency out of sync: cpufreq and timing "
               "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
        freqs.cpu = cpu;
@@ -923,7 +923,7 @@ static int cpufreq_suspend(struct sys_device * sysdev, u32 state)
                struct cpufreq_freqs freqs;
                if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
-                        printk(KERN_DEBUG "Warning: CPU frequency is %u, "
+                        dprintk(KERN_DEBUG "Warning: CPU frequency is %u, "
                               "cpufreq assumed %u kHz.\n",
                               cur_freq, cpu_policy->cur);
@@ -1004,7 +1004,7 @@ static int cpufreq_resume(struct sys_device * sysdev)
                        struct cpufreq_freqs freqs;
                        if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
-                                printk(KERN_WARNING "Warning: CPU frequency"
+                                dprintk(KERN_WARNING "Warning: CPU frequency"
                                       "is %u, cpufreq assumed %u kHz.\n",
                                       cur_freq, cpu_policy->cur);
diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
new file mode 100644
index 000000000000..e1df376e709e
--- /dev/null
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -0,0 +1,586 @@
+/*
+ *  drivers/cpufreq/cpufreq_conservative.c
+ *
+ *  Copyright (C)  2001 Russell King
+ *            (C)  2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
+ *                      Jun Nakajima <jun.nakajima@intel.com>
+ *            (C)  2004 Alexander Clouter <alex-kernel@digriz.org.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/smp.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/ctype.h>
+#include <linux/cpufreq.h>
+#include <linux/sysctl.h>
+#include <linux/types.h>
+#include <linux/fs.h>
+#include <linux/sysfs.h>
+#include <linux/sched.h>
+#include <linux/kmod.h>
+#include <linux/workqueue.h>
+#include <linux/jiffies.h>
+#include <linux/kernel_stat.h>
+#include <linux/percpu.h>
+/*
+ * dbs is used in this file as a shortform for demandbased switching
+ * It helps to keep variable names smaller, simpler
+ */
+#define DEF_FREQUENCY_UP_THRESHOLD              (80)
+#define MIN_FREQUENCY_UP_THRESHOLD              (0)
+#define MAX_FREQUENCY_UP_THRESHOLD              (100)
+#define DEF_FREQUENCY_DOWN_THRESHOLD            (20)
+#define MIN_FREQUENCY_DOWN_THRESHOLD            (0)
+#define MAX_FREQUENCY_DOWN_THRESHOLD            (100)
+/* 
+ * The polling frequency of this governor depends on the capability of 
+ * the processor. Default polling frequency is 1000 times the transition
+ * latency of the processor. The governor will work on any processor with 
+ * transition latency <= 10mS, using appropriate sampling 
+ * rate.
+ * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
+ * this governor will not work.
+ * All times here are in uS.
+ */
+static unsigned int                             def_sampling_rate;
+#define MIN_SAMPLING_RATE                       (def_sampling_rate / 2)
+#define MAX_SAMPLING_RATE                       (500 * def_sampling_rate)
+#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (100000)
+#define DEF_SAMPLING_DOWN_FACTOR                (5)
+#define TRANSITION_LATENCY_LIMIT                (10 * 1000)
+static void do_dbs_timer(void *data);
+struct cpu_dbs_info_s {
+        struct cpufreq_policy   *cur_policy;
+        unsigned int            prev_cpu_idle_up;
+        unsigned int            prev_cpu_idle_down;
+        unsigned int            enable;
+};
+static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
+static unsigned int dbs_enable; /* number of CPUs using this policy */
+static DECLARE_MUTEX    (dbs_sem);
+static DECLARE_WORK     (dbs_work, do_dbs_timer, NULL);
+struct dbs_tuners {
+        unsigned int            sampling_rate;
+        unsigned int            sampling_down_factor;
+        unsigned int            up_threshold;
+        unsigned int            down_threshold;
+        unsigned int            ignore_nice;
+        unsigned int            freq_step;
+};
+static struct dbs_tuners dbs_tuners_ins = {
+        .up_threshold           = DEF_FREQUENCY_UP_THRESHOLD,
+        .down_threshold         = DEF_FREQUENCY_DOWN_THRESHOLD,
+        .sampling_down_factor   = DEF_SAMPLING_DOWN_FACTOR,
+};
+static inline unsigned int get_cpu_idle_time(unsigned int cpu)
+{
+        return  kstat_cpu(cpu).cpustat.idle +
+                kstat_cpu(cpu).cpustat.iowait +
+                ( !dbs_tuners_ins.ignore_nice ? 
+                  kstat_cpu(cpu).cpustat.nice :
+                  0);
+}
+/************************** sysfs interface ************************/
+static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
+{
+        return sprintf (buf, "%u\n", MAX_SAMPLING_RATE);
+}
+static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
+{
+        return sprintf (buf, "%u\n", MIN_SAMPLING_RATE);
+}
+#define define_one_ro(_name)                                    \
+static struct freq_attr _name =                                 \
+__ATTR(_name, 0444, show_##_name, NULL)
+define_one_ro(sampling_rate_max);
+define_one_ro(sampling_rate_min);
+/* cpufreq_conservative Governor Tunables */
+#define show_one(file_name, object)                                     \
+static ssize_t show_##file_name                                         \
+(struct cpufreq_policy *unused, char *buf)                              \
+{                                                                       \
+        return sprintf(buf, "%u\n", dbs_tuners_ins.object);             \
+}
+show_one(sampling_rate, sampling_rate);
+show_one(sampling_down_factor, sampling_down_factor);
+show_one(up_threshold, up_threshold);
+show_one(down_threshold, down_threshold);
+show_one(ignore_nice, ignore_nice);
+show_one(freq_step, freq_step);
+static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, 
+                const char *buf, size_t count)
+{
+        unsigned int input;
+        int ret;
+        ret = sscanf (buf, "%u", &input);
+        if (ret != 1 )
+                return -EINVAL;
+        down(&dbs_sem);
+        dbs_tuners_ins.sampling_down_factor = input;
+        up(&dbs_sem);
+        return count;
+}
+static ssize_t store_sampling_rate(struct cpufreq_policy *unused, 
+                const char *buf, size_t count)
+{
+        unsigned int input;
+        int ret;
+        ret = sscanf (buf, "%u", &input);
+        down(&dbs_sem);
+        if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {
+                up(&dbs_sem);
+                return -EINVAL;
+        }
+        dbs_tuners_ins.sampling_rate = input;
+        up(&dbs_sem);
+        return count;
+}
+static ssize_t store_up_threshold(struct cpufreq_policy *unused, 
+                const char *buf, size_t count)
+{
+        unsigned int input;
+        int ret;
+        ret = sscanf (buf, "%u", &input);
+        down(&dbs_sem);
+        if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || 
+                        input < MIN_FREQUENCY_UP_THRESHOLD ||
+                        input <= dbs_tuners_ins.down_threshold) {
+                up(&dbs_sem);
+                return -EINVAL;
+        }
+        dbs_tuners_ins.up_threshold = input;
+        up(&dbs_sem);
+        return count;
+}
+static ssize_t store_down_threshold(struct cpufreq_policy *unused, 
+                const char *buf, size_t count)
+{
+        unsigned int input;
+        int ret;
+        ret = sscanf (buf, "%u", &input);
+        down(&dbs_sem);
+        if (ret != 1 || input > MAX_FREQUENCY_DOWN_THRESHOLD || 
+                        input < MIN_FREQUENCY_DOWN_THRESHOLD ||
+                        input >= dbs_tuners_ins.up_threshold) {
+                up(&dbs_sem);
+                return -EINVAL;
+        }
+        dbs_tuners_ins.down_threshold = input;
+        up(&dbs_sem);
+        return count;
+}
+static ssize_t store_ignore_nice(struct cpufreq_policy *policy,
+                const char *buf, size_t count)
+{
+        unsigned int input;
+        int ret;
+        unsigned int j;
+        
+        ret = sscanf (buf, "%u", &input);
+        if ( ret != 1 )
+                return -EINVAL;
+        if ( input > 1 )
+                input = 1;
+        
+        down(&dbs_sem);
+        if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
+                up(&dbs_sem);
+                return count;
+        }
+        dbs_tuners_ins.ignore_nice = input;
+        /* we need to re-evaluate prev_cpu_idle_up and prev_cpu_idle_down */
+        for_each_online_cpu(j) {
+                struct cpu_dbs_info_s *j_dbs_info;
+                j_dbs_info = &per_cpu(cpu_dbs_info, j);
+                j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
+                j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
+        }
+        up(&dbs_sem);
+        return count;
+}
+static ssize_t store_freq_step(struct cpufreq_policy *policy,
+                const char *buf, size_t count)
+{
+        unsigned int input;
+        int ret;
+        ret = sscanf (buf, "%u", &input);
+        if ( ret != 1 )
+                return -EINVAL;
+        if ( input > 100 )
+                input = 100;
+        
+        /* no need to test here if freq_step is zero as the user might actually
+         * want this, they would be crazy though :) */
+        down(&dbs_sem);
+        dbs_tuners_ins.freq_step = input;
+        up(&dbs_sem);
+        return count;
+}
+#define define_one_rw(_name) \
+static struct freq_attr _name = \
+__ATTR(_name, 0644, show_##_name, store_##_name)
+define_one_rw(sampling_rate);
+define_one_rw(sampling_down_factor);
+define_one_rw(up_threshold);
+define_one_rw(down_threshold);
+define_one_rw(ignore_nice);
+define_one_rw(freq_step);
+static struct attribute * dbs_attributes[] = {
+        &sampling_rate_max.attr,
+        &sampling_rate_min.attr,
+        &sampling_rate.attr,
+        &sampling_down_factor.attr,
+        &up_threshold.attr,
+        &down_threshold.attr,
+        &ignore_nice.attr,
+        &freq_step.attr,
+        NULL
+};
+static struct attribute_group dbs_attr_group = {
+        .attrs = dbs_attributes,
+        .name = "conservative",
+};
+/************************** sysfs end ************************/
+static void dbs_check_cpu(int cpu)
+{
+        unsigned int idle_ticks, up_idle_ticks, down_idle_ticks;
+        unsigned int freq_step;
+        unsigned int freq_down_sampling_rate;
+        static int down_skip[NR_CPUS];
+        static int requested_freq[NR_CPUS];
+        static unsigned short init_flag = 0;
+        struct cpu_dbs_info_s *this_dbs_info;
+        struct cpu_dbs_info_s *dbs_info;
+        struct cpufreq_policy *policy;
+        unsigned int j;
+        this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
+        if (!this_dbs_info->enable)
+                return;
+        policy = this_dbs_info->cur_policy;
+        if ( init_flag == 0 ) {
+                for ( /* NULL */; init_flag < NR_CPUS; init_flag++ ) {
+                        dbs_info = &per_cpu(cpu_dbs_info, init_flag);
+                        requested_freq[cpu] = dbs_info->cur_policy->cur;
+                }
+                init_flag = 1;
+        }
+        
+        /* 
+         * The default safe range is 20% to 80% 
+         * Every sampling_rate, we check
+         *      - If current idle time is less than 20%, then we try to 
+         *        increase frequency
+         * Every sampling_rate*sampling_down_factor, we check
+         *      - If current idle time is more than 80%, then we try to
+         *        decrease frequency
+         *
+         * Any frequency increase takes it to the maximum frequency. 
+         * Frequency reduction happens at minimum steps of 
+         * 5% (default) of max_frequency 
+         */
+        /* Check for frequency increase */
+        idle_ticks = UINT_MAX;
+        for_each_cpu_mask(j, policy->cpus) {
+                unsigned int tmp_idle_ticks, total_idle_ticks;
+                struct cpu_dbs_info_s *j_dbs_info;
+                j_dbs_info = &per_cpu(cpu_dbs_info, j);
+                /* Check for frequency increase */
+                total_idle_ticks = get_cpu_idle_time(j);
+                tmp_idle_ticks = total_idle_ticks -
+                        j_dbs_info->prev_cpu_idle_up;
+                j_dbs_info->prev_cpu_idle_up = total_idle_ticks;
+                if (tmp_idle_ticks < idle_ticks)
+                        idle_ticks = tmp_idle_ticks;
+        }
+        /* Scale idle ticks by 100 and compare with up and down ticks */
+        idle_ticks *= 100;
+        up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) *
+                usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
+        if (idle_ticks < up_idle_ticks) {
+                down_skip[cpu] = 0;
+                for_each_cpu_mask(j, policy->cpus) {
+                        struct cpu_dbs_info_s *j_dbs_info;
+                        j_dbs_info = &per_cpu(cpu_dbs_info, j);
+                        j_dbs_info->prev_cpu_idle_down = 
+                                        j_dbs_info->prev_cpu_idle_up;
+                }
+                /* if we are already at full speed then break out early */
+                if (requested_freq[cpu] == policy->max)
+                        return;
+                
+                freq_step = (dbs_tuners_ins.freq_step * policy->max) / 100;
+                /* max freq cannot be less than 100. But who knows.... */
+                if (unlikely(freq_step == 0))
+                        freq_step = 5;
+                
+                requested_freq[cpu] += freq_step;
+                if (requested_freq[cpu] > policy->max)
+                        requested_freq[cpu] = policy->max;
+                __cpufreq_driver_target(policy, requested_freq[cpu], 
+                        CPUFREQ_RELATION_H);
+                return;
+        }
+        /* Check for frequency decrease */
+        down_skip[cpu]++;
+        if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor)
+                return;
+        idle_ticks = UINT_MAX;
+        for_each_cpu_mask(j, policy->cpus) {
+                unsigned int tmp_idle_ticks, total_idle_ticks;
+                struct cpu_dbs_info_s *j_dbs_info;
+                j_dbs_info = &per_cpu(cpu_dbs_info, j);
+                total_idle_ticks = j_dbs_info->prev_cpu_idle_up;
+                tmp_idle_ticks = total_idle_ticks -
+                        j_dbs_info->prev_cpu_idle_down;
+                j_dbs_info->prev_cpu_idle_down = total_idle_ticks;
+                if (tmp_idle_ticks < idle_ticks)
+                        idle_ticks = tmp_idle_ticks;
+        }
+        /* Scale idle ticks by 100 and compare with up and down ticks */
+        idle_ticks *= 100;
+        down_skip[cpu] = 0;
+        freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *
+                dbs_tuners_ins.sampling_down_factor;
+        down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) *
+                        usecs_to_jiffies(freq_down_sampling_rate);
+        if (idle_ticks > down_idle_ticks) {
+                /* if we are already at the lowest speed then break out early
+                 * or if we 'cannot' reduce the speed as the user might want
+                 * freq_step to be zero */
+                if (requested_freq[cpu] == policy->min
+                                || dbs_tuners_ins.freq_step == 0)
+                        return;
+                freq_step = (dbs_tuners_ins.freq_step * policy->max) / 100;
+                /* max freq cannot be less than 100. But who knows.... */
+                if (unlikely(freq_step == 0))
+                        freq_step = 5;
+                requested_freq[cpu] -= freq_step;
+                if (requested_freq[cpu] < policy->min)
+                        requested_freq[cpu] = policy->min;
+                __cpufreq_driver_target(policy,
+                        requested_freq[cpu],
+                        CPUFREQ_RELATION_H);
+                return;
+        }
+}
+static void do_dbs_timer(void *data)
+{ 
+        int i;
+        down(&dbs_sem);
+        for_each_online_cpu(i)
+                dbs_check_cpu(i);
+        schedule_delayed_work(&dbs_work, 
+                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
+        up(&dbs_sem);
+} 
+static inline void dbs_timer_init(void)
+{
+        INIT_WORK(&dbs_work, do_dbs_timer, NULL);
+        schedule_delayed_work(&dbs_work,
+                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
+        return;
+}
+static inline void dbs_timer_exit(void)
+{
+        cancel_delayed_work(&dbs_work);
+        return;
+}
+static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
+                                   unsigned int event)
+{
+        unsigned int cpu = policy->cpu;
+        struct cpu_dbs_info_s *this_dbs_info;
+        unsigned int j;
+        this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
+        switch (event) {
+        case CPUFREQ_GOV_START:
+                if ((!cpu_online(cpu)) || 
+                    (!policy->cur))
+                        return -EINVAL;
+                if (policy->cpuinfo.transition_latency >
+                                (TRANSITION_LATENCY_LIMIT * 1000))
+                        return -EINVAL;
+                if (this_dbs_info->enable) /* Already enabled */
+                        break;
+                 
+                down(&dbs_sem);
+                for_each_cpu_mask(j, policy->cpus) {
+                        struct cpu_dbs_info_s *j_dbs_info;
+                        j_dbs_info = &per_cpu(cpu_dbs_info, j);
+                        j_dbs_info->cur_policy = policy;
+                
+                        j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
+                        j_dbs_info->prev_cpu_idle_down
+                                = j_dbs_info->prev_cpu_idle_up;
+                }
+                this_dbs_info->enable = 1;
+                sysfs_create_group(&policy->kobj, &dbs_attr_group);
+                dbs_enable++;
+                /*
+                 * Start the timerschedule work, when this governor
+                 * is used for first time
+                 */
+                if (dbs_enable == 1) {
+                        unsigned int latency;
+                        /* policy latency is in nS. Convert it to uS first */
+                        latency = policy->cpuinfo.transition_latency;
+                        if (latency < 1000)
+                                latency = 1000;
+                        def_sampling_rate = (latency / 1000) *
+                                        DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
+                        dbs_tuners_ins.sampling_rate = def_sampling_rate;
+                        dbs_tuners_ins.ignore_nice = 0;
+                        dbs_tuners_ins.freq_step = 5;
+                        dbs_timer_init();
+                }
+                
+                up(&dbs_sem);
+                break;
+        case CPUFREQ_GOV_STOP:
+                down(&dbs_sem);
+                this_dbs_info->enable = 0;
+                sysfs_remove_group(&policy->kobj, &dbs_attr_group);
+                dbs_enable--;
+                /*
+                 * Stop the timerschedule work, when this governor
+                 * is used for first time
+                 */
+                if (dbs_enable == 0) 
+                        dbs_timer_exit();
+                
+                up(&dbs_sem);
+                break;
+        case CPUFREQ_GOV_LIMITS:
+                down(&dbs_sem);
+                if (policy->max < this_dbs_info->cur_policy->cur)
+                        __cpufreq_driver_target(
+                                        this_dbs_info->cur_policy,
+                                        policy->max, CPUFREQ_RELATION_H);
+                else if (policy->min > this_dbs_info->cur_policy->cur)
+                        __cpufreq_driver_target(
+                                        this_dbs_info->cur_policy,
+                                        policy->min, CPUFREQ_RELATION_L);
+                up(&dbs_sem);
+                break;
+        }
+        return 0;
+}
+static struct cpufreq_governor cpufreq_gov_dbs = {
+        .name           = "conservative",
+        .governor       = cpufreq_governor_dbs,
+        .owner          = THIS_MODULE,
+};
+static int __init cpufreq_gov_dbs_init(void)
+{
+        return cpufreq_register_governor(&cpufreq_gov_dbs);
+}
+static void __exit cpufreq_gov_dbs_exit(void)
+{
+        /* Make sure that the scheduled work is indeed not running */
+        flush_scheduled_work();
+        cpufreq_unregister_governor(&cpufreq_gov_dbs);
+}
+MODULE_AUTHOR ("Alexander Clouter <alex-kernel@digriz.org.uk>");
+MODULE_DESCRIPTION ("'cpufreq_conservative' - A dynamic cpufreq governor for "
+                "Low Latency Frequency Transition capable processors "
+                "optimised for use in a battery environment");
+MODULE_LICENSE ("GPL");
+module_init(cpufreq_gov_dbs_init);
+module_exit(cpufreq_gov_dbs_exit);
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 8d83a21c6477..c1fc9c62bb51 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -34,13 +34,9 @@
 */
 #define DEF_FREQUENCY_UP_THRESHOLD              (80)
-#define MIN_FREQUENCY_UP_THRESHOLD              (0)
+#define MIN_FREQUENCY_UP_THRESHOLD              (11)
 #define MAX_FREQUENCY_UP_THRESHOLD              (100)
-#define DEF_FREQUENCY_DOWN_THRESHOLD            (20)
-#define MIN_FREQUENCY_DOWN_THRESHOLD            (0)
-#define MAX_FREQUENCY_DOWN_THRESHOLD            (100)
 /* 
 * The polling frequency of this governor depends on the capability of 
 * the processor. Default polling frequency is 1000 times the transition
@@ -55,9 +51,9 @@ static unsigned int 				def_sampling_rate;
 #define MIN_SAMPLING_RATE                       (def_sampling_rate / 2)
 #define MAX_SAMPLING_RATE                       (500 * def_sampling_rate)
 #define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (1000)
-#define DEF_SAMPLING_DOWN_FACTOR                (10)
+#define DEF_SAMPLING_DOWN_FACTOR                (1)
+#define MAX_SAMPLING_DOWN_FACTOR                (10)
 #define TRANSITION_LATENCY_LIMIT                (10 * 1000)
-#define sampling_rate_in_HZ(x)                  (((x * HZ) < (1000 * 1000))?1:((x * HZ) / (1000 * 1000)))
 static void do_dbs_timer(void *data);
@@ -78,15 +74,23 @@ struct dbs_tuners {
        unsigned int            sampling_rate;
        unsigned int            sampling_down_factor;
        unsigned int            up_threshold;
-        unsigned int            down_threshold;
+        unsigned int            ignore_nice;
 };
 static struct dbs_tuners dbs_tuners_ins = {
        .up_threshold           = DEF_FREQUENCY_UP_THRESHOLD,
-        .down_threshold         = DEF_FREQUENCY_DOWN_THRESHOLD,
        .sampling_down_factor   = DEF_SAMPLING_DOWN_FACTOR,
 };
+static inline unsigned int get_cpu_idle_time(unsigned int cpu)
+{
+        return  kstat_cpu(cpu).cpustat.idle +
+                kstat_cpu(cpu).cpustat.iowait +
+                ( !dbs_tuners_ins.ignore_nice ? 
+                  kstat_cpu(cpu).cpustat.nice :
+                  0);
+}
 /************************** sysfs interface ************************/
 static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
 {
@@ -115,7 +119,7 @@ static ssize_t show_##file_name						\
 show_one(sampling_rate, sampling_rate);
 show_one(sampling_down_factor, sampling_down_factor);
 show_one(up_threshold, up_threshold);
-show_one(down_threshold, down_threshold);
+show_one(ignore_nice, ignore_nice);
 static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, 
                const char *buf, size_t count)
@@ -126,6 +130,9 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
        if (ret != 1 )
                return -EINVAL;
+        if (input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
+                return -EINVAL;
        down(&dbs_sem);
        dbs_tuners_ins.sampling_down_factor = input;
        up(&dbs_sem);
@@ -161,8 +168,7 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
        down(&dbs_sem);
        if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || 
-                        input < MIN_FREQUENCY_UP_THRESHOLD ||
+                        input < MIN_FREQUENCY_UP_THRESHOLD) {
-                        input <= dbs_tuners_ins.down_threshold) {
                up(&dbs_sem);
                return -EINVAL;
        }
@@ -173,22 +179,35 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
        return count;
 }
-static ssize_t store_down_threshold(struct cpufreq_policy *unused, 
+static ssize_t store_ignore_nice(struct cpufreq_policy *policy,
                const char *buf, size_t count)
 {
        unsigned int input;
        int ret;
+        unsigned int j;
+        
        ret = sscanf (buf, "%u", &input);
+        if ( ret != 1 )
+                return -EINVAL;
+        if ( input > 1 )
+                input = 1;
+        
        down(&dbs_sem);
-        if (ret != 1 || input > MAX_FREQUENCY_DOWN_THRESHOLD || 
+        if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
-                        input < MIN_FREQUENCY_DOWN_THRESHOLD ||
-                        input >= dbs_tuners_ins.up_threshold) {
                up(&dbs_sem);
-                return -EINVAL;
+                return count;
        }
+        dbs_tuners_ins.ignore_nice = input;
-        dbs_tuners_ins.down_threshold = input;
+        /* we need to re-evaluate prev_cpu_idle_up and prev_cpu_idle_down */
+        for_each_online_cpu(j) {
+                struct cpu_dbs_info_s *j_dbs_info;
+                j_dbs_info = &per_cpu(cpu_dbs_info, j);
+                j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
+                j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
+        }
        up(&dbs_sem);
        return count;
@@ -201,7 +220,7 @@ __ATTR(_name, 0644, show_##_name, store_##_name)
 define_one_rw(sampling_rate);
 define_one_rw(sampling_down_factor);
 define_one_rw(up_threshold);
-define_one_rw(down_threshold);
+define_one_rw(ignore_nice);
 static struct attribute * dbs_attributes[] = {
        &sampling_rate_max.attr,
@@ -209,7 +228,7 @@ static struct attribute * dbs_attributes[] = {
        &sampling_rate.attr,
        &sampling_down_factor.attr,
        &up_threshold.attr,
-        &down_threshold.attr,
+        &ignore_nice.attr,
        NULL
 };
@@ -222,9 +241,8 @@ static struct attribute_group dbs_attr_group = {
 static void dbs_check_cpu(int cpu)
 {
-        unsigned int idle_ticks, up_idle_ticks, down_idle_ticks;
+        unsigned int idle_ticks, up_idle_ticks, total_ticks;
-        unsigned int total_idle_ticks;
+        unsigned int freq_next;
-        unsigned int freq_down_step;
        unsigned int freq_down_sampling_rate;
        static int down_skip[NR_CPUS];
        struct cpu_dbs_info_s *this_dbs_info;
@@ -238,38 +256,25 @@ static void dbs_check_cpu(int cpu)
        policy = this_dbs_info->cur_policy;
        /* 
-         * The default safe range is 20% to 80% 
+         * Every sampling_rate, we check, if current idle time is less
-         * Every sampling_rate, we check
+         * than 20% (default), then we try to increase frequency
-         *      - If current idle time is less than 20%, then we try to 
+         * Every sampling_rate*sampling_down_factor, we look for a the lowest
-         *        increase frequency
+         * frequency which can sustain the load while keeping idle time over
-         * Every sampling_rate*sampling_down_factor, we check
+         * 30%. If such a frequency exist, we try to decrease to this frequency.
-         *      - If current idle time is more than 80%, then we try to
-         *        decrease frequency
         *
         * Any frequency increase takes it to the maximum frequency. 
         * Frequency reduction happens at minimum steps of 
-         * 5% of max_frequency 
+         * 5% (default) of current frequency 
         */
        /* Check for frequency increase */
-        total_idle_ticks = kstat_cpu(cpu).cpustat.idle +
+        idle_ticks = UINT_MAX;
-                kstat_cpu(cpu).cpustat.iowait;
-        idle_ticks = total_idle_ticks -
-                this_dbs_info->prev_cpu_idle_up;
-        this_dbs_info->prev_cpu_idle_up = total_idle_ticks;
-        
        for_each_cpu_mask(j, policy->cpus) {
-                unsigned int tmp_idle_ticks;
+                unsigned int tmp_idle_ticks, total_idle_ticks;
                struct cpu_dbs_info_s *j_dbs_info;
-                if (j == cpu)
-                        continue;
                j_dbs_info = &per_cpu(cpu_dbs_info, j);
-                /* Check for frequency increase */
+                total_idle_ticks = get_cpu_idle_time(j);
-                total_idle_ticks = kstat_cpu(j).cpustat.idle +
-                        kstat_cpu(j).cpustat.iowait;
                tmp_idle_ticks = total_idle_ticks -
                        j_dbs_info->prev_cpu_idle_up;
                j_dbs_info->prev_cpu_idle_up = total_idle_ticks;
@@ -281,13 +286,23 @@ static void dbs_check_cpu(int cpu)
        /* Scale idle ticks by 100 and compare with up and down ticks */
        idle_ticks *= 100;
        up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) *
-                        sampling_rate_in_HZ(dbs_tuners_ins.sampling_rate);
+                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
        if (idle_ticks < up_idle_ticks) {
+                down_skip[cpu] = 0;
+                for_each_cpu_mask(j, policy->cpus) {
+                        struct cpu_dbs_info_s *j_dbs_info;
+                        j_dbs_info = &per_cpu(cpu_dbs_info, j);
+                        j_dbs_info->prev_cpu_idle_down = 
+                                        j_dbs_info->prev_cpu_idle_up;
+                }
+                /* if we are already at full speed then break out early */
+                if (policy->cur == policy->max)
+                        return;
+                
                __cpufreq_driver_target(policy, policy->max, 
                        CPUFREQ_RELATION_H);
-                down_skip[cpu] = 0;
-                this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
                return;
        }
@@ -296,23 +311,14 @@ static void dbs_check_cpu(int cpu)
        if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor)
                return;
-        total_idle_ticks = kstat_cpu(cpu).cpustat.idle +
+        idle_ticks = UINT_MAX;
-                kstat_cpu(cpu).cpustat.iowait;
-        idle_ticks = total_idle_ticks -
-                this_dbs_info->prev_cpu_idle_down;
-        this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
        for_each_cpu_mask(j, policy->cpus) {
-                unsigned int tmp_idle_ticks;
+                unsigned int tmp_idle_ticks, total_idle_ticks;
                struct cpu_dbs_info_s *j_dbs_info;
-                if (j == cpu)
-                        continue;
                j_dbs_info = &per_cpu(cpu_dbs_info, j);
-                /* Check for frequency increase */
+                /* Check for frequency decrease */
-                total_idle_ticks = kstat_cpu(j).cpustat.idle +
+                total_idle_ticks = j_dbs_info->prev_cpu_idle_up;
-                        kstat_cpu(j).cpustat.iowait;
                tmp_idle_ticks = total_idle_ticks -
                        j_dbs_info->prev_cpu_idle_down;
                j_dbs_info->prev_cpu_idle_down = total_idle_ticks;
@@ -321,38 +327,37 @@ static void dbs_check_cpu(int cpu)
                        idle_ticks = tmp_idle_ticks;
        }
-        /* Scale idle ticks by 100 and compare with up and down ticks */
-        idle_ticks *= 100;
        down_skip[cpu] = 0;
+        /* if we cannot reduce the frequency anymore, break out early */
+        if (policy->cur == policy->min)
+                return;
+        /* Compute how many ticks there are between two measurements */
        freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *
                dbs_tuners_ins.sampling_down_factor;
-        down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) *
+        total_ticks = usecs_to_jiffies(freq_down_sampling_rate);
-                        sampling_rate_in_HZ(freq_down_sampling_rate);
-        if (idle_ticks > down_idle_ticks ) {
+        /*
-                freq_down_step = (5 * policy->max) / 100;
+         * The optimal frequency is the frequency that is the lowest that
+         * can support the current CPU usage without triggering the up
-                /* max freq cannot be less than 100. But who knows.... */
+         * policy. To be safe, we focus 10 points under the threshold.
-                if (unlikely(freq_down_step == 0))
+         */
-                        freq_down_step = 5;
+        freq_next = ((total_ticks - idle_ticks) * 100) / total_ticks;
+        freq_next = (freq_next * policy->cur) / 
+                        (dbs_tuners_ins.up_threshold - 10);
-                __cpufreq_driver_target(policy,
+        if (freq_next <= ((policy->cur * 95) / 100))
-                        policy->cur - freq_down_step, 
+                __cpufreq_driver_target(policy, freq_next, CPUFREQ_RELATION_L);
-                        CPUFREQ_RELATION_H);
-                return;
-        }
 }
 static void do_dbs_timer(void *data)
 { 
        int i;
        down(&dbs_sem);
-        for (i = 0; i < NR_CPUS; i++)
+        for_each_online_cpu(i)
-                if (cpu_online(i))
+                dbs_check_cpu(i);
-                        dbs_check_cpu(i);
        schedule_delayed_work(&dbs_work, 
-                        sampling_rate_in_HZ(dbs_tuners_ins.sampling_rate));
+                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
        up(&dbs_sem);
 } 
@@ -360,7 +365,7 @@ static inline void dbs_timer_init(void)
 {
        INIT_WORK(&dbs_work, do_dbs_timer, NULL);
        schedule_delayed_work(&dbs_work,
-                        sampling_rate_in_HZ(dbs_tuners_ins.sampling_rate));
+                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
        return;
 }
@@ -397,12 +402,9 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                        j_dbs_info = &per_cpu(cpu_dbs_info, j);
                        j_dbs_info->cur_policy = policy;
                
-                        j_dbs_info->prev_cpu_idle_up = 
+                        j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
-                                kstat_cpu(j).cpustat.idle +
+                        j_dbs_info->prev_cpu_idle_down
-                                kstat_cpu(j).cpustat.iowait;
+                                = j_dbs_info->prev_cpu_idle_up;
-                        j_dbs_info->prev_cpu_idle_down = 
-                                kstat_cpu(j).cpustat.idle +
-                                kstat_cpu(j).cpustat.iowait;
                }
                this_dbs_info->enable = 1;
                sysfs_create_group(&policy->kobj, &dbs_attr_group);
@@ -422,6 +424,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                        def_sampling_rate = (latency / 1000) *
                                        DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
                        dbs_tuners_ins.sampling_rate = def_sampling_rate;
+                        dbs_tuners_ins.ignore_nice = 0;
                        dbs_timer_init();
                }
@@ -461,12 +464,11 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
        return 0;
 }
-struct cpufreq_governor cpufreq_gov_dbs = {
+static struct cpufreq_governor cpufreq_gov_dbs = {
        .name           = "ondemand",
        .governor       = cpufreq_governor_dbs,
        .owner          = THIS_MODULE,
 };
-EXPORT_SYMBOL(cpufreq_gov_dbs);
 static int __init cpufreq_gov_dbs_init(void)
 {
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index 2084593937c6..741b6b191e6a 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -19,6 +19,7 @@
 #include <linux/percpu.h>
 #include <linux/kobject.h>
 #include <linux/spinlock.h>
+#include <asm/cputime.h>
 static spinlock_t cpufreq_stats_lock;
@@ -29,20 +30,14 @@ static struct freq_attr _attr_##_name = {\
        .show = _show,\
 };
-static unsigned long
-delta_time(unsigned long old, unsigned long new)
-{
-        return (old > new) ? (old - new): (new + ~old + 1);
-}
 struct cpufreq_stats {
        unsigned int cpu;
        unsigned int total_trans;
-        unsigned long long last_time;
+        unsigned long long  last_time;
        unsigned int max_state;
        unsigned int state_num;
        unsigned int last_index;
-        unsigned long long *time_in_state;
+        cputime64_t *time_in_state;
        unsigned int *freq_table;
 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS
        unsigned int *trans_table;
@@ -60,12 +55,16 @@ static int
 cpufreq_stats_update (unsigned int cpu)
 {
        struct cpufreq_stats *stat;
+        unsigned long long cur_time;
+        cur_time = get_jiffies_64();
        spin_lock(&cpufreq_stats_lock);
        stat = cpufreq_stats_table[cpu];
        if (stat->time_in_state)
-                stat->time_in_state[stat->last_index] +=
+                stat->time_in_state[stat->last_index] =
-                        delta_time(stat->last_time, jiffies);
+                        cputime64_add(stat->time_in_state[stat->last_index],
-        stat->last_time = jiffies;
+                                      cputime_sub(cur_time, stat->last_time));
+        stat->last_time = cur_time;
        spin_unlock(&cpufreq_stats_lock);
        return 0;
 }
@@ -90,8 +89,8 @@ show_time_in_state(struct cpufreq_policy *policy, char *buf)
                return 0;
        cpufreq_stats_update(stat->cpu);
        for (i = 0; i < stat->state_num; i++) {
-                len += sprintf(buf + len, "%u %llu\n",
+                len += sprintf(buf + len, "%u %llu\n", stat->freq_table[i], 
-                        stat->freq_table[i], stat->time_in_state[i]);
+                        (unsigned long long)cputime64_to_clock_t(stat->time_in_state[i]));
        }
        return len;
 }
@@ -107,16 +106,30 @@ show_trans_table(struct cpufreq_policy *policy, char *buf)
        if(!stat)
                return 0;
        cpufreq_stats_update(stat->cpu);
+        len += snprintf(buf + len, PAGE_SIZE - len, "   From  :    To\n");
+        len += snprintf(buf + len, PAGE_SIZE - len, "         : ");
+        for (i = 0; i < stat->state_num; i++) {
+                if (len >= PAGE_SIZE)
+                        break;
+                len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
+                                stat->freq_table[i]);
+        }
+        if (len >= PAGE_SIZE)
+                return len;
+        len += snprintf(buf + len, PAGE_SIZE - len, "\n");
        for (i = 0; i < stat->state_num; i++) {
                if (len >= PAGE_SIZE)
                        break;
-                len += snprintf(buf + len, PAGE_SIZE - len, "%9u:\t",
+                len += snprintf(buf + len, PAGE_SIZE - len, "%9u: ",
                                stat->freq_table[i]);
                for (j = 0; j < stat->state_num; j++)   {
                        if (len >= PAGE_SIZE)
                                break;
-                        len += snprintf(buf + len, PAGE_SIZE - len, "%u\t",
+                        len += snprintf(buf + len, PAGE_SIZE - len, "%9u ",
                                        stat->trans_table[i*stat->max_state+j]);
                }
                len += snprintf(buf + len, PAGE_SIZE - len, "\n");
@@ -197,7 +210,7 @@ cpufreq_stats_create_table (struct cpufreq_policy *policy,
                count++;
        }
-        alloc_size = count * sizeof(int) + count * sizeof(long long);
+        alloc_size = count * sizeof(int) + count * sizeof(cputime64_t);
 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS
        alloc_size += count * count * sizeof(int);
@@ -224,7 +237,7 @@ cpufreq_stats_create_table (struct cpufreq_policy *policy,
        }
        stat->state_num = j;
        spin_lock(&cpufreq_stats_lock);
-        stat->last_time = jiffies;
+        stat->last_time = get_jiffies_64();
        stat->last_index = freq_table_get_index(stat, policy->cur);
        spin_unlock(&cpufreq_stats_lock);
        cpufreq_cpu_put(data);
diff --git a/drivers/firmware/pcdp.c b/drivers/firmware/pcdp.c
index 6d5df6c2efa2..df1b721154d2 100644
--- a/drivers/firmware/pcdp.c
+++ b/drivers/firmware/pcdp.c
@@ -11,6 +11,7 @@
 * published by the Free Software Foundation.
 */
+#include <linux/config.h>
 #include <linux/acpi.h>
 #include <linux/console.h>
 #include <linux/efi.h>
diff --git a/drivers/i2c/busses/i2c-ali1563.c b/drivers/i2c/busses/i2c-ali1563.c
index 35710818fe47..fdd881aee618 100644
--- a/drivers/i2c/busses/i2c-ali1563.c
+++ b/drivers/i2c/busses/i2c-ali1563.c
@@ -2,6 +2,7 @@
 *      i2c-ali1563.c - i2c driver for the ALi 1563 Southbridge
 *
 *      Copyright (C) 2004 Patrick Mochel
+ *                    2005 Rudolf Marek <r.marek@sh.cvut.cz>
 *
 *      The 1563 southbridge is deceptively similar to the 1533, with a
 *      few notable exceptions. One of those happens to be the fact they
@@ -57,10 +58,11 @@
 #define HST_CNTL2_BLOCK         0x05
+#define HST_CNTL2_SIZEMASK      0x38
 static unsigned short ali1563_smba;
-static int ali1563_transaction(struct i2c_adapter * a)
+static int ali1563_transaction(struct i2c_adapter * a, int size)
 {
        u32 data;
        int timeout;
@@ -73,7 +75,7 @@ static int ali1563_transaction(struct i2c_adapter * a)
        data = inb_p(SMB_HST_STS);
        if (data & HST_STS_BAD) {
-                dev_warn(&a->dev,"ali1563: Trying to reset busy device\n");
+                dev_err(&a->dev, "ali1563: Trying to reset busy device\n");
                outb_p(data | HST_STS_BAD,SMB_HST_STS);
                data = inb_p(SMB_HST_STS);
                if (data & HST_STS_BAD)
@@ -94,19 +96,31 @@ static int ali1563_transaction(struct i2c_adapter * a)
        if (timeout && !(data & HST_STS_BAD))
                return 0;
-        dev_warn(&a->dev, "SMBus Error: %s%s%s%s%s\n",
-                timeout ? "Timeout " : "",
-                data & HST_STS_FAIL ? "Transaction Failed " : "",
-                data & HST_STS_BUSERR ? "No response or Bus Collision " : "",
-                data & HST_STS_DEVERR ? "Device Error " : "",
-                !(data & HST_STS_DONE) ? "Transaction Never Finished " : "");
-        if (!(data & HST_STS_DONE))
+        if (!timeout) {
+                dev_err(&a->dev, "Timeout - Trying to KILL transaction!\n");
                /* Issue 'kill' to host controller */
                outb_p(HST_CNTL2_KILL,SMB_HST_CNTL2);
-        else
+                data = inb_p(SMB_HST_STS);
-                /* Issue timeout to reset all devices on bus */
+        }
+        /* device error - no response, ignore the autodetection case */
+        if ((data & HST_STS_DEVERR) && (size != HST_CNTL2_QUICK)) {
+                dev_err(&a->dev, "Device error!\n");
+        }
+        /* bus collision */
+        if (data & HST_STS_BUSERR) {
+                dev_err(&a->dev, "Bus collision!\n");
+                /* Issue timeout, hoping it helps */
                outb_p(HST_CNTL1_TIMEOUT,SMB_HST_CNTL1);
+        }
+        if (data & HST_STS_FAIL) {
+                dev_err(&a->dev, "Cleaning fail after KILL!\n");
+                outb_p(0x0,SMB_HST_CNTL2);
+        }
        return -1;
 }
@@ -149,7 +163,7 @@ static int ali1563_block_start(struct i2c_adapter * a)
        if (timeout && !(data & HST_STS_BAD))
                return 0;
-        dev_warn(&a->dev, "SMBus Error: %s%s%s%s%s\n",
+        dev_err(&a->dev, "SMBus Error: %s%s%s%s%s\n",
                timeout ? "Timeout " : "",
                data & HST_STS_FAIL ? "Transaction Failed " : "",
                data & HST_STS_BUSERR ? "No response or Bus Collision " : "",
@@ -242,13 +256,15 @@ static s32 ali1563_access(struct i2c_adapter * a, u16 addr,
        }
        outb_p(((addr & 0x7f) << 1) | (rw & 0x01), SMB_HST_ADD);
-        outb_p(inb_p(SMB_HST_CNTL2) | (size << 3), SMB_HST_CNTL2);
+        outb_p((inb_p(SMB_HST_CNTL2) & ~HST_CNTL2_SIZEMASK) | (size << 3), SMB_HST_CNTL2);
        /* Write the command register */
        switch(size) {
        case HST_CNTL2_BYTE:
                if (rw== I2C_SMBUS_WRITE)
-                        outb_p(cmd, SMB_HST_CMD);
+                        /* Beware it uses DAT0 register and not CMD! */
+                        outb_p(cmd, SMB_HST_DAT0);
                break;
        case HST_CNTL2_BYTE_DATA:
                outb_p(cmd, SMB_HST_CMD);
@@ -268,7 +284,7 @@ static s32 ali1563_access(struct i2c_adapter * a, u16 addr,
                goto Done;
        }
-        if ((error = ali1563_transaction(a)))
+        if ((error = ali1563_transaction(a, size)))
                goto Done;
        if ((rw == I2C_SMBUS_WRITE) || (size == HST_CNTL2_QUICK))
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 78e3e7b24d7d..39f3e9101ed4 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -1936,7 +1936,7 @@ static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
                 * NOTE! The "len" and "addr" checks should possibly have
                 * separate masks.
                 */
-                if ((rq->data_len & mask) || (addr & mask))
+                if ((rq->data_len & 15) || (addr & mask))
                        info->dma = 0;
        }
diff --git a/drivers/ide/pci/amd74xx.c b/drivers/ide/pci/amd74xx.c
index 47225e324356..4e0f13d1d060 100644
--- a/drivers/ide/pci/amd74xx.c
+++ b/drivers/ide/pci/amd74xx.c
@@ -72,6 +72,7 @@ static struct amd_ide_chip {
        { PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2,  0x50, AMD_UDMA_133 },
        { PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE,        0x50, AMD_UDMA_133 },
        { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE,        0x50, AMD_UDMA_133 },
+        { PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE,        0x50, AMD_UDMA_133 },
        { 0 }
 };
@@ -487,6 +488,7 @@ static ide_pci_device_t amd74xx_chipsets[] __devinitdata = {
        /* 12 */ DECLARE_NV_DEV("NFORCE3-250-SATA2"),
        /* 13 */ DECLARE_NV_DEV("NFORCE-CK804"),
        /* 14 */ DECLARE_NV_DEV("NFORCE-MCP04"),
+        /* 15 */ DECLARE_NV_DEV("NFORCE-MCP51"),
 };
 static int __devinit amd74xx_probe(struct pci_dev *dev, const struct pci_device_id *id)
@@ -521,6 +523,7 @@ static struct pci_device_id amd74xx_pci_tbl[] = {
 #endif
        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 13 },
        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 14 },
+        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 15 },
        { 0, },
 };
 MODULE_DEVICE_TABLE(pci, amd74xx_pci_tbl);
diff --git a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
index af0446c6de82..48fdf1e517cf 100644
--- a/drivers/input/keyboard/atkbd.c
+++ b/drivers/input/keyboard/atkbd.c
@@ -54,7 +54,7 @@ static int atkbd_softraw = 1;
 module_param_named(softraw, atkbd_softraw, bool, 0);
 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
-static int atkbd_scroll = 1;
+static int atkbd_scroll = 0;
 module_param_named(scroll, atkbd_scroll, bool, 0);
 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
diff --git a/drivers/net/hamradio/baycom_epp.c b/drivers/net/hamradio/baycom_epp.c
index 1c563f905a59..a7f15d9f13e5 100644
--- a/drivers/net/hamradio/baycom_epp.c
+++ b/drivers/net/hamradio/baycom_epp.c
@@ -374,29 +374,6 @@ static inline void do_kiss_params(struct baycom_state *bc,
 }
 /* --------------------------------------------------------------------- */
-/*
- * high performance HDLC encoder
- * yes, it's ugly, but generates pretty good code
- */
-#define ENCODEITERA(j)                         \
-({                                             \
-        if (!(notbitstream & (0x1f0 << j)))    \
-                goto stuff##j;                 \
-  encodeend##j:         ;                      \
-})
-#define ENCODEITERB(j)                                          \
-({                                                              \
-  stuff##j:                                                     \
-        bitstream &= ~(0x100 << j);                             \
-        bitbuf = (bitbuf & (((2 << j) << numbit) - 1)) |        \
-                ((bitbuf & ~(((2 << j) << numbit) - 1)) << 1);  \
-        numbit++;                                               \
-        notbitstream = ~bitstream;                              \
-        goto encodeend##j;                                      \
-})
 static void encode_hdlc(struct baycom_state *bc)
 {
@@ -405,6 +382,7 @@ static void encode_hdlc(struct baycom_state *bc)
        int pkt_len;
        unsigned bitstream, notbitstream, bitbuf, numbit, crc;
        unsigned char crcarr[2];
+        int j;
        
        if (bc->hdlctx.bufcnt > 0)
                return;
@@ -429,24 +407,14 @@ static void encode_hdlc(struct baycom_state *bc)
                pkt_len--;
                if (!pkt_len)
                        bp = crcarr;
-                ENCODEITERA(0);
+                for (j = 0; j < 8; j++)
-                ENCODEITERA(1);
+                        if (unlikely(!(notbitstream & (0x1f0 << j)))) {
-                ENCODEITERA(2);
+                                bitstream &= ~(0x100 << j);
-                ENCODEITERA(3);
+                                bitbuf = (bitbuf & (((2 << j) << numbit) - 1)) |
-                ENCODEITERA(4);
+                                        ((bitbuf & ~(((2 << j) << numbit) - 1)) << 1);
-                ENCODEITERA(5);
+                                numbit++;
-                ENCODEITERA(6);
+                                notbitstream = ~bitstream;
-                ENCODEITERA(7);
+                        }
-                goto enditer;
-                ENCODEITERB(0);
-                ENCODEITERB(1);
-                ENCODEITERB(2);
-                ENCODEITERB(3);
-                ENCODEITERB(4);
-                ENCODEITERB(5);
-                ENCODEITERB(6);
-                ENCODEITERB(7);
-        enditer:
                numbit += 8;
                while (numbit >= 8) {
                        *wp++ = bitbuf;
@@ -610,37 +578,6 @@ static void do_rxpacket(struct net_device *dev)
        bc->stats.rx_packets++;
 }
-#define DECODEITERA(j)                                                        \
-({                                                                            \
-        if (!(notbitstream & (0x0fc << j)))              /* flag or abort */  \
-                goto flgabrt##j;                                              \
-        if ((bitstream & (0x1f8 << j)) == (0xf8 << j))   /* stuffed bit */    \
-                goto stuff##j;                                                \
-  enditer##j:      ;                                                           \
-})
-#define DECODEITERB(j)                                                                 \
-({                                                                                     \
-  flgabrt##j:                                                                          \
-        if (!(notbitstream & (0x1fc << j))) {              /* abort received */        \
-                state = 0;                                                             \
-                goto enditer##j;                                                       \
-        }                                                                              \
-        if ((bitstream & (0x1fe << j)) != (0x0fc << j))   /* flag received */          \
-                goto enditer##j;                                                       \
-        if (state)                                                                     \
-                do_rxpacket(dev);                                                      \
-        bc->hdlcrx.bufcnt = 0;                                                         \
-        bc->hdlcrx.bufptr = bc->hdlcrx.buf;                                            \
-        state = 1;                                                                     \
-        numbits = 7-j;                                                                 \
-        goto enditer##j;                                                               \
-  stuff##j:                                                                            \
-        numbits--;                                                                     \
-        bitbuf = (bitbuf & ((~0xff) << j)) | ((bitbuf & ~((~0xff) << j)) << 1);        \
-        goto enditer##j;                                                               \
-})
-        
 static int receive(struct net_device *dev, int cnt)
 {
        struct baycom_state *bc = netdev_priv(dev);
@@ -649,6 +586,7 @@ static int receive(struct net_device *dev, int cnt)
        unsigned char tmp[128];
        unsigned char *cp;
        int cnt2, ret = 0;
+        int j;
        
        numbits = bc->hdlcrx.numbits;
        state = bc->hdlcrx.state;
@@ -669,24 +607,32 @@ static int receive(struct net_device *dev, int cnt)
                        bitbuf |= (*cp) << 8;
                        numbits += 8;
                        notbitstream = ~bitstream;
-                        DECODEITERA(0);
+                        for (j = 0; j < 8; j++) {
-                        DECODEITERA(1);
-                        DECODEITERA(2);
+                                /* flag or abort */
-                        DECODEITERA(3);
+                                if (unlikely(!(notbitstream & (0x0fc << j)))) {
-                        DECODEITERA(4);
-                        DECODEITERA(5);
+                                        /* abort received */
-                        DECODEITERA(6);
+                                        if (!(notbitstream & (0x1fc << j)))
-                        DECODEITERA(7);
+                                                state = 0;
-                        goto enddec;
-                        DECODEITERB(0);
+                                        /* not flag received */
-                        DECODEITERB(1);
+                                        else if (!(bitstream & (0x1fe << j)) != (0x0fc << j)) {
-                        DECODEITERB(2);
+                                                if (state)
-                        DECODEITERB(3);
+                                                        do_rxpacket(dev);
-                        DECODEITERB(4);
+                                                bc->hdlcrx.bufcnt = 0;
-                        DECODEITERB(5);
+                                                bc->hdlcrx.bufptr = bc->hdlcrx.buf;
-                        DECODEITERB(6);
+                                                state = 1;
-                        DECODEITERB(7);
+                                                numbits = 7-j;
-                enddec:
+                                                }
+                                        }
+                                /* stuffed bit */
+                                else if (unlikely((bitstream & (0x1f8 << j)) == (0xf8 << j))) {
+                                        numbits--;
+                                        bitbuf = (bitbuf & ((~0xff) << j)) | ((bitbuf & ~((~0xff) << j)) << 1);
+                                        }
+                                }
                        while (state && numbits >= 8) {
                                if (bc->hdlcrx.bufcnt >= TXBUFFER_SIZE) {
                                        state = 0;
diff --git a/drivers/net/pcmcia/3c574_cs.c b/drivers/net/pcmcia/3c574_cs.c
index 41e517114807..c6e8b25f9685 100644
--- a/drivers/net/pcmcia/3c574_cs.c
+++ b/drivers/net/pcmcia/3c574_cs.c
@@ -1274,6 +1274,9 @@ static int el3_close(struct net_device *dev)
                spin_lock_irqsave(&lp->window_lock, flags);
                update_stats(dev);
                spin_unlock_irqrestore(&lp->window_lock, flags);
+                /* force interrupts off */
+                outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
        }
        link->open--;
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index c59507f8a76b..b3768d844747 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -1585,8 +1585,8 @@ rtl8169_hw_start(struct net_device *dev)
        RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
        RTL_W8(EarlyTxThres, EarlyTxThld);
-        /* For gigabit rtl8169, MTU + header + CRC + VLAN */
+        /* Low hurts. Let's disable the filtering. */
-        RTL_W16(RxMaxSize, tp->rx_buf_sz);
+        RTL_W16(RxMaxSize, 16383);
        /* Set Rx Config register */
        i = rtl8169_rx_config |
@@ -2127,6 +2127,11 @@ rtl8169_tx_interrupt(struct net_device *dev, struct rtl8169_private *tp,
        }
 }
+static inline int rtl8169_fragmented_frame(u32 status)
+{
+        return (status & (FirstFrag | LastFrag)) != (FirstFrag | LastFrag);
+}
 static inline void rtl8169_rx_csum(struct sk_buff *skb, struct RxDesc *desc)
 {
        u32 opts1 = le32_to_cpu(desc->opts1);
@@ -2177,27 +2182,41 @@ rtl8169_rx_interrupt(struct net_device *dev, struct rtl8169_private *tp,
        while (rx_left > 0) {
                unsigned int entry = cur_rx % NUM_RX_DESC;
+                struct RxDesc *desc = tp->RxDescArray + entry;
                u32 status;
                rmb();
-                status = le32_to_cpu(tp->RxDescArray[entry].opts1);
+                status = le32_to_cpu(desc->opts1);
                if (status & DescOwn)
                        break;
                if (status & RxRES) {
-                        printk(KERN_INFO "%s: Rx ERROR!!!\n", dev->name);
+                        printk(KERN_INFO "%s: Rx ERROR. status = %08x\n",
+                               dev->name, status);
                        tp->stats.rx_errors++;
                        if (status & (RxRWT | RxRUNT))
                                tp->stats.rx_length_errors++;
                        if (status & RxCRC)
                                tp->stats.rx_crc_errors++;
+                        rtl8169_mark_to_asic(desc, tp->rx_buf_sz);
                } else {
-                        struct RxDesc *desc = tp->RxDescArray + entry;
                        struct sk_buff *skb = tp->Rx_skbuff[entry];
                        int pkt_size = (status & 0x00001FFF) - 4;
                        void (*pci_action)(struct pci_dev *, dma_addr_t,
                                size_t, int) = pci_dma_sync_single_for_device;
+                        /*
+                         * The driver does not support incoming fragmented
+                         * frames. They are seen as a symptom of over-mtu
+                         * sized frames.
+                         */
+                        if (unlikely(rtl8169_fragmented_frame(status))) {
+                                tp->stats.rx_dropped++;
+                                tp->stats.rx_length_errors++;
+                                rtl8169_mark_to_asic(desc, tp->rx_buf_sz);
+                                goto move_on;
+                        }
                        rtl8169_rx_csum(skb, desc);
                        
                        pci_dma_sync_single_for_cpu(tp->pci_dev,
@@ -2224,7 +2243,7 @@ rtl8169_rx_interrupt(struct net_device *dev, struct rtl8169_private *tp,
                        tp->stats.rx_bytes += pkt_size;
                        tp->stats.rx_packets++;
                }
-                
+move_on:                
                cur_rx++; 
                rx_left--;
        }
diff --git a/drivers/net/shaper.c b/drivers/net/shaper.c
index e68cf5fb4920..20edeb345792 100644
--- a/drivers/net/shaper.c
+++ b/drivers/net/shaper.c
@@ -100,35 +100,8 @@ static int sh_debug;		/* Debug flag */
 #define SHAPER_BANNER   "CymruNet Traffic Shaper BETA 0.04 for Linux 2.1\n"
-/*
- *      Locking
- */
- 
-static int shaper_lock(struct shaper *sh)
-{
-        /*
-         *      Lock in an interrupt must fail
-         */
-        while (test_and_set_bit(0, &sh->locked))
-        {
-                if (!in_interrupt())
-                        sleep_on(&sh->wait_queue);
-                else
-                        return 0;
-                        
-        }
-        return 1;
-}
 static void shaper_kick(struct shaper *sh);
-static void shaper_unlock(struct shaper *sh)
-{
-        clear_bit(0, &sh->locked);
-        wake_up(&sh->wait_queue);
-        shaper_kick(sh);
-}
 /*
 *      Compute clocks on a buffer
 */
@@ -157,17 +130,15 @@ static void shaper_setspeed(struct shaper *shaper, int bitspersec)
 *      Throw a frame at a shaper.
 */
  
-static int shaper_qframe(struct shaper *shaper, struct sk_buff *skb)
+static int shaper_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
+        struct shaper *shaper = dev->priv;
        struct sk_buff *ptr;
   
-        /*
+        if (down_trylock(&shaper->sem))
-         *      Get ready to work on this shaper. Lock may fail if its
+                return -1;
-         *      an interrupt and locked.
-         */
-         
-        if(!shaper_lock(shaper))
-                return -1;
        ptr=shaper->sendq.prev;
        
        /*
@@ -260,7 +231,8 @@ static int shaper_qframe(struct shaper *shaper, struct sk_buff *skb)
                dev_kfree_skb(ptr);
                shaper->stats.collisions++;
        }
-        shaper_unlock(shaper);
+        shaper_kick(shaper);
+        up(&shaper->sem);
        return 0;
 }
@@ -297,8 +269,13 @@ static void shaper_queue_xmit(struct shaper *shaper, struct sk_buff *skb)
 
 static void shaper_timer(unsigned long data)
 {
-        struct shaper *sh=(struct shaper *)data;
+        struct shaper *shaper = (struct shaper *)data;
-        shaper_kick(sh);
+        if (!down_trylock(&shaper->sem)) {
+                shaper_kick(shaper);
+                up(&shaper->sem);
+        } else
+                mod_timer(&shaper->timer, jiffies);
 }
 /*
@@ -311,19 +288,6 @@ static void shaper_kick(struct shaper *shaper)
        struct sk_buff *skb;
        
        /*
-         *      Shaper unlock will kick
-         */
-         
-        if (test_and_set_bit(0, &shaper->locked))
-        {
-                if(sh_debug)
-                        printk("Shaper locked.\n");
-                mod_timer(&shaper->timer, jiffies);
-                return;
-        }
-                
-        /*
         *      Walk the list (may be empty)
         */
         
@@ -364,8 +328,6 @@ static void shaper_kick(struct shaper *shaper)
         
        if(skb!=NULL)
                mod_timer(&shaper->timer, SHAPERCB(skb)->shapeclock);
-        clear_bit(0, &shaper->locked);
 }
@@ -376,14 +338,12 @@ static void shaper_kick(struct shaper *shaper)
 static void shaper_flush(struct shaper *shaper)
 {
        struct sk_buff *skb;
-        if(!shaper_lock(shaper))
-        {
+        down(&shaper->sem);
-                printk(KERN_ERR "shaper: shaper_flush() called by an irq!\n");
-                return;
-        }
        while((skb=skb_dequeue(&shaper->sendq))!=NULL)
                dev_kfree_skb(skb);
-        shaper_unlock(shaper);
+        shaper_kick(shaper);
+        up(&shaper->sem);
 }
 /*
@@ -426,13 +386,6 @@ static int shaper_close(struct net_device *dev)
 *      ARP and other resolutions and not before.
 */
-static int shaper_start_xmit(struct sk_buff *skb, struct net_device *dev)
-{
-        struct shaper *sh=dev->priv;
-        return shaper_qframe(sh, skb);
-}
 static struct net_device_stats *shaper_get_stats(struct net_device *dev)
 {
        struct shaper *sh=dev->priv;
@@ -623,7 +576,6 @@ static void shaper_init_priv(struct net_device *dev)
        init_timer(&sh->timer);
        sh->timer.function=shaper_timer;
        sh->timer.data=(unsigned long)sh;
-        init_waitqueue_head(&sh->wait_queue);
 }
 /*
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index fc9b5cd957aa..e944aac258e3 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -7,7 +7,12 @@
 * Copyright (C) 2005 Broadcom Corporation.
 *
 * Firmware is:
- *      Copyright (C) 2000-2003 Broadcom Corporation.
+ *      Derived from proprietary unpublished source code,
+ *      Copyright (C) 2000-2003 Broadcom Corporation.
+ *
+ *      Permission is hereby granted for the distribution of this firmware
+ *      data in hexadecimal or equivalent format, provided this copyright
+ *      notice is accompanying it.
 */
 #include <linux/config.h>
@@ -61,8 +66,8 @@
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.29"
+#define DRV_MODULE_VERSION      "3.30"
-#define DRV_MODULE_RELDATE      "May 23, 2005"
+#define DRV_MODULE_RELDATE      "June 6, 2005"
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -8555,6 +8560,16 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
                case NIC_SRAM_DATA_CFG_LED_MODE_MAC:
                        tp->led_ctrl = LED_CTRL_MODE_MAC;
+                        /* Default to PHY_1_MODE if 0 (MAC_MODE) is
+                         * read on some older 5700/5701 bootcode.
+                         */
+                        if (GET_ASIC_REV(tp->pci_chip_rev_id) ==
+                            ASIC_REV_5700 ||
+                            GET_ASIC_REV(tp->pci_chip_rev_id) ==
+                            ASIC_REV_5701)
+                                tp->led_ctrl = LED_CTRL_MODE_PHY_1;
                        break;
                case SHASTA_EXT_LED_SHARED:
diff --git a/drivers/pci/hotplug/cpci_hotplug_core.c b/drivers/pci/hotplug/cpci_hotplug_core.c
index 9e9dab7fe86a..8132d946c384 100644
--- a/drivers/pci/hotplug/cpci_hotplug_core.c
+++ b/drivers/pci/hotplug/cpci_hotplug_core.c
@@ -1,7 +1,7 @@
 /*
 * CompactPCI Hot Plug Driver
 *
- * Copyright (C) 2002 SOMA Networks, Inc.
+ * Copyright (C) 2002,2005 SOMA Networks, Inc.
 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
 * Copyright (C) 2001 IBM Corp.
 *
@@ -45,10 +45,10 @@
 #define dbg(format, arg...)                                     \
        do {                                                    \
-                if(cpci_debug)                                  \
+                if (cpci_debug)                                 \
                        printk (KERN_DEBUG "%s: " format "\n",  \
                                MY_NAME , ## arg);              \
-        } while(0)
+        } while (0)
 #define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg)
 #define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
@@ -111,10 +111,8 @@ enable_slot(struct hotplug_slot *hotplug_slot)
        dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name);
-        if(controller->ops->set_power) {
+        if (controller->ops->set_power)
                retval = controller->ops->set_power(slot, 1);
-        }
        return retval;
 }
@@ -126,37 +124,41 @@ disable_slot(struct hotplug_slot *hotplug_slot)
        dbg("%s - physical_slot = %s", __FUNCTION__, hotplug_slot->name);
+        down_write(&list_rwsem);
        /* Unconfigure device */
        dbg("%s - unconfiguring slot %s",
            __FUNCTION__, slot->hotplug_slot->name);
-        if((retval = cpci_unconfigure_slot(slot))) {
+        if ((retval = cpci_unconfigure_slot(slot))) {
                err("%s - could not unconfigure slot %s",
                    __FUNCTION__, slot->hotplug_slot->name);
-                return retval;
+                goto disable_error;
        }
        dbg("%s - finished unconfiguring slot %s",
            __FUNCTION__, slot->hotplug_slot->name);
        /* Clear EXT (by setting it) */
-        if(cpci_clear_ext(slot)) {
+        if (cpci_clear_ext(slot)) {
                err("%s - could not clear EXT for slot %s",
                    __FUNCTION__, slot->hotplug_slot->name);
                retval = -ENODEV;
+                goto disable_error;
        }
        cpci_led_on(slot);
-        if(controller->ops->set_power) {
+        if (controller->ops->set_power)
-                retval = controller->ops->set_power(slot, 0);
+                if ((retval = controller->ops->set_power(slot, 0)))
-        }
+                        goto disable_error;
-        if(update_adapter_status(slot->hotplug_slot, 0)) {
+        if (update_adapter_status(slot->hotplug_slot, 0))
                warn("failure to update adapter file");
-        }
-        if(slot->extracting) {
+        if (slot->extracting) {
                slot->extracting = 0;
                atomic_dec(&extracting);
        }
+disable_error:
+        up_write(&list_rwsem);
        return retval;
 }
@@ -165,9 +167,8 @@ cpci_get_power_status(struct slot *slot)
 {
        u8 power = 1;
-        if(controller->ops->get_power) {
+        if (controller->ops->get_power)
                power = controller->ops->get_power(slot);
-        }
        return power;
 }
@@ -237,9 +238,8 @@ cpci_hp_register_bus(struct pci_bus *bus, u8 first, u8 last)
        int status = -ENOMEM;
        int i;
-        if(!(controller && bus)) {
+        if (!(controller && bus))
                return -ENODEV;
-        }
        /*
         * Create a structure for each slot, and register that slot
@@ -316,32 +316,30 @@ int
 cpci_hp_unregister_bus(struct pci_bus *bus)
 {
        struct slot *slot;
-        struct list_head *tmp;
+        struct slot *tmp;
-        struct list_head *next;
+        int status = 0;
-        int status;
        down_write(&list_rwsem);
-        if(!slots) {
+        if (!slots) {
                up_write(&list_rwsem);
                return -1;
        }
-        list_for_each_safe(tmp, next, &slot_list) {
+        list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
-                slot = list_entry(tmp, struct slot, slot_list);
+                if (slot->bus == bus) {
-                if(slot->bus == bus) {
+                        list_del(&slot->slot_list);
+                        slots--;
                        dbg("deregistering slot %s", slot->hotplug_slot->name);
                        status = pci_hp_deregister(slot->hotplug_slot);
-                        if(status) {
+                        if (status) {
                                err("pci_hp_deregister failed with error %d",
                                    status);
-                                return status;
+                                break;
                        }
-                        list_del(&slot->slot_list);
-                        slots--;
                }
        }
        up_write(&list_rwsem);
-        return 0;
+        return status;
 }
 /* This is the interrupt mode interrupt handler */
@@ -351,7 +349,7 @@ cpci_hp_intr(int irq, void *data, struct pt_regs *regs)
        dbg("entered cpci_hp_intr");
        /* Check to see if it was our interrupt */
-        if((controller->irq_flags & SA_SHIRQ) &&
+        if ((controller->irq_flags & SA_SHIRQ) &&
            !controller->ops->check_irq(controller->dev_id)) {
                dbg("exited cpci_hp_intr, not our interrupt");
                return IRQ_NONE;
@@ -373,38 +371,30 @@ cpci_hp_intr(int irq, void *data, struct pt_regs *regs)
 * INS bits of the cold-inserted devices.
 */
 static int
-init_slots(void)
+init_slots(int clear_ins)
 {
        struct slot *slot;
-        struct list_head *tmp;
        struct pci_dev* dev;
        dbg("%s - enter", __FUNCTION__);
        down_read(&list_rwsem);
-        if(!slots) {
+        if (!slots) {
                up_read(&list_rwsem);
                return -1;
        }
-        list_for_each(tmp, &slot_list) {
+        list_for_each_entry(slot, &slot_list, slot_list) {
-                slot = list_entry(tmp, struct slot, slot_list);
                dbg("%s - looking at slot %s",
                    __FUNCTION__, slot->hotplug_slot->name);
-                if(cpci_check_and_clear_ins(slot)) {
+                if (clear_ins && cpci_check_and_clear_ins(slot))
                        dbg("%s - cleared INS for slot %s",
                            __FUNCTION__, slot->hotplug_slot->name);
-                        dev = pci_find_slot(slot->bus->number, PCI_DEVFN(slot->number, 0));
+                dev = pci_get_slot(slot->bus, PCI_DEVFN(slot->number, 0));
-                        if(dev) {
+                if (dev) {
-                                if(update_adapter_status(slot->hotplug_slot, 1)) {
+                        if (update_adapter_status(slot->hotplug_slot, 1))
-                                        warn("failure to update adapter file");
+                                warn("failure to update adapter file");
-                                }
+                        if (update_latch_status(slot->hotplug_slot, 1))
-                                if(update_latch_status(slot->hotplug_slot, 1)) {
+                                warn("failure to update latch file");
-                                        warn("failure to update latch file");
+                        slot->dev = dev;
-                                }
-                                slot->dev = dev;
-                        } else {
-                                err("%s - no driver attached to device in slot %s",
-                                    __FUNCTION__, slot->hotplug_slot->name);
-                        }
                }
        }
        up_read(&list_rwsem);
@@ -416,26 +406,28 @@ static int
 check_slots(void)
 {
        struct slot *slot;
-        struct list_head *tmp;
        int extracted;
        int inserted;
        u16 hs_csr;
        down_read(&list_rwsem);
-        if(!slots) {
+        if (!slots) {
                up_read(&list_rwsem);
                err("no slots registered, shutting down");
                return -1;
        }
        extracted = inserted = 0;
-        list_for_each(tmp, &slot_list) {
+        list_for_each_entry(slot, &slot_list, slot_list) {
-                slot = list_entry(tmp, struct slot, slot_list);
                dbg("%s - looking at slot %s",
                    __FUNCTION__, slot->hotplug_slot->name);
-                if(cpci_check_and_clear_ins(slot)) {
+                if (cpci_check_and_clear_ins(slot)) {
-                        /* Some broken hardware (e.g. PLX 9054AB) asserts ENUM# twice... */
+                        /*
-                        if(slot->dev) {
+                         * Some broken hardware (e.g. PLX 9054AB) asserts
-                                warn("slot %s already inserted", slot->hotplug_slot->name);
+                         * ENUM# twice...
+                         */
+                        if (slot->dev) {
+                                warn("slot %s already inserted",
+                                     slot->hotplug_slot->name);
                                inserted++;
                                continue;
                        }
@@ -452,7 +444,7 @@ check_slots(void)
                        /* Configure device */
                        dbg("%s - configuring slot %s",
                            __FUNCTION__, slot->hotplug_slot->name);
-                        if(cpci_configure_slot(slot)) {
+                        if (cpci_configure_slot(slot)) {
                                err("%s - could not configure slot %s",
                                    __FUNCTION__, slot->hotplug_slot->name);
                                continue;
@@ -465,13 +457,11 @@ check_slots(void)
                        dbg("%s - slot %s HS_CSR (2) = %04x",
                            __FUNCTION__, slot->hotplug_slot->name, hs_csr);
-                        if(update_latch_status(slot->hotplug_slot, 1)) {
+                        if (update_latch_status(slot->hotplug_slot, 1))
                                warn("failure to update latch file");
-                        }
-                        if(update_adapter_status(slot->hotplug_slot, 1)) {
+                        if (update_adapter_status(slot->hotplug_slot, 1))
                                warn("failure to update adapter file");
-                        }
                        cpci_led_off(slot);
@@ -481,7 +471,7 @@ check_slots(void)
                            __FUNCTION__, slot->hotplug_slot->name, hs_csr);
                        inserted++;
-                } else if(cpci_check_ext(slot)) {
+                } else if (cpci_check_ext(slot)) {
                        /* Process extraction request */
                        dbg("%s - slot %s extracted",
                            __FUNCTION__, slot->hotplug_slot->name);
@@ -491,27 +481,25 @@ check_slots(void)
                        dbg("%s - slot %s HS_CSR = %04x",
                            __FUNCTION__, slot->hotplug_slot->name, hs_csr);
-                        if(!slot->extracting) {
+                        if (!slot->extracting) {
-                                if(update_latch_status(slot->hotplug_slot, 0)) {
+                                if (update_latch_status(slot->hotplug_slot, 0)) {
                                        warn("failure to update latch file");
                                }
-                                atomic_inc(&extracting);
                                slot->extracting = 1;
+                                atomic_inc(&extracting);
                        }
                        extracted++;
-                } else if(slot->extracting) {
+                } else if (slot->extracting) {
                        hs_csr = cpci_get_hs_csr(slot);
-                        if(hs_csr == 0xffff) {
+                        if (hs_csr == 0xffff) {
                                /*
                                 * Hmmm, we're likely hosed at this point, should we
                                 * bother trying to tell the driver or not?
                                 */
                                err("card in slot %s was improperly removed",
                                    slot->hotplug_slot->name);
-                                if(update_adapter_status(slot->hotplug_slot, 0)) {
+                                if (update_adapter_status(slot->hotplug_slot, 0))
                                        warn("failure to update adapter file");
-                                }
                                slot->extracting = 0;
                                atomic_dec(&extracting);
                        }
@@ -520,10 +508,9 @@ check_slots(void)
        up_read(&list_rwsem);
        dbg("inserted=%d, extracted=%d, extracting=%d",
            inserted, extracted, atomic_read(&extracting));
-        if(inserted || extracted) {
+        if (inserted || extracted)
                return extracted;
-        }
+        else if (!atomic_read(&extracting)) {
-        else if(!atomic_read(&extracting)) {
                err("cannot find ENUM# source, shutting down");
                return -1;
        }
@@ -541,12 +528,12 @@ event_thread(void *data)
        unlock_kernel();
        dbg("%s - event thread started", __FUNCTION__);
-        while(1) {
+        while (1) {
                dbg("event thread sleeping");
                down_interruptible(&event_semaphore);
                dbg("event thread woken, thread_finished = %d",
                    thread_finished);
-                if(thread_finished || signal_pending(current))
+                if (thread_finished || signal_pending(current))
                        break;
                do {
                        rc = check_slots();
@@ -558,7 +545,9 @@ event_thread(void *data)
                                thread_finished = 1;
                                break;
                        }
-                } while(atomic_read(&extracting) != 0);
+                } while (atomic_read(&extracting) && !thread_finished);
+                if (thread_finished)
+                        break;
                /* Re-enable ENUM# interrupt */
                dbg("%s - re-enabling irq", __FUNCTION__);
@@ -579,21 +568,21 @@ poll_thread(void *data)
        daemonize("cpci_hp_polld");
        unlock_kernel();
-        while(1) {
+        while (1) {
-                if(thread_finished || signal_pending(current))
+                if (thread_finished || signal_pending(current))
                        break;
-                if(controller->ops->query_enum()) {
+                if (controller->ops->query_enum()) {
                        do {
                                rc = check_slots();
-                                if(rc > 0) {
+                                if (rc > 0) {
                                        /* Give userspace a chance to handle extraction */
                                        msleep(500);
-                                } else if(rc < 0) {
+                                } else if (rc < 0) {
                                        dbg("%s - error checking slots", __FUNCTION__);
                                        thread_finished = 1;
                                        break;
                                }
-                        } while(atomic_read(&extracting) != 0);
+                        } while (atomic_read(&extracting) && !thread_finished);
                }
                msleep(100);
        }
@@ -612,12 +601,11 @@ cpci_start_thread(void)
        init_MUTEX_LOCKED(&thread_exit);
        thread_finished = 0;
-        if(controller->irq) {
+        if (controller->irq)
                pid = kernel_thread(event_thread, NULL, 0);
-        } else {
+        else
                pid = kernel_thread(poll_thread, NULL, 0);
-        }
+        if (pid < 0) {
-        if(pid < 0) {
                err("Can't start up our thread");
                return -1;
        }
@@ -630,9 +618,8 @@ cpci_stop_thread(void)
 {
        thread_finished = 1;
        dbg("thread finish command given");
-        if(controller->irq) {
+        if (controller->irq)
                up(&event_semaphore);
-        }
        dbg("wait for thread to exit");
        down(&thread_exit);
 }
@@ -642,45 +629,67 @@ cpci_hp_register_controller(struct cpci_hp_controller *new_controller)
 {
        int status = 0;
-        if(!controller) {
+        if (controller)
-                controller = new_controller;
+                return -1;
-                if(controller->irq) {
+        if (!(new_controller && new_controller->ops))
-                        if(request_irq(controller->irq,
+                return -EINVAL;
-                                        cpci_hp_intr,
+        if (new_controller->irq) {
-                                        controller->irq_flags,
+                if (!(new_controller->ops->enable_irq &&
-                                        MY_NAME, controller->dev_id)) {
+                     new_controller->ops->disable_irq))
-                                err("Can't get irq %d for the hotplug cPCI controller", controller->irq);
+                        status = -EINVAL;
-                                status = -ENODEV;
+                if (request_irq(new_controller->irq,
-                        }
+                               cpci_hp_intr,
-                        dbg("%s - acquired controller irq %d", __FUNCTION__,
+                               new_controller->irq_flags,
-                            controller->irq);
+                               MY_NAME,
+                               new_controller->dev_id)) {
+                        err("Can't get irq %d for the hotplug cPCI controller",
+                            new_controller->irq);
+                        status = -ENODEV;
                }
-        } else {
+                dbg("%s - acquired controller irq %d",
-                err("cPCI hotplug controller already registered");
+                    __FUNCTION__, new_controller->irq);
-                status = -1;
        }
+        if (!status)
+                controller = new_controller;
        return status;
 }
+static void
+cleanup_slots(void)
+{
+        struct slot *slot;
+        struct slot *tmp;
+        /*
+         * Unregister all of our slots with the pci_hotplug subsystem,
+         * and free up all memory that we had allocated.
+         */
+        down_write(&list_rwsem);
+        if (!slots)
+                goto cleanup_null;
+        list_for_each_entry_safe(slot, tmp, &slot_list, slot_list) {
+                list_del(&slot->slot_list);
+                pci_hp_deregister(slot->hotplug_slot);
+        }
+cleanup_null:
+        up_write(&list_rwsem);
+        return;
+}
 int
 cpci_hp_unregister_controller(struct cpci_hp_controller *old_controller)
 {
        int status = 0;
-        if(controller) {
+        if (controller) {
-                if(atomic_read(&extracting) != 0) {
+                if (!thread_finished)
-                        return -EBUSY;
-                }
-                if(!thread_finished) {
                        cpci_stop_thread();
-                }
+                if (controller->irq)
-                if(controller->irq) {
                        free_irq(controller->irq, controller->dev_id);
-                }
                controller = NULL;
-        } else {
+                cleanup_slots();
+        } else
                status = -ENODEV;
-        }
        return status;
 }
@@ -691,32 +700,28 @@ cpci_hp_start(void)
        int status;
        dbg("%s - enter", __FUNCTION__);
-        if(!controller) {
+        if (!controller)
                return -ENODEV;
-        }
        down_read(&list_rwsem);
-        if(list_empty(&slot_list)) {
+        if (list_empty(&slot_list)) {
                up_read(&list_rwsem);
                return -ENODEV;
        }
        up_read(&list_rwsem);
-        if(first) {
+        status = init_slots(first);
-                status = init_slots();
+        if (first)
-                if(status) {
-                        return status;
-                }
                first = 0;
-        }
+        if (status)
+                return status;
        status = cpci_start_thread();
-        if(status) {
+        if (status)
                return status;
-        }
        dbg("%s - thread started", __FUNCTION__);
-        if(controller->irq) {
+        if (controller->irq) {
                /* Start enum interrupt processing */
                dbg("%s - enabling irq", __FUNCTION__);
                controller->ops->enable_irq();
@@ -728,13 +733,9 @@ cpci_hp_start(void)
 int
 cpci_hp_stop(void)
 {
-        if(!controller) {
+        if (!controller)
                return -ENODEV;
-        }
+        if (controller->irq) {
-        if(atomic_read(&extracting) != 0) {
-                return -EBUSY;
-        }
-        if(controller->irq) {
                /* Stop enum interrupt processing */
                dbg("%s - disabling irq", __FUNCTION__);
                controller->ops->disable_irq();
@@ -743,34 +744,6 @@ cpci_hp_stop(void)
        return 0;
 }
-static void __exit
-cleanup_slots(void)
-{
-        struct list_head *tmp;
-        struct slot *slot;
-        /*
-         * Unregister all of our slots with the pci_hotplug subsystem,
-         * and free up all memory that we had allocated.
-         */
-        down_write(&list_rwsem);
-        if(!slots) {
-                goto null_cleanup;
-        }
-        list_for_each(tmp, &slot_list) {
-                slot = list_entry(tmp, struct slot, slot_list);
-                list_del(&slot->slot_list);
-                pci_hp_deregister(slot->hotplug_slot);
-                kfree(slot->hotplug_slot->info);
-                kfree(slot->hotplug_slot->name);
-                kfree(slot->hotplug_slot);
-                kfree(slot);
-        }
-      null_cleanup:
-        up_write(&list_rwsem);
-        return;
-}
 int __init
 cpci_hotplug_init(int debug)
 {
@@ -784,7 +757,8 @@ cpci_hotplug_exit(void)
        /*
         * Clean everything up.
         */
-        cleanup_slots();
+        cpci_hp_stop();
+        cpci_hp_unregister_controller(controller);
 }
 EXPORT_SYMBOL_GPL(cpci_hp_register_controller);
diff --git a/drivers/pci/hotplug/cpci_hotplug_pci.c b/drivers/pci/hotplug/cpci_hotplug_pci.c
index 69eb4fc54f2f..c878028ad215 100644
--- a/drivers/pci/hotplug/cpci_hotplug_pci.c
+++ b/drivers/pci/hotplug/cpci_hotplug_pci.c
@@ -1,7 +1,7 @@
 /*
 * CompactPCI Hot Plug Driver PCI functions
 *
- * Copyright (C) 2002 by SOMA Networks, Inc.
+ * Copyright (C) 2002,2005 by SOMA Networks, Inc.
 *
 * All rights reserved.
 *
@@ -38,10 +38,10 @@ extern int cpci_debug;
 #define dbg(format, arg...)                                     \
        do {                                                    \
-                if(cpci_debug)                                  \
+                if (cpci_debug)                                 \
                        printk (KERN_DEBUG "%s: " format "\n",  \
                                MY_NAME , ## arg);              \
-        } while(0)
+        } while (0)
 #define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg)
 #define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
@@ -57,16 +57,15 @@ u8 cpci_get_attention_status(struct slot* slot)
        hs_cap = pci_bus_find_capability(slot->bus,
                                         slot->devfn,
                                         PCI_CAP_ID_CHSWP);
-        if(!hs_cap) {
+        if (!hs_cap)
                return 0;
-        }
-        if(pci_bus_read_config_word(slot->bus,
+        if (pci_bus_read_config_word(slot->bus,
                                     slot->devfn,
                                     hs_cap + 2,
-                                     &hs_csr)) {
+                                     &hs_csr))
                return 0;
-        }
        return hs_csr & 0x0008 ? 1 : 0;
 }
@@ -78,27 +77,22 @@ int cpci_set_attention_status(struct slot* slot, int status)
        hs_cap = pci_bus_find_capability(slot->bus,
                                         slot->devfn,
                                         PCI_CAP_ID_CHSWP);
-        if(!hs_cap) {
+        if (!hs_cap)
                return 0;
-        }
+        if (pci_bus_read_config_word(slot->bus,
-        if(pci_bus_read_config_word(slot->bus,
                                     slot->devfn,
                                     hs_cap + 2,
-                                     &hs_csr)) {
+                                     &hs_csr))
                return 0;
-        }
+        if (status)
-        if(status) {
                hs_csr |= HS_CSR_LOO;
-        } else {
+        else
                hs_csr &= ~HS_CSR_LOO;
-        }
+        if (pci_bus_write_config_word(slot->bus,
-        if(pci_bus_write_config_word(slot->bus,
                                      slot->devfn,
                                      hs_cap + 2,
-                                      hs_csr)) {
+                                      hs_csr))
                return 0;
-        }
        return 1;
 }
@@ -110,16 +104,13 @@ u16 cpci_get_hs_csr(struct slot* slot)
        hs_cap = pci_bus_find_capability(slot->bus,
                                         slot->devfn,
                                         PCI_CAP_ID_CHSWP);
-        if(!hs_cap) {
+        if (!hs_cap)
                return 0xFFFF;
-        }
+        if (pci_bus_read_config_word(slot->bus,
-        if(pci_bus_read_config_word(slot->bus,
                                     slot->devfn,
                                     hs_cap + 2,
-                                     &hs_csr)) {
+                                     &hs_csr))
                return 0xFFFF;
-        }
        return hs_csr;
 }
@@ -132,24 +123,22 @@ int cpci_check_and_clear_ins(struct slot* slot)
        hs_cap = pci_bus_find_capability(slot->bus,
                                         slot->devfn,
                                         PCI_CAP_ID_CHSWP);
-        if(!hs_cap) {
+        if (!hs_cap)
                return 0;
-        }
+        if (pci_bus_read_config_word(slot->bus,
-        if(pci_bus_read_config_word(slot->bus,
                                     slot->devfn,
                                     hs_cap + 2,
-                                     &hs_csr)) {
+                                     &hs_csr))
                return 0;
-        }
+        if (hs_csr & HS_CSR_INS) {
-        if(hs_csr & HS_CSR_INS) {
                /* Clear INS (by setting it) */
-                if(pci_bus_write_config_word(slot->bus,
+                if (pci_bus_write_config_word(slot->bus,
                                              slot->devfn,
                                              hs_cap + 2,
-                                              hs_csr)) {
+                                              hs_csr))
                        ins = 0;
-                }
+                else
-                ins = 1;
+                        ins = 1;
        }
        return ins;
 }
@@ -163,18 +152,15 @@ int cpci_check_ext(struct slot* slot)
        hs_cap = pci_bus_find_capability(slot->bus,
                                         slot->devfn,
                                         PCI_CAP_ID_CHSWP);
-        if(!hs_cap) {
+        if (!hs_cap)
                return 0;
-        }
+        if (pci_bus_read_config_word(slot->bus,
-        if(pci_bus_read_config_word(slot->bus,
                                     slot->devfn,
                                     hs_cap + 2,
-                                     &hs_csr)) {
+                                     &hs_csr))
                return 0;
-        }
+        if (hs_csr & HS_CSR_EXT)
-        if(hs_csr & HS_CSR_EXT) {
                ext = 1;
-        }
        return ext;
 }
@@ -186,23 +172,20 @@ int cpci_clear_ext(struct slot* slot)
        hs_cap = pci_bus_find_capability(slot->bus,
                                         slot->devfn,
                                         PCI_CAP_ID_CHSWP);
-        if(!hs_cap) {
+        if (!hs_cap)
                return -ENODEV;
-        }
+        if (pci_bus_read_config_word(slot->bus,
-        if(pci_bus_read_config_word(slot->bus,
                                     slot->devfn,
                                     hs_cap + 2,
-                                     &hs_csr)) {
+                                     &hs_csr))
                return -ENODEV;
-        }
+        if (hs_csr & HS_CSR_EXT) {
-        if(hs_csr & HS_CSR_EXT) {
                /* Clear EXT (by setting it) */
-                if(pci_bus_write_config_word(slot->bus,
+                if (pci_bus_write_config_word(slot->bus,
                                              slot->devfn,
                                              hs_cap + 2,
-                                              hs_csr)) {
+                                              hs_csr))
                        return -ENODEV;
-                }
        }
        return 0;
 }
@@ -215,18 +198,16 @@ int cpci_led_on(struct slot* slot)
        hs_cap = pci_bus_find_capability(slot->bus,
                                         slot->devfn,
                                         PCI_CAP_ID_CHSWP);
-        if(!hs_cap) {
+        if (!hs_cap)
                return -ENODEV;
-        }
+        if (pci_bus_read_config_word(slot->bus,
-        if(pci_bus_read_config_word(slot->bus,
                                     slot->devfn,
                                     hs_cap + 2,
-                                     &hs_csr)) {
+                                     &hs_csr))
                return -ENODEV;
-        }
+        if ((hs_csr & HS_CSR_LOO) != HS_CSR_LOO) {
-        if((hs_csr & HS_CSR_LOO) != HS_CSR_LOO) {
                hs_csr |= HS_CSR_LOO;
-                if(pci_bus_write_config_word(slot->bus,
+                if (pci_bus_write_config_word(slot->bus,
                                              slot->devfn,
                                              hs_cap + 2,
                                              hs_csr)) {
@@ -246,18 +227,16 @@ int cpci_led_off(struct slot* slot)
        hs_cap = pci_bus_find_capability(slot->bus,
                                         slot->devfn,
                                         PCI_CAP_ID_CHSWP);
-        if(!hs_cap) {
+        if (!hs_cap)
                return -ENODEV;
-        }
+        if (pci_bus_read_config_word(slot->bus,
-        if(pci_bus_read_config_word(slot->bus,
                                     slot->devfn,
                                     hs_cap + 2,
-                                     &hs_csr)) {
+                                     &hs_csr))
                return -ENODEV;
-        }
+        if (hs_csr & HS_CSR_LOO) {
-        if(hs_csr & HS_CSR_LOO) {
                hs_csr &= ~HS_CSR_LOO;
-                if(pci_bus_write_config_word(slot->bus,
+                if (pci_bus_write_config_word(slot->bus,
                                              slot->devfn,
                                              hs_cap + 2,
                                              hs_csr)) {
@@ -274,19 +253,6 @@ int cpci_led_off(struct slot* slot)
 * Device configuration functions
 */
-static void cpci_enable_device(struct pci_dev *dev)
-{
-        struct pci_bus *bus;
-        pci_enable_device(dev);
-        if(dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
-                bus = dev->subordinate;
-                list_for_each_entry(dev, &bus->devices, bus_list) {
-                        cpci_enable_device(dev);
-                }
-        }
-}
 int cpci_configure_slot(struct slot* slot)
 {
        unsigned char busnr;
@@ -294,14 +260,14 @@ int cpci_configure_slot(struct slot* slot)
        dbg("%s - enter", __FUNCTION__);
-        if(slot->dev == NULL) {
+        if (slot->dev == NULL) {
                dbg("pci_dev null, finding %02x:%02x:%x",
                    slot->bus->number, PCI_SLOT(slot->devfn), PCI_FUNC(slot->devfn));
-                slot->dev = pci_find_slot(slot->bus->number, slot->devfn);
+                slot->dev = pci_get_slot(slot->bus, slot->devfn);
        }
        /* Still NULL? Well then scan for it! */
-        if(slot->dev == NULL) {
+        if (slot->dev == NULL) {
                int n;
                dbg("pci_dev still null");
@@ -311,10 +277,10 @@ int cpci_configure_slot(struct slot* slot)
                 */
                n = pci_scan_slot(slot->bus, slot->devfn);
                dbg("%s: pci_scan_slot returned %d", __FUNCTION__, n);
-                if(n > 0)
+                if (n > 0)
                        pci_bus_add_devices(slot->bus);
-                slot->dev = pci_find_slot(slot->bus->number, slot->devfn);
+                slot->dev = pci_get_slot(slot->bus, slot->devfn);
-                if(slot->dev == NULL) {
+                if (slot->dev == NULL) {
                        err("Could not find PCI device for slot %02x", slot->number);
                        return 1;
                }
@@ -329,8 +295,6 @@ int cpci_configure_slot(struct slot* slot)
        pci_bus_assign_resources(slot->dev->bus);
-        cpci_enable_device(slot->dev);
        dbg("%s - exit", __FUNCTION__);
        return 0;
 }
@@ -341,15 +305,15 @@ int cpci_unconfigure_slot(struct slot* slot)
        struct pci_dev *dev;
        dbg("%s - enter", __FUNCTION__);
-        if(!slot->dev) {
+        if (!slot->dev) {
                err("No device for slot %02x\n", slot->number);
                return -ENODEV;
        }
        for (i = 0; i < 8; i++) {
-                dev = pci_find_slot(slot->bus->number,
+                dev = pci_get_slot(slot->bus,
                                    PCI_DEVFN(PCI_SLOT(slot->devfn), i));
-                if(dev) {
+                if (dev) {
                        pci_remove_bus_device(dev);
                        slot->dev = NULL;
                }
diff --git a/drivers/pci/hotplug/shpchprm_acpi.c b/drivers/pci/hotplug/shpchprm_acpi.c
index 243a51d88b86..7957cdc72cd0 100644
--- a/drivers/pci/hotplug/shpchprm_acpi.c
+++ b/drivers/pci/hotplug/shpchprm_acpi.c
@@ -1626,7 +1626,7 @@ int shpchprm_set_hpp(
        pci_bus->number = func->bus;
        devfn = PCI_DEVFN(func->device, func->function);
-        ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->bus);
+        ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->slot_bus);
        if (ab) {
                if (ab->_hpp) {
@@ -1681,7 +1681,7 @@ void shpchprm_enable_card(
                | PCI_COMMAND_IO | PCI_COMMAND_MEMORY;
        bcmd = bcommand  = bcommand | PCI_BRIDGE_CTL_NO_ISA;
-        ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->bus);
+        ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->slot_bus);
        if (ab) {
                if (ab->_hpp) {
                        if (ab->_hpp->enable_perr) {
diff --git a/drivers/pci/pci.ids b/drivers/pci/pci.ids
index 93481b41b613..1d2ef1e2ffc6 100644
--- a/drivers/pci/pci.ids
+++ b/drivers/pci/pci.ids
@@ -7173,6 +7173,7 @@
        080f  Sentry5 DDR/SDR RAM Controller
        0811  Sentry5 External Interface Core
        0816  BCM3302 Sentry5 MIPS32 CPU
+        1600  NetXtreme BCM5752 Gigabit Ethernet PCI Express
        1644  NetXtreme BCM5700 Gigabit Ethernet
                1014 0277  Broadcom Vigil B5700 1000Base-T
                1028 00d1  Broadcom BCM5700
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 637e9493034b..2194669300bf 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -460,17 +460,6 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_APIC,
 /*
- * Via 686A/B:  The PCI_INTERRUPT_LINE register for the on-chip
- * devices, USB0/1, AC97, MC97, and ACPI, has an unusual feature:
- * when written, it makes an internal connection to the PIC.
- * For these devices, this register is defined to be 4 bits wide.
- * Normally this is fine.  However for IO-APIC motherboards, or
- * non-x86 architectures (yes Via exists on PPC among other places),
- * we must mask the PCI_INTERRUPT_LINE value versus 0xf to get
- * interrupts delivered properly.
- */
-/*
 * FIXME: it is questionable that quirk_via_acpi
 * is needed.  It shows up as an ISA bridge, and does not
 * support the PCI_INTERRUPT_LINE register at all.  Therefore
@@ -492,28 +481,30 @@ static void __devinit quirk_via_acpi(struct pci_dev *d)
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA,     PCI_DEVICE_ID_VIA_82C586_3,     quirk_via_acpi );
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA,     PCI_DEVICE_ID_VIA_82C686_4,     quirk_via_acpi );
-static void quirk_via_irqpic(struct pci_dev *dev)
+/*
+ * Via 686A/B:  The PCI_INTERRUPT_LINE register for the on-chip
+ * devices, USB0/1, AC97, MC97, and ACPI, has an unusual feature:
+ * when written, it makes an internal connection to the PIC.
+ * For these devices, this register is defined to be 4 bits wide.
+ * Normally this is fine.  However for IO-APIC motherboards, or
+ * non-x86 architectures (yes Via exists on PPC among other places),
+ * we must mask the PCI_INTERRUPT_LINE value versus 0xf to get
+ * interrupts delivered properly.
+ */
+static void quirk_via_irq(struct pci_dev *dev)
 {
        u8 irq, new_irq;
-#ifdef CONFIG_X86_IO_APIC
-        if (nr_ioapics && !skip_ioapic_setup)
-                return;
-#endif
-#ifdef CONFIG_ACPI
-        if (acpi_irq_model != ACPI_IRQ_MODEL_PIC)
-                return;
-#endif
        new_irq = dev->irq & 0xf;
        pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
        if (new_irq != irq) {
-                printk(KERN_INFO "PCI: Via PIC IRQ fixup for %s, from %d to %d\n",
+                printk(KERN_INFO "PCI: Via IRQ fixup for %s, from %d to %d\n",
                        pci_name(dev), irq, new_irq);
                udelay(15);     /* unknown if delay really needed */
                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, new_irq);
        }
 }
-DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_ANY_ID, quirk_via_irqpic);
+DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_ANY_ID, quirk_via_irq);
 /*
 * PIIX3 USB: We have to disable USB interrupts that are
diff --git a/drivers/scsi/ata_piix.c b/drivers/scsi/ata_piix.c
index 54c52349adc5..3be546439252 100644
--- a/drivers/scsi/ata_piix.c
+++ b/drivers/scsi/ata_piix.c
@@ -665,15 +665,6 @@ static int piix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
        return ata_pci_init_one(pdev, port_info, n_ports);
 }
-/**
- *      piix_init -
- *
- *      LOCKING:
- *
- *      RETURNS:
- *
- */
 static int __init piix_init(void)
 {
        int rc;
@@ -689,13 +680,6 @@ static int __init piix_init(void)
        return 0;
 }
-/**
- *      piix_exit -
- *
- *      LOCKING:
- *
- */
 static void __exit piix_exit(void)
 {
        pci_unregister_driver(&piix_pci_driver);
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index 30a88f0e7bd6..21d194c6ace3 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -186,6 +186,28 @@ static void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
        ata_wait_idle(ap);
 }
+/**
+ *      ata_tf_load - send taskfile registers to host controller
+ *      @ap: Port to which output is sent
+ *      @tf: ATA taskfile register set
+ *
+ *      Outputs ATA taskfile to standard ATA host controller using MMIO
+ *      or PIO as indicated by the ATA_FLAG_MMIO flag.
+ *      Writes the control, feature, nsect, lbal, lbam, and lbah registers.
+ *      Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
+ *      hob_lbal, hob_lbam, and hob_lbah.
+ *
+ *      This function waits for idle (!BUSY and !DRQ) after writing
+ *      registers.  If the control register has a new value, this
+ *      function also waits for idle after writing control and before
+ *      writing the remaining registers.
+ *
+ *      May be used as the tf_load() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
 void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
 {
        if (ap->flags & ATA_FLAG_MMIO)
@@ -195,11 +217,11 @@ void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
 }
 /**
- *      ata_exec_command - issue ATA command to host controller
+ *      ata_exec_command_pio - issue ATA command to host controller
 *      @ap: port to which command is being issued
 *      @tf: ATA taskfile register set
 *
- *      Issues PIO/MMIO write to ATA command register, with proper
+ *      Issues PIO write to ATA command register, with proper
 *      synchronization with interrupt handler / other threads.
 *
 *      LOCKING:
@@ -235,6 +257,18 @@ static void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
        ata_pause(ap);
 }
+/**
+ *      ata_exec_command - issue ATA command to host controller
+ *      @ap: port to which command is being issued
+ *      @tf: ATA taskfile register set
+ *
+ *      Issues PIO/MMIO write to ATA command register, with proper
+ *      synchronization with interrupt handler / other threads.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
 void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
 {
        if (ap->flags & ATA_FLAG_MMIO)
@@ -305,7 +339,7 @@ void ata_tf_to_host_nolock(struct ata_port *ap, struct ata_taskfile *tf)
 }
 /**
- *      ata_tf_read - input device's ATA taskfile shadow registers
+ *      ata_tf_read_pio - input device's ATA taskfile shadow registers
 *      @ap: Port from which input is read
 *      @tf: ATA taskfile register set for storing input
 *
@@ -368,6 +402,23 @@ static void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
        }
 }
+/**
+ *      ata_tf_read - input device's ATA taskfile shadow registers
+ *      @ap: Port from which input is read
+ *      @tf: ATA taskfile register set for storing input
+ *
+ *      Reads ATA taskfile registers for currently-selected device
+ *      into @tf.
+ *
+ *      Reads nsect, lbal, lbam, lbah, and device.  If ATA_TFLAG_LBA48
+ *      is set, also reads the hob registers.
+ *
+ *      May be used as the tf_read() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
 void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 {
        if (ap->flags & ATA_FLAG_MMIO)
@@ -381,7 +432,7 @@ void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 *      @ap: port where the device is
 *
 *      Reads ATA taskfile status register for currently-selected device
- *      and return it's value. This also clears pending interrupts
+ *      and return its value. This also clears pending interrupts
 *      from this device
 *
 *      LOCKING:
@@ -397,7 +448,7 @@ static u8 ata_check_status_pio(struct ata_port *ap)
 *      @ap: port where the device is
 *
 *      Reads ATA taskfile status register for currently-selected device
- *      via MMIO and return it's value. This also clears pending interrupts
+ *      via MMIO and return its value. This also clears pending interrupts
 *      from this device
 *
 *      LOCKING:
@@ -408,6 +459,20 @@ static u8 ata_check_status_mmio(struct ata_port *ap)
        return readb((void __iomem *) ap->ioaddr.status_addr);
 }
+/**
+ *      ata_check_status - Read device status reg & clear interrupt
+ *      @ap: port where the device is
+ *
+ *      Reads ATA taskfile status register for currently-selected device
+ *      and return its value. This also clears pending interrupts
+ *      from this device
+ *
+ *      May be used as the check_status() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
 u8 ata_check_status(struct ata_port *ap)
 {
        if (ap->flags & ATA_FLAG_MMIO)
@@ -415,6 +480,20 @@ u8 ata_check_status(struct ata_port *ap)
        return ata_check_status_pio(ap);
 }
+/**
+ *      ata_altstatus - Read device alternate status reg
+ *      @ap: port where the device is
+ *
+ *      Reads ATA taskfile alternate status register for
+ *      currently-selected device and return its value.
+ *
+ *      Note: may NOT be used as the check_altstatus() entry in
+ *      ata_port_operations.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
 u8 ata_altstatus(struct ata_port *ap)
 {
        if (ap->ops->check_altstatus)
@@ -425,6 +504,20 @@ u8 ata_altstatus(struct ata_port *ap)
        return inb(ap->ioaddr.altstatus_addr);
 }
+/**
+ *      ata_chk_err - Read device error reg
+ *      @ap: port where the device is
+ *
+ *      Reads ATA taskfile error register for
+ *      currently-selected device and return its value.
+ *
+ *      Note: may NOT be used as the check_err() entry in
+ *      ata_port_operations.
+ *
+ *      LOCKING:
+ *      Inherited from caller.
+ */
 u8 ata_chk_err(struct ata_port *ap)
 {
        if (ap->ops->check_err)
@@ -873,10 +966,24 @@ void ata_dev_id_string(u16 *id, unsigned char *s,
        }
 }
+/**
+ *      ata_noop_dev_select - Select device 0/1 on ATA bus
+ *      @ap: ATA channel to manipulate
+ *      @device: ATA device (numbered from zero) to select
+ *
+ *      This function performs no actual function.
+ *
+ *      May be used as the dev_select() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      caller.
+ */
 void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
 {
 }
 /**
 *      ata_std_dev_select - Select device 0/1 on ATA bus
 *      @ap: ATA channel to manipulate
@@ -884,7 +991,9 @@ void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
 *
 *      Use the method defined in the ATA specification to
 *      make either device 0, or device 1, active on the
- *      ATA channel.
+ *      ATA channel.  Works with both PIO and MMIO.
+ *
+ *      May be used as the dev_select() entry in ata_port_operations.
 *
 *      LOCKING:
 *      caller.
@@ -1190,7 +1299,12 @@ err_out:
 *      ata_bus_probe - Reset and probe ATA bus
 *      @ap: Bus to probe
 *
+ *      Master ATA bus probing function.  Initiates a hardware-dependent
+ *      bus reset, then attempts to identify any devices found on
+ *      the bus.
+ *
 *      LOCKING:
+ *      PCI/etc. bus probe sem.
 *
 *      RETURNS:
 *      Zero on success, non-zero on error.
@@ -1229,10 +1343,14 @@ err_out:
 }
 /**
- *      ata_port_probe -
+ *      ata_port_probe - Mark port as enabled
- *      @ap:
+ *      @ap: Port for which we indicate enablement
 *
- *      LOCKING:
+ *      Modify @ap data structure such that the system
+ *      thinks that the entire port is enabled.
+ *
+ *      LOCKING: host_set lock, or some other form of
+ *      serialization.
 */
 void ata_port_probe(struct ata_port *ap)
@@ -1241,10 +1359,15 @@ void ata_port_probe(struct ata_port *ap)
 }
 /**
- *      __sata_phy_reset -
+ *      __sata_phy_reset - Wake/reset a low-level SATA PHY
- *      @ap:
+ *      @ap: SATA port associated with target SATA PHY.
+ *
+ *      This function issues commands to standard SATA Sxxx
+ *      PHY registers, to wake up the phy (and device), and
+ *      clear any reset condition.
 *
 *      LOCKING:
+ *      PCI/etc. bus probe sem.
 *
 */
 void __sata_phy_reset(struct ata_port *ap)
@@ -1289,10 +1412,14 @@ void __sata_phy_reset(struct ata_port *ap)
 }
 /**
- *      __sata_phy_reset -
+ *      sata_phy_reset - Reset SATA bus.
- *      @ap:
+ *      @ap: SATA port associated with target SATA PHY.
+ *
+ *      This function resets the SATA bus, and then probes
+ *      the bus for devices.
 *
 *      LOCKING:
+ *      PCI/etc. bus probe sem.
 *
 */
 void sata_phy_reset(struct ata_port *ap)
@@ -1304,10 +1431,16 @@ void sata_phy_reset(struct ata_port *ap)
 }
 /**
- *      ata_port_disable -
+ *      ata_port_disable - Disable port.
- *      @ap:
+ *      @ap: Port to be disabled.
 *
- *      LOCKING:
+ *      Modify @ap data structure such that the system
+ *      thinks that the entire port is disabled, and should
+ *      never attempt to probe or communicate with devices
+ *      on this port.
+ *
+ *      LOCKING: host_set lock, or some other form of
+ *      serialization.
 */
 void ata_port_disable(struct ata_port *ap)
@@ -1416,7 +1549,10 @@ static void ata_host_set_dma(struct ata_port *ap, u8 xfer_mode,
 *      ata_set_mode - Program timings and issue SET FEATURES - XFER
 *      @ap: port on which timings will be programmed
 *
+ *      Set ATA device disk transfer mode (PIO3, UDMA6, etc.).
+ *
 *      LOCKING:
+ *      PCI/etc. bus probe sem.
 *
 */
 static void ata_set_mode(struct ata_port *ap)
@@ -1467,7 +1603,10 @@ err_out:
 *      @tmout_pat: impatience timeout
 *      @tmout: overall timeout
 *
- *      LOCKING:
+ *      Sleep until ATA Status register bit BSY clears,
+ *      or a timeout occurs.
+ *
+ *      LOCKING: None.
 *
 */
@@ -1553,10 +1692,14 @@ static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
 }
 /**
- *      ata_bus_edd -
+ *      ata_bus_edd - Issue EXECUTE DEVICE DIAGNOSTIC command.
- *      @ap:
+ *      @ap: Port to reset and probe
+ *
+ *      Use the EXECUTE DEVICE DIAGNOSTIC command to reset and
+ *      probe the bus.  Not often used these days.
 *
 *      LOCKING:
+ *      PCI/etc. bus probe sem.
 *
 */
@@ -1633,8 +1776,8 @@ static unsigned int ata_bus_softreset(struct ata_port *ap,
 *      the device is ATA or ATAPI.
 *
 *      LOCKING:
- *      Inherited from caller.  Some functions called by this function
+ *      PCI/etc. bus probe sem.
- *      obtain the host_set lock.
+ *      Obtains host_set lock.
 *
 *      SIDE EFFECTS:
 *      Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
@@ -1876,7 +2019,11 @@ static int fgb(u32 bitmap)
 *      @xfer_mode_out: (output) SET FEATURES - XFER MODE code
 *      @xfer_shift_out: (output) bit shift that selects this mode
 *
+ *      Based on host and device capabilities, determine the
+ *      maximum transfer mode that is amenable to all.
+ *
 *      LOCKING:
+ *      PCI/etc. bus probe sem.
 *
 *      RETURNS:
 *      Zero on success, negative on error.
@@ -1909,7 +2056,11 @@ static int ata_choose_xfer_mode(struct ata_port *ap,
 *      @ap: Port associated with device @dev
 *      @dev: Device to which command will be sent
 *
+ *      Issue SET FEATURES - XFER MODE command to device @dev
+ *      on port @ap.
+ *
 *      LOCKING:
+ *      PCI/etc. bus probe sem.
 */
 static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
@@ -1947,10 +2098,13 @@ static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
 }
 /**
- *      ata_sg_clean -
+ *      ata_sg_clean - Unmap DMA memory associated with command
- *      @qc:
+ *      @qc: Command containing DMA memory to be released
+ *
+ *      Unmap all mapped DMA memory associated with this command.
 *
 *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
 */
 static void ata_sg_clean(struct ata_queued_cmd *qc)
@@ -1981,7 +2135,11 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
 *      ata_fill_sg - Fill PCI IDE PRD table
 *      @qc: Metadata associated with taskfile to be transferred
 *
+ *      Fill PCI IDE PRD (scatter-gather) table with segments
+ *      associated with the current disk command.
+ *
 *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
 *
 */
 static void ata_fill_sg(struct ata_queued_cmd *qc)
@@ -2028,7 +2186,13 @@ static void ata_fill_sg(struct ata_queued_cmd *qc)
 *      ata_check_atapi_dma - Check whether ATAPI DMA can be supported
 *      @qc: Metadata associated with taskfile to check
 *
+ *      Allow low-level driver to filter ATA PACKET commands, returning
+ *      a status indicating whether or not it is OK to use DMA for the
+ *      supplied PACKET command.
+ *
 *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ *
 *      RETURNS: 0 when ATAPI DMA can be used
 *               nonzero otherwise
 */
@@ -2046,6 +2210,8 @@ int ata_check_atapi_dma(struct ata_queued_cmd *qc)
 *      ata_qc_prep - Prepare taskfile for submission
 *      @qc: Metadata associated with taskfile to be prepared
 *
+ *      Prepare ATA taskfile for submission.
+ *
 *      LOCKING:
 *      spin_lock_irqsave(host_set lock)
 */
@@ -2057,6 +2223,32 @@ void ata_qc_prep(struct ata_queued_cmd *qc)
        ata_fill_sg(qc);
 }
+/**
+ *      ata_sg_init_one - Associate command with memory buffer
+ *      @qc: Command to be associated
+ *      @buf: Memory buffer
+ *      @buflen: Length of memory buffer, in bytes.
+ *
+ *      Initialize the data-related elements of queued_cmd @qc
+ *      to point to a single memory buffer, @buf of byte length @buflen.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
+/**
+ *      ata_sg_init_one - Prepare a one-entry scatter-gather list.
+ *      @qc:  Queued command
+ *      @buf:  transfer buffer
+ *      @buflen:  length of buf
+ *
+ *      Builds a single-entry scatter-gather list to initiate a
+ *      transfer utilizing the specified buffer.
+ *
+ *      LOCKING:
+ */
 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
 {
        struct scatterlist *sg;
@@ -2074,6 +2266,32 @@ void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
        sg->length = buflen;
 }
+/**
+ *      ata_sg_init - Associate command with scatter-gather table.
+ *      @qc: Command to be associated
+ *      @sg: Scatter-gather table.
+ *      @n_elem: Number of elements in s/g table.
+ *
+ *      Initialize the data-related elements of queued_cmd @qc
+ *      to point to a scatter-gather table @sg, containing @n_elem
+ *      elements.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
+/**
+ *      ata_sg_init - Assign a scatter gather list to a queued command
+ *      @qc:  Queued command
+ *      @sg:  Scatter-gather list
+ *      @n_elem:  length of sg list
+ *
+ *      Attaches a scatter-gather list to a queued command.
+ *
+ *      LOCKING:
+ */
 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
                 unsigned int n_elem)
 {
@@ -2083,14 +2301,16 @@ void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
 }
 /**
- *      ata_sg_setup_one -
+ *      ata_sg_setup_one - DMA-map the memory buffer associated with a command.
- *      @qc:
+ *      @qc: Command with memory buffer to be mapped.
+ *
+ *      DMA-map the memory buffer associated with queued_cmd @qc.
 *
 *      LOCKING:
 *      spin_lock_irqsave(host_set lock)
 *
 *      RETURNS:
- *
+ *      Zero on success, negative on error.
 */
 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
@@ -2115,13 +2335,16 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
 }
 /**
- *      ata_sg_setup -
+ *      ata_sg_setup - DMA-map the scatter-gather table associated with a command.
- *      @qc:
+ *      @qc: Command with scatter-gather table to be mapped.
+ *
+ *      DMA-map the scatter-gather table associated with queued_cmd @qc.
 *
 *      LOCKING:
 *      spin_lock_irqsave(host_set lock)
 *
 *      RETURNS:
+ *      Zero on success, negative on error.
 *
 */
@@ -2151,6 +2374,7 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
 *      @ap:
 *
 *      LOCKING:
+ *      None.  (executing in kernel thread context)
 *
 *      RETURNS:
 *
@@ -2198,6 +2422,7 @@ static unsigned long ata_pio_poll(struct ata_port *ap)
 *      @ap:
 *
 *      LOCKING:
+ *      None.  (executing in kernel thread context)
 */
 static void ata_pio_complete (struct ata_port *ap)
@@ -2240,6 +2465,18 @@ static void ata_pio_complete (struct ata_port *ap)
        ata_qc_complete(qc, drv_stat);
 }
+/**
+ *      swap_buf_le16 -
+ *      @buf:  Buffer to swap
+ *      @buf_words:  Number of 16-bit words in buffer.
+ *
+ *      Swap halves of 16-bit words if needed to convert from
+ *      little-endian byte order to native cpu byte order, or
+ *      vice-versa.
+ *
+ *      LOCKING:
+ */
 void swap_buf_le16(u16 *buf, unsigned int buf_words)
 {
 #ifdef __BIG_ENDIAN
@@ -2415,6 +2652,7 @@ err_out:
 *      @ap:
 *
 *      LOCKING:
+ *      None.  (executing in kernel thread context)
 */
 static void ata_pio_block(struct ata_port *ap)
@@ -2583,6 +2821,7 @@ static void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
 *      transaction completed successfully.
 *
 *      LOCKING:
+ *      Inherited from SCSI layer (none, can sleep)
 */
 static void ata_qc_timeout(struct ata_queued_cmd *qc)
@@ -2692,6 +2931,7 @@ out:
 *      @dev: Device from whom we request an available command structure
 *
 *      LOCKING:
+ *      None.
 */
 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
@@ -2717,6 +2957,7 @@ static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
 *      @dev: Device from whom we request an available command structure
 *
 *      LOCKING:
+ *      None.
 */
 struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
@@ -2781,6 +3022,7 @@ static void __ata_qc_complete(struct ata_queued_cmd *qc)
 *      in case something prevents using it.
 *
 *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
 *
 */
 void ata_qc_free(struct ata_queued_cmd *qc)
@@ -2794,9 +3036,13 @@ void ata_qc_free(struct ata_queued_cmd *qc)
 /**
 *      ata_qc_complete - Complete an active ATA command
 *      @qc: Command to complete
- *      @drv_stat: ATA status register contents
+ *      @drv_stat: ATA Status register contents
+ *
+ *      Indicate to the mid and upper layers that an ATA
+ *      command has completed, with either an ok or not-ok status.
 *
 *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
 *
 */
@@ -2892,6 +3138,7 @@ err_out:
        return -1;
 }
 /**
 *      ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
 *      @qc: command to issue to device
@@ -2901,6 +3148,8 @@ err_out:
 *      classes called "protocols", and issuing each type of protocol
 *      is slightly different.
 *
+ *      May be used as the qc_issue() entry in ata_port_operations.
+ *
 *      LOCKING:
 *      spin_lock_irqsave(host_set lock)
 *
@@ -2958,7 +3207,7 @@ int ata_qc_issue_prot(struct ata_queued_cmd *qc)
 }
 /**
- *      ata_bmdma_setup - Set up PCI IDE BMDMA transaction
+ *      ata_bmdma_setup_mmio - Set up PCI IDE BMDMA transaction
 *      @qc: Info associated with this ATA transaction.
 *
 *      LOCKING:
@@ -3065,6 +3314,18 @@ static void ata_bmdma_start_pio (struct ata_queued_cmd *qc)
             ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
 }
+/**
+ *      ata_bmdma_start - Start a PCI IDE BMDMA transaction
+ *      @qc: Info associated with this ATA transaction.
+ *
+ *      Writes the ATA_DMA_START flag to the DMA command register.
+ *
+ *      May be used as the bmdma_start() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
 void ata_bmdma_start(struct ata_queued_cmd *qc)
 {
        if (qc->ap->flags & ATA_FLAG_MMIO)
@@ -3073,6 +3334,20 @@ void ata_bmdma_start(struct ata_queued_cmd *qc)
                ata_bmdma_start_pio(qc);
 }
+/**
+ *      ata_bmdma_setup - Set up PCI IDE BMDMA transaction
+ *      @qc: Info associated with this ATA transaction.
+ *
+ *      Writes address of PRD table to device's PRD Table Address
+ *      register, sets the DMA control register, and calls
+ *      ops->exec_command() to start the transfer.
+ *
+ *      May be used as the bmdma_setup() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
 void ata_bmdma_setup(struct ata_queued_cmd *qc)
 {
        if (qc->ap->flags & ATA_FLAG_MMIO)
@@ -3081,6 +3356,19 @@ void ata_bmdma_setup(struct ata_queued_cmd *qc)
                ata_bmdma_setup_pio(qc);
 }
+/**
+ *      ata_bmdma_irq_clear - Clear PCI IDE BMDMA interrupt.
+ *      @ap: Port associated with this ATA transaction.
+ *
+ *      Clear interrupt and error flags in DMA status register.
+ *
+ *      May be used as the irq_clear() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
 void ata_bmdma_irq_clear(struct ata_port *ap)
 {
    if (ap->flags & ATA_FLAG_MMIO) {
@@ -3093,6 +3381,19 @@ void ata_bmdma_irq_clear(struct ata_port *ap)
 }
+/**
+ *      ata_bmdma_status - Read PCI IDE BMDMA status
+ *      @ap: Port associated with this ATA transaction.
+ *
+ *      Read and return BMDMA status register.
+ *
+ *      May be used as the bmdma_status() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
 u8 ata_bmdma_status(struct ata_port *ap)
 {
        u8 host_stat;
@@ -3104,6 +3405,19 @@ u8 ata_bmdma_status(struct ata_port *ap)
        return host_stat;
 }
+/**
+ *      ata_bmdma_stop - Stop PCI IDE BMDMA transfer
+ *      @ap: Port associated with this ATA transaction.
+ *
+ *      Clears the ATA_DMA_START flag in the dma control register
+ *
+ *      May be used as the bmdma_stop() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
 void ata_bmdma_stop(struct ata_port *ap)
 {
        if (ap->flags & ATA_FLAG_MMIO) {
@@ -3203,13 +3517,18 @@ idle_irq:
 /**
 *      ata_interrupt - Default ATA host interrupt handler
- *      @irq: irq line
+ *      @irq: irq line (unused)
- *      @dev_instance: pointer to our host information structure
+ *      @dev_instance: pointer to our ata_host_set information structure
 *      @regs: unused
 *
+ *      Default interrupt handler for PCI IDE devices.  Calls
+ *      ata_host_intr() for each port that is not disabled.
+ *
 *      LOCKING:
+ *      Obtains host_set lock during operation.
 *
 *      RETURNS:
+ *      IRQ_NONE or IRQ_HANDLED.
 *
 */
@@ -3302,6 +3621,19 @@ err_out:
        ata_qc_complete(qc, ATA_ERR);
 }
+/**
+ *      ata_port_start - Set port up for dma.
+ *      @ap: Port to initialize
+ *
+ *      Called just after data structures for each port are
+ *      initialized.  Allocates space for PRD table.
+ *
+ *      May be used as the port_start() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ */
 int ata_port_start (struct ata_port *ap)
 {
        struct device *dev = ap->host_set->dev;
@@ -3315,6 +3647,18 @@ int ata_port_start (struct ata_port *ap)
        return 0;
 }
+/**
+ *      ata_port_stop - Undo ata_port_start()
+ *      @ap: Port to shut down
+ *
+ *      Frees the PRD table.
+ *
+ *      May be used as the port_stop() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ */
 void ata_port_stop (struct ata_port *ap)
 {
        struct device *dev = ap->host_set->dev;
@@ -3357,7 +3701,11 @@ static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
 *      @ent: Probe information provided by low-level driver
 *      @port_no: Port number associated with this ata_port
 *
+ *      Initialize a new ata_port structure, and its associated
+ *      scsi_host.
+ *
 *      LOCKING:
+ *      Inherited from caller.
 *
 */
@@ -3412,9 +3760,13 @@ static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
 *      @host_set: Collections of ports to which we add
 *      @port_no: Port number associated with this host
 *
+ *      Attach low-level ATA driver to system.
+ *
 *      LOCKING:
+ *      PCI/etc. bus probe sem.
 *
 *      RETURNS:
+ *      New ata_port on success, for NULL on error.
 *
 */
@@ -3447,12 +3799,22 @@ err_out:
 }
 /**
- *      ata_device_add -
+ *      ata_device_add - Register hardware device with ATA and SCSI layers
- *      @ent:
+ *      @ent: Probe information describing hardware device to be registered
+ *
+ *      This function processes the information provided in the probe
+ *      information struct @ent, allocates the necessary ATA and SCSI
+ *      host information structures, initializes them, and registers
+ *      everything with requisite kernel subsystems.
+ *
+ *      This function requests irqs, probes the ATA bus, and probes
+ *      the SCSI bus.
 *
 *      LOCKING:
+ *      PCI/etc. bus probe sem.
 *
 *      RETURNS:
+ *      Number of ports registered.  Zero on error (no ports registered).
 *
 */
@@ -3604,7 +3966,15 @@ int ata_scsi_release(struct Scsi_Host *host)
 /**
 *      ata_std_ports - initialize ioaddr with standard port offsets.
 *      @ioaddr: IO address structure to be initialized
+ *
+ *      Utility function which initializes data_addr, error_addr,
+ *      feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
+ *      device_addr, status_addr, and command_addr to standard offsets
+ *      relative to cmd_addr.
+ *
+ *      Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
 */
 void ata_std_ports(struct ata_ioports *ioaddr)
 {
        ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
@@ -3646,6 +4016,20 @@ ata_probe_ent_alloc(struct device *dev, struct ata_port_info *port)
        return probe_ent;
 }
+/**
+ *      ata_pci_init_native_mode - Initialize native-mode driver
+ *      @pdev:  pci device to be initialized
+ *      @port:  array[2] of pointers to port info structures.
+ *
+ *      Utility function which allocates and initializes an
+ *      ata_probe_ent structure for a standard dual-port
+ *      PIO-based IDE controller.  The returned ata_probe_ent
+ *      structure can be passed to ata_device_add().  The returned
+ *      ata_probe_ent structure should then be freed with kfree().
+ */
 #ifdef CONFIG_PCI
 struct ata_probe_ent *
 ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
@@ -3727,10 +4111,19 @@ ata_pci_init_legacy_mode(struct pci_dev *pdev, struct ata_port_info **port,
 *      @port_info: Information from low-level host driver
 *      @n_ports: Number of ports attached to host controller
 *
+ *      This is a helper function which can be called from a driver's
+ *      xxx_init_one() probe function if the hardware uses traditional
+ *      IDE taskfile registers.
+ *
+ *      This function calls pci_enable_device(), reserves its register
+ *      regions, sets the dma mask, enables bus master mode, and calls
+ *      ata_device_add()
+ *
 *      LOCKING:
 *      Inherited from PCI layer (may sleep).
 *
 *      RETURNS:
+ *      Zero on success, negative on errno-based value on error.
 *
 */
@@ -3949,15 +4342,6 @@ int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits)
 #endif /* CONFIG_PCI */
-/**
- *      ata_init -
- *
- *      LOCKING:
- *
- *      RETURNS:
- *
- */
 static int __init ata_init(void)
 {
        ata_wq = create_workqueue("ata");
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index 416ba67ba9ee..7a4adc4c8f09 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -947,7 +947,7 @@ unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
 }
 /**
- *      ata_scsiop_noop -
+ *      ata_scsiop_noop - Command handler that simply returns success.
 *      @args: device IDENTIFY data / SCSI command of interest.
 *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 *      @buflen: Response buffer length.
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 579448222d69..3c97aa45772d 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -507,6 +507,7 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
        int ret, i;
        unsigned int id, lun;
        unsigned long serial;
+        unsigned long flags;
        if (!CMD_SP(cmd))
                return FAILED;
@@ -519,7 +520,7 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
        /* Check active list for command command. */
        spin_unlock_irq(ha->host->host_lock);
-        spin_lock(&ha->hardware_lock);
+        spin_lock_irqsave(&ha->hardware_lock, flags);
        for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++) {
                sp = ha->outstanding_cmds[i];
@@ -534,7 +535,7 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
                    sp->state));
                DEBUG3(qla2x00_print_scsi_cmd(cmd);)
-                spin_unlock(&ha->hardware_lock);
+                spin_unlock_irqrestore(&ha->hardware_lock, flags);
                if (qla2x00_abort_command(ha, sp)) {
                        DEBUG2(printk("%s(%ld): abort_command "
                            "mbx failed.\n", __func__, ha->host_no));
@@ -543,20 +544,19 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
                            "mbx success.\n", __func__, ha->host_no));
                        ret = SUCCESS;
                }
-                spin_lock(&ha->hardware_lock);
+                spin_lock_irqsave(&ha->hardware_lock, flags);
                break;
        }
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
        /* Wait for the command to be returned. */
        if (ret == SUCCESS) {
-                spin_unlock(&ha->hardware_lock);
                if (qla2x00_eh_wait_on_command(ha, cmd) != QLA_SUCCESS) {
                        qla_printk(KERN_ERR, ha, 
                            "scsi(%ld:%d:%d): Abort handler timed out -- %lx "
                            "%x.\n", ha->host_no, id, lun, serial, ret);
                }
-                spin_lock(&ha->hardware_lock);
        }
        spin_lock_irq(ha->host->host_lock);
@@ -588,6 +588,7 @@ qla2x00_eh_wait_for_pending_target_commands(scsi_qla_host_t *ha, unsigned int t)
        int     status;
        srb_t           *sp;
        struct scsi_cmnd *cmd;
+        unsigned long flags;
        status = 0;
@@ -596,11 +597,11 @@ qla2x00_eh_wait_for_pending_target_commands(scsi_qla_host_t *ha, unsigned int t)
         * array
         */
        for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
-                spin_lock(&ha->hardware_lock);
+                spin_lock_irqsave(&ha->hardware_lock, flags);
                sp = ha->outstanding_cmds[cnt];
                if (sp) {
                        cmd = sp->cmd;
-                        spin_unlock(&ha->hardware_lock);
+                        spin_unlock_irqrestore(&ha->hardware_lock, flags);
                        if (cmd->device->id == t) {
                                if (!qla2x00_eh_wait_on_command(ha, cmd)) {
                                        status = 1;
@@ -608,7 +609,7 @@ qla2x00_eh_wait_for_pending_target_commands(scsi_qla_host_t *ha, unsigned int t)
                                }
                        }
                } else {
-                        spin_unlock(&ha->hardware_lock);
+                        spin_unlock_irqrestore(&ha->hardware_lock, flags);
                }
        }
        return (status);
@@ -740,6 +741,7 @@ qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *ha)
        int     status;
        srb_t           *sp;
        struct scsi_cmnd *cmd;
+        unsigned long flags;
        status = 1;
@@ -748,17 +750,17 @@ qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *ha)
         * array
         */
        for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
-                spin_lock(&ha->hardware_lock);
+                spin_lock_irqsave(&ha->hardware_lock, flags);
                sp = ha->outstanding_cmds[cnt];
                if (sp) {
                        cmd = sp->cmd;
-                        spin_unlock(&ha->hardware_lock);
+                        spin_unlock_irqrestore(&ha->hardware_lock, flags);
                        status = qla2x00_eh_wait_on_command(ha, cmd);
                        if (status == 0)
                                break;
                }
                else {
-                        spin_unlock(&ha->hardware_lock);
+                        spin_unlock_irqrestore(&ha->hardware_lock, flags);
                }
        }
        return (status);
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index cca772624ae7..8d0d302844a1 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -1197,6 +1197,7 @@ struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
        if (!starget)
                return ERR_PTR(-ENOMEM);
+        get_device(&starget->dev);
        down(&shost->scan_mutex);
        res = scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
        if (res != SCSI_SCAN_LUN_PRESENT)
diff --git a/drivers/serial/vr41xx_siu.c b/drivers/serial/vr41xx_siu.c
index 5d2ceb623e6f..1f985327b0d4 100644
--- a/drivers/serial/vr41xx_siu.c
+++ b/drivers/serial/vr41xx_siu.c
@@ -234,7 +234,7 @@ static inline const char *siu_type_name(struct uart_port *port)
                return "DSIU";
        }
-        return "unknown";
+        return NULL;
 }
 static unsigned int siu_tx_empty(struct uart_port *port)
@@ -482,9 +482,6 @@ static irqreturn_t siu_interrupt(int irq, void *dev_id, struct pt_regs *regs)
        struct uart_port *port;
        uint8_t iir, lsr;
-        if (dev_id == NULL)
-                return IRQ_NONE;
        port = (struct uart_port *)dev_id;
        iir = siu_read(port, UART_IIR);
@@ -507,6 +504,9 @@ static int siu_startup(struct uart_port *port)
 {
        int retval;
+        if (port->membase == NULL)
+                return -ENODEV;
        siu_clear_fifo(port);
        (void)siu_read(port, UART_LSR);
@@ -545,9 +545,6 @@ static void siu_shutdown(struct uart_port *port)
        unsigned long flags;
        uint8_t lcr;
-        if (port->membase == NULL)
-                return;
        siu_write(port, UART_IER, 0);
        spin_lock_irqsave(&port->lock, flags);
@@ -802,53 +799,6 @@ static int siu_init_ports(void)
 #ifdef CONFIG_SERIAL_VR41XX_CONSOLE
-static void early_set_termios(struct uart_port *port, struct termios *new,
-                              struct termios *old)
-{
-        tcflag_t c_cflag;
-        uint8_t lcr;
-        unsigned int baud, quot;
-        c_cflag = new->c_cflag;
-        switch (c_cflag & CSIZE) {
-        case CS5:
-                lcr = UART_LCR_WLEN5;
-                break;
-        case CS6:
-                lcr = UART_LCR_WLEN6;
-                break;
-        case CS7:
-                lcr = UART_LCR_WLEN7;
-                break;
-        default:
-                lcr = UART_LCR_WLEN8;
-                break;
-        }
-        if (c_cflag & CSTOPB)
-                lcr |= UART_LCR_STOP;
-        if (c_cflag & PARENB)
-                lcr |= UART_LCR_PARITY;
-        if ((c_cflag & PARODD) != PARODD)
-                lcr |= UART_LCR_EPAR;
-        if (c_cflag & CMSPAR)
-                lcr |= UART_LCR_SPAR;
-        baud = uart_get_baud_rate(port, new, old, 0, port->uartclk/16);
-        quot = uart_get_divisor(port, baud);
-        siu_write(port, UART_LCR, lcr | UART_LCR_DLAB);
-        siu_write(port, UART_DLL, (uint8_t)quot);
-        siu_write(port, UART_DLM, (uint8_t)(quot >> 8));
-        siu_write(port, UART_LCR, lcr);
-}
-static struct uart_ops early_uart_ops = {
-        .set_termios    = early_set_termios,
-};
 #define BOTH_EMPTY      (UART_LSR_TEMT | UART_LSR_THRE)
 static void wait_for_xmitr(struct uart_port *port)
@@ -915,7 +865,7 @@ static int siu_console_setup(struct console *con, char *options)
        if (port->membase == NULL) {
                if (port->mapbase == 0)
                        return -ENODEV;
-                port->membase = (unsigned char __iomem *)KSEG1ADDR(port->mapbase);
+                port->membase = ioremap(port->mapbase, siu_port_size(port));
        }
        vr41xx_select_siu_interface(SIU_INTERFACE_RS232C);
@@ -949,7 +899,7 @@ static int __devinit siu_console_init(void)
        for (i = 0; i < num; i++) {
                port = &siu_uart_ports[i];
-                port->ops = &early_uart_ops;
+                port->ops = &siu_uart_ops;
        }
        register_console(&siu_console);
@@ -994,8 +944,10 @@ static int siu_probe(struct device *dev)
                port->dev = dev;
                retval = uart_add_one_port(&siu_uart_driver, port);
-                if (retval)
+                if (retval < 0) {
+                        port->dev = NULL;
                        break;
+                }
        }
        if (i == 0 && retval < 0) {
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 4ab50009291d..4d0c9e65cd03 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -290,32 +290,30 @@ static ssize_t show_modalias(struct device *dev, char *buf)
 {
        struct usb_interface *intf;
        struct usb_device *udev;
+        int len;
        intf = to_usb_interface(dev);
        udev = interface_to_usbdev(intf);
-        if (udev->descriptor.bDeviceClass == 0) {
-                struct usb_host_interface *alt = intf->cur_altsetting;
-                return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X\n",
+        len = sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic",
                               le16_to_cpu(udev->descriptor.idVendor),
                               le16_to_cpu(udev->descriptor.idProduct),
                               le16_to_cpu(udev->descriptor.bcdDevice),
                               udev->descriptor.bDeviceClass,
                               udev->descriptor.bDeviceSubClass,
-                               udev->descriptor.bDeviceProtocol,
+                               udev->descriptor.bDeviceProtocol);
+        buf += len;
+        if (udev->descriptor.bDeviceClass == 0) {
+                struct usb_host_interface *alt = intf->cur_altsetting;
+                return len + sprintf(buf, "%02Xisc%02Xip%02X\n",
                               alt->desc.bInterfaceClass,
                               alt->desc.bInterfaceSubClass,
                               alt->desc.bInterfaceProtocol);
        } else {
-                return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic*isc*ip*\n",
+                return len + sprintf(buf, "*isc*ip*\n");
-                               le16_to_cpu(udev->descriptor.idVendor),
-                               le16_to_cpu(udev->descriptor.idProduct),
-                               le16_to_cpu(udev->descriptor.bcdDevice),
-                               udev->descriptor.bDeviceClass,
-                               udev->descriptor.bDeviceSubClass,
-                               udev->descriptor.bDeviceProtocol);
        }
 }
 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 3196c3265ff5..19e598c9641f 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -124,3 +124,14 @@ config USB_SL811_HCD
          To compile this driver as a module, choose M here: the
          module will be called sl811-hcd.
+config USB_SL811_CS
+        tristate "CF/PCMCIA support for SL811HS HCD"
+        depends on USB_SL811_HCD && PCMCIA
+        default N
+        help
+          Wraps a PCMCIA driver around the SL811HS HCD, supporting the RATOC
+          REX-CFU1U CF card (often used with PDAs).  If unsure, say N.
+          To compile this driver as a module, choose M here: the
+          module will be called "sl811_cs".
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index a574ca06cf6b..5dbd3e7a27c7 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -7,4 +7,5 @@ obj-$(CONFIG_USB_EHCI_HCD)	+= ehci-hcd.o
 obj-$(CONFIG_USB_OHCI_HCD)      += ohci-hcd.o
 obj-$(CONFIG_USB_UHCI_HCD)      += uhci-hcd.o
 obj-$(CONFIG_USB_SL811_HCD)     += sl811-hcd.o
+obj-$(CONFIG_USB_SL811_CS)      += sl811_cs.o
 obj-$(CONFIG_ETRAX_ARCH_V10)    += hc_crisv10.o
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index a374b7692073..99d43f758ad0 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -2,8 +2,8 @@
 * SL811HS HCD (Host Controller Driver) for USB.
 *
 * Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
- * Copyright (C) 2004 David Brownell
+ * Copyright (C) 2004-2005 David Brownell
- * 
+ *
 * Periodic scheduling is based on Roman's OHCI code
 *      Copyright (C) 1999 Roman Weissgaerber
 *
@@ -15,7 +15,7 @@
 * For documentation, see the SL811HS spec and the "SL811HS Embedded Host"
 * document (providing significant pieces missing from that spec); plus
 * the SL811S spec if you want peripheral side info.
- */ 
+ */
 /*
 * Status:  Passed basic stress testing, works with hubs, mice, keyboards,
@@ -67,7 +67,7 @@
 MODULE_DESCRIPTION("SL811HS USB Host Controller Driver");
 MODULE_LICENSE("GPL");
-#define DRIVER_VERSION  "15 Dec 2004"
+#define DRIVER_VERSION  "19 May 2005"
 #ifndef DEBUG
@@ -121,6 +121,10 @@ static void port_power(struct sl811 *sl811, int is_on)
        /* reset as thoroughly as we can */
        if (sl811->board && sl811->board->reset)
                sl811->board->reset(hcd->self.controller);
+        else {
+                sl811_write(sl811, SL11H_CTLREG1, SL11H_CTL1MASK_SE0);
+                mdelay(20);
+        }
        sl811_write(sl811, SL11H_IRQ_ENABLE, 0);
        sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
@@ -443,6 +447,7 @@ static void finish_request(
        spin_lock(&urb->lock);
        if (urb->status == -EINPROGRESS)
                urb->status = status;
+        urb->hcpriv = NULL;
        spin_unlock(&urb->lock);
        spin_unlock(&sl811->lock);
@@ -472,7 +477,7 @@ static void finish_request(
                if (*prev)
                        *prev = ep->next;
                sl811->load[i] -= ep->load;
-        }       
+        }
        ep->branch = PERIODIC_SIZE;
        sl811->periodic_count--;
        sl811_to_hcd(sl811)->self.bandwidth_allocated
@@ -661,9 +666,9 @@ retry:
 #ifdef  QUIRK2
        /* this may no longer be necessary ... */
-        if (irqstat == 0 && ret == IRQ_NONE) {
+        if (irqstat == 0) {
                irqstat = checkdone(sl811);
-                if (irqstat /* && irq != ~0 */ )
+                if (irqstat)
                        sl811->stat_lost++;
        }
 #endif
@@ -722,7 +727,8 @@ retry:
                if (sl811->active_a) {
                        sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG), 0);
                        finish_request(sl811, sl811->active_a,
-                                container_of(sl811->active_a->hep->urb_list.next,
+                                container_of(sl811->active_a
+                                                ->hep->urb_list.next,
                                        struct urb, urb_list),
                                NULL, -ESHUTDOWN);
                        sl811->active_a = NULL;
@@ -731,7 +737,8 @@ retry:
                if (sl811->active_b) {
                        sl811_write(sl811, SL811_EP_B(SL11H_HOSTCTLREG), 0);
                        finish_request(sl811, sl811->active_b,
-                                container_of(sl811->active_b->hep->urb_list.next,
+                                container_of(sl811->active_b
+                                                ->hep->urb_list.next,
                                        struct urb, urb_list),
                                NULL, -ESHUTDOWN);
                        sl811->active_b = NULL;
@@ -761,7 +768,7 @@ retry:
                        goto retry;
        }
-        if (sl811->periodic_count == 0 && list_empty(&sl811->async)) 
+        if (sl811->periodic_count == 0 && list_empty(&sl811->async))
                sofirq_off(sl811);
        sl811_write(sl811, SL11H_IRQ_ENABLE, sl811->irq_enable);
@@ -796,7 +803,7 @@ static int balance(struct sl811 *sl811, u16 period, u16 load)
                        }
                        if (j < PERIODIC_SIZE)
                                continue;
-                        branch = i; 
+                        branch = i;
                }
        }
        return branch;
@@ -890,6 +897,7 @@ static int sl811h_urb_enqueue(
                        break;
                }
+                ep->hep = hep;
                hep->hcpriv = ep;
        }
@@ -961,15 +969,16 @@ fail:
 static int sl811h_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
 {
        struct sl811            *sl811 = hcd_to_sl811(hcd);
-        struct usb_host_endpoint *hep = urb->hcpriv;
+        struct usb_host_endpoint *hep;
        unsigned long           flags;
        struct sl811h_ep        *ep;
        int                     retval = 0;
+        spin_lock_irqsave(&sl811->lock, flags);
+        hep = urb->hcpriv;
        if (!hep)
-                return -EINVAL;
+                goto fail;
-        spin_lock_irqsave(&sl811->lock, flags);
        ep = hep->hcpriv;
        if (ep) {
                /* finish right away if this urb can't be active ...
@@ -1017,6 +1026,7 @@ static int sl811h_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
                        VDBG("dequeue, urb %p active %s; wait4irq\n", urb,
                                (sl811->active_a == ep) ? "A" : "B");
        } else
+fail:
                retval = -EINVAL;
        spin_unlock_irqrestore(&sl811->lock, flags);
        return retval;
@@ -1576,6 +1586,9 @@ sl811h_start(struct usb_hcd *hcd)
        if (sl811->board && sl811->board->power)
                hub_set_power_budget(udev, sl811->board->power * 2);
+        /* enable power and interupts */
+        port_power(sl811, 1);
        return 0;
 }
@@ -1618,7 +1631,7 @@ static struct hc_driver sl811h_hc_driver = {
 /*-------------------------------------------------------------------------*/
-static int __init_or_module
+static int __devexit
 sl811h_remove(struct device *dev)
 {
        struct usb_hcd          *hcd = dev_get_drvdata(dev);
@@ -1631,21 +1644,20 @@ sl811h_remove(struct device *dev)
        remove_debug_file(sl811);
        usb_remove_hcd(hcd);
-        iounmap(sl811->data_reg);
+        /* some platforms may use IORESOURCE_IO */
        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        release_mem_region(res->start, 1);
+        if (res)
+                iounmap(sl811->data_reg);
-        iounmap(sl811->addr_reg);
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(res->start, 1);
+        if (res)
+                iounmap(sl811->addr_reg);
        usb_put_hcd(hcd);
        return 0;
 }
-#define resource_len(r) (((r)->end - (r)->start) + 1)
+static int __devinit
-static int __init
 sl811h_probe(struct device *dev)
 {
        struct usb_hcd          *hcd;
@@ -1656,7 +1668,7 @@ sl811h_probe(struct device *dev)
        void __iomem            *addr_reg;
        void __iomem            *data_reg;
        int                     retval;
-        u8                      tmp;
+        u8                      tmp, ioaddr = 0;
        /* basic sanity checks first.  board-specific init logic should
         * have initialized these three resources and probably board
@@ -1664,13 +1676,8 @@ sl811h_probe(struct device *dev)
         * minimal sanity checking.
         */
        pdev = container_of(dev, struct platform_device, dev);
-        if (pdev->num_resources < 3)
-                return -ENODEV;
-        addr = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        data = platform_get_resource(pdev, IORESOURCE_MEM, 1);
        irq = platform_get_irq(pdev, 0);
-        if (!addr || !data || irq < 0)
+        if (pdev->num_resources < 3 || irq < 0)
                return -ENODEV;
        /* refuse to confuse usbcore */
@@ -1679,24 +1686,31 @@ sl811h_probe(struct device *dev)
                return -EINVAL;
        }
-        if (!request_mem_region(addr->start, 1, hcd_name)) {
+        /* the chip may be wired for either kind of addressing */
-                retval = -EBUSY;
+        addr = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-                goto err1;
+        data = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        }
+        retval = -EBUSY;
-        addr_reg = ioremap(addr->start, resource_len(addr));
+        if (!addr || !data) {
-        if (addr_reg == NULL) {
+                addr = platform_get_resource(pdev, IORESOURCE_IO, 0);
-                retval = -ENOMEM;
+                data = platform_get_resource(pdev, IORESOURCE_IO, 1);
-                goto err2;
+                if (!addr || !data)
-        }
+                        return -ENODEV;
+                ioaddr = 1;
+                addr_reg = (void __iomem *) addr->start;
+                data_reg = (void __iomem *) data->start;
+        } else {
+                addr_reg = ioremap(addr->start, 1);
+                if (addr_reg == NULL) {
+                        retval = -ENOMEM;
+                        goto err2;
+                }
-        if (!request_mem_region(data->start, 1, hcd_name)) {
+                data_reg = ioremap(data->start, 1);
-                retval = -EBUSY;
+                if (data_reg == NULL) {
-                goto err3;
+                        retval = -ENOMEM;
-        }
+                        goto err4;
-        data_reg = ioremap(data->start, resource_len(addr));
+                }
-        if (data_reg == NULL) {
-                retval = -ENOMEM;
-                goto err4;
        }
        /* allocate and initialize hcd */
@@ -1737,12 +1751,14 @@ sl811h_probe(struct device *dev)
                goto err6;
        }
-        /* sl811s would need a different handler for this irq */
+        /* The chip's IRQ is level triggered, active high.  A requirement
-#ifdef  CONFIG_ARM
+         * for platform device setup is to cope with things like signal
-        /* Cypress docs say the IRQ is IRQT_HIGH ... */
+         * inverters (e.g. CF is active low) or working only with edge
-        set_irq_type(irq, IRQT_RISING);
+         * triggers (e.g. most ARM CPUs).  Initial driver stress testing
-#endif
+         * was on a system with single edge triggering, so most sorts of
-        retval = usb_add_hcd(hcd, irq, SA_INTERRUPT);
+         * triggering arrangement should work.
+         */
+        retval = usb_add_hcd(hcd, irq, SA_INTERRUPT | SA_SHIRQ);
        if (retval != 0)
                goto err6;
@@ -1752,14 +1768,12 @@ sl811h_probe(struct device *dev)
 err6:
        usb_put_hcd(hcd);
 err5:
-        iounmap(data_reg);
+        if (!ioaddr)
+                iounmap(data_reg);
 err4:
-        release_mem_region(data->start, 1);
+        if (!ioaddr)
- err3:
+                iounmap(addr_reg);
-        iounmap(addr_reg);
 err2:
-        release_mem_region(addr->start, 1);
- err1:
        DBG("init error, %d\n", retval);
        return retval;
 }
@@ -1767,7 +1781,7 @@ sl811h_probe(struct device *dev)
 #ifdef  CONFIG_PM
 /* for this device there's no useful distinction between the controller
- * and its root hub, except that the root hub only gets direct PM calls 
+ * and its root hub, except that the root hub only gets direct PM calls
 * when CONFIG_USB_SUSPEND is enabled.
 */
@@ -1821,20 +1835,22 @@ sl811h_resume(struct device *dev, u32 phase)
 #endif
-static struct device_driver sl811h_driver = {
+/* this driver is exported so sl811_cs can depend on it */
+struct device_driver sl811h_driver = {
        .name =         (char *) hcd_name,
        .bus =          &platform_bus_type,
        .probe =        sl811h_probe,
-        .remove =       sl811h_remove,
+        .remove =       __devexit_p(sl811h_remove),
        .suspend =      sl811h_suspend,
        .resume =       sl811h_resume,
 };
+EXPORT_SYMBOL(sl811h_driver);
 /*-------------------------------------------------------------------------*/
- 
-static int __init sl811h_init(void) 
+static int __init sl811h_init(void)
 {
        if (usb_disabled())
                return -ENODEV;
@@ -1844,8 +1860,8 @@ static int __init sl811h_init(void)
 }
 module_init(sl811h_init);
-static void __exit sl811h_cleanup(void) 
+static void __exit sl811h_cleanup(void)
-{       
+{
        driver_unregister(&sl811h_driver);
 }
 module_exit(sl811h_cleanup);
diff --git a/drivers/usb/host/sl811_cs.c b/drivers/usb/host/sl811_cs.c
new file mode 100644
index 000000000000..6e173265095c
--- /dev/null
+++ b/drivers/usb/host/sl811_cs.c
@@ -0,0 +1,442 @@
+/*
+ * PCMCIA driver for SL811HS (as found in REX-CFU1U)
+ * Filename: sl811_cs.c
+ * Author:   Yukio Yamamoto
+ *
+ *  Port to sl811-hcd and 2.6.x by
+ *    Botond Botyanszki <boti@rocketmail.com>
+ *    Simon Pickering
+ *
+ *  Last update: 2005-05-12
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sched.h>
+#include <linux/ptrace.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/timer.h>
+#include <linux/ioport.h>
+#include <pcmcia/version.h>
+#include <pcmcia/cs_types.h>
+#include <pcmcia/cs.h>
+#include <pcmcia/cistpl.h>
+#include <pcmcia/cisreg.h>
+#include <pcmcia/ds.h>
+#include <linux/usb_sl811.h>
+MODULE_AUTHOR("Botond Botyanszki");
+MODULE_DESCRIPTION("REX-CFU1U PCMCIA driver for 2.6");
+MODULE_LICENSE("GPL");
+/*====================================================================*/
+/* MACROS                                                             */
+/*====================================================================*/
+#if defined(DEBUG) || defined(CONFIG_USB_DEBUG) || defined(PCMCIA_DEBUG)
+static int pc_debug = 0;
+module_param(pc_debug, int, 0644);
+#define DBG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG "sl811_cs: " args)
+#else
+#define DBG(n, args...) do{}while(0)
+#endif  /* no debugging */
+#define INFO(args...) printk(KERN_INFO "sl811_cs: " args)
+#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
+#define CS_CHECK(fn, ret) \
+        do { \
+                last_fn = (fn); \
+                if ((last_ret = (ret)) != 0) \
+                        goto cs_failed; \
+        } while (0)
+/*====================================================================*/
+/* VARIABLES                                                          */
+/*====================================================================*/
+static const char driver_name[DEV_NAME_LEN]  = "sl811_cs";
+static dev_link_t *dev_list = NULL;
+static int irq_list[4] = { -1 };
+static int irq_list_count;
+module_param_array(irq_list, int, &irq_list_count, 0444);
+INT_MODULE_PARM(irq_mask, 0xdeb8);
+typedef struct local_info_t {
+        dev_link_t              link;
+        dev_node_t              node;
+} local_info_t;
+/*====================================================================*/
+static void release_platform_dev(struct device * dev)
+{
+        DBG(0, "sl811_cs platform_dev release\n");
+        dev->parent = NULL;
+}
+static struct sl811_platform_data platform_data = {
+        .potpg          = 100,
+        .power          = 50,           /* == 100mA */
+        // .reset       = ... FIXME:  invoke CF reset on the card
+};
+static struct resource resources[] = {
+        [0] = {
+                .flags  = IORESOURCE_IRQ,
+        },
+        [1] = {
+                // .name   = "address",
+                .flags  = IORESOURCE_IO,
+        },
+        [2] = {
+                // .name   = "data",
+                .flags  = IORESOURCE_IO,
+        },
+};
+extern struct device_driver sl811h_driver;
+static struct platform_device platform_dev = {
+        .id                     = -1,
+        .dev = {
+                .platform_data = &platform_data,
+                .release       = release_platform_dev,
+        },
+        .resource               = resources,
+        .num_resources          = ARRAY_SIZE(resources),
+};
+static int sl811_hc_init(struct device *parent, ioaddr_t base_addr, int irq)
+{
+        if (platform_dev.dev.parent)
+                return -EBUSY;
+        platform_dev.dev.parent = parent;
+        /* finish seting up the platform device */
+        resources[0].start = irq;
+        resources[1].start = base_addr;
+        resources[1].end = base_addr;
+        resources[2].start = base_addr + 1;
+        resources[2].end   = base_addr + 1;
+        /* The driver core will probe for us.  We know sl811-hcd has been
+         * initialized already because of the link order dependency.
+         */
+        platform_dev.name = sl811h_driver.name;
+        return platform_device_register(&platform_dev);
+}
+/*====================================================================*/
+static void sl811_cs_detach(dev_link_t *link)
+{
+        dev_link_t **linkp;
+        DBG(0, "sl811_cs_detach(0x%p)\n", link);
+        /* Locate device structure */
+        for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) {
+                if (*linkp == link)
+                        break;
+        }
+        if (*linkp == NULL)
+                return;
+        /* Break the link with Card Services */
+        if (link->handle)
+                pcmcia_deregister_client(link->handle);
+        /* Unlink device structure, and free it */
+        *linkp = link->next;
+        /* This points to the parent local_info_t struct */
+        kfree(link->priv);
+}
+static void sl811_cs_release(dev_link_t * link)
+{
+        DBG(0, "sl811_cs_release(0x%p)\n", link);
+        if (link->open) {
+                DBG(1, "sl811_cs: release postponed, '%s' still open\n",
+                    link->dev->dev_name);
+                link->state |= DEV_STALE_CONFIG;
+                return;
+        }
+        /* Unlink the device chain */
+        link->dev = NULL;
+        platform_device_unregister(&platform_dev);
+        pcmcia_release_configuration(link->handle);
+        if (link->io.NumPorts1)
+                pcmcia_release_io(link->handle, &link->io);
+        if (link->irq.AssignedIRQ)
+                pcmcia_release_irq(link->handle, &link->irq);
+        link->state &= ~DEV_CONFIG;
+        if (link->state & DEV_STALE_LINK)
+                sl811_cs_detach(link);
+}
+static void sl811_cs_config(dev_link_t *link)
+{
+        client_handle_t         handle = link->handle;
+        struct device           *parent = &handle_to_dev(handle);
+        local_info_t            *dev = link->priv;
+        tuple_t                 tuple;
+        cisparse_t              parse;
+        int                     last_fn, last_ret;
+        u_char                  buf[64];
+        config_info_t           conf;
+        cistpl_cftable_entry_t  dflt = { 0 };
+        DBG(0, "sl811_cs_config(0x%p)\n", link);
+        tuple.DesiredTuple = CISTPL_CONFIG;
+        tuple.Attributes = 0;
+        tuple.TupleData = buf;
+        tuple.TupleDataMax = sizeof(buf);
+        tuple.TupleOffset = 0;
+        CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
+        CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
+        CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
+        link->conf.ConfigBase = parse.config.base;
+        link->conf.Present = parse.config.rmask[0];
+        /* Configure card */
+        link->state |= DEV_CONFIG;
+        /* Look up the current Vcc */
+        CS_CHECK(GetConfigurationInfo,
+                        pcmcia_get_configuration_info(handle, &conf));
+        link->conf.Vcc = conf.Vcc;
+        tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
+        CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
+        while (1) {
+                cistpl_cftable_entry_t  *cfg = &(parse.cftable_entry);
+                if (pcmcia_get_tuple_data(handle, &tuple) != 0
+                                || pcmcia_parse_tuple(handle, &tuple, &parse)
+                                                != 0)
+                        goto next_entry;
+                if (cfg->flags & CISTPL_CFTABLE_DEFAULT) {
+                        dflt = *cfg;
+                }
+                if (cfg->index == 0)
+                        goto next_entry;
+                link->conf.ConfigIndex = cfg->index;
+                /* Use power settings for Vcc and Vpp if present */
+                /*  Note that the CIS values need to be rescaled */
+                if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
+                        if (cfg->vcc.param[CISTPL_POWER_VNOM]/10000
+                                        != conf.Vcc)
+                                goto next_entry;
+                } else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM)) {
+                        if (dflt.vcc.param[CISTPL_POWER_VNOM]/10000
+                                        != conf.Vcc)
+                                goto next_entry;
+                }
+                if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
+                        link->conf.Vpp1 = link->conf.Vpp2 =
+                                cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
+                else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
+                        link->conf.Vpp1 = link->conf.Vpp2 =
+                                dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
+                /* we need an interrupt */
+                if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
+                        link->conf.Attributes |= CONF_ENABLE_IRQ;
+                /* IO window settings */
+                link->io.NumPorts1 = link->io.NumPorts2 = 0;
+                if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
+                        cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
+                        link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
+                        link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
+                        link->io.BasePort1 = io->win[0].base;
+                        link->io.NumPorts1 = io->win[0].len;
+                        if (pcmcia_request_io(link->handle, &link->io) != 0)
+                                goto next_entry;
+                }
+                break;
+next_entry:
+                if (link->io.NumPorts1)
+                        pcmcia_release_io(link->handle, &link->io);
+                last_ret = pcmcia_get_next_tuple(handle, &tuple);
+        }
+        /* require an IRQ and two registers */
+        if (!link->io.NumPorts1 || link->io.NumPorts1 < 2)
+                goto cs_failed;
+        if (link->conf.Attributes & CONF_ENABLE_IRQ)
+                CS_CHECK(RequestIRQ,
+                        pcmcia_request_irq(link->handle, &link->irq));
+        else
+                goto cs_failed;
+        CS_CHECK(RequestConfiguration,
+                pcmcia_request_configuration(link->handle, &link->conf));
+        sprintf(dev->node.dev_name, driver_name);
+        dev->node.major = dev->node.minor = 0;
+        link->dev = &dev->node;
+        printk(KERN_INFO "%s: index 0x%02x: Vcc %d.%d",
+               dev->node.dev_name, link->conf.ConfigIndex,
+               link->conf.Vcc/10, link->conf.Vcc%10);
+        if (link->conf.Vpp1)
+                printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);
+        printk(", irq %d", link->irq.AssignedIRQ);
+        printk(", io 0x%04x-0x%04x", link->io.BasePort1,
+               link->io.BasePort1+link->io.NumPorts1-1);
+        printk("\n");
+        link->state &= ~DEV_CONFIG_PENDING;
+        if (sl811_hc_init(parent, link->io.BasePort1, link->irq.AssignedIRQ)
+                        < 0) {
+cs_failed:
+                printk("sl811_cs_config failed\n");
+                cs_error(link->handle, last_fn, last_ret);
+                sl811_cs_release(link);
+                link->state &= ~DEV_CONFIG_PENDING;
+        }
+}
+static int
+sl811_cs_event(event_t event, int priority, event_callback_args_t *args)
+{
+        dev_link_t *link = args->client_data;
+        DBG(1, "sl811_cs_event(0x%06x)\n", event);
+        switch (event) {
+        case CS_EVENT_CARD_REMOVAL:
+                link->state &= ~DEV_PRESENT;
+                if (link->state & DEV_CONFIG)
+                        sl811_cs_release(link);
+                break;
+        case CS_EVENT_CARD_INSERTION:
+                link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
+                sl811_cs_config(link);
+                break;
+        case CS_EVENT_PM_SUSPEND:
+                link->state |= DEV_SUSPEND;
+                /* Fall through... */
+        case CS_EVENT_RESET_PHYSICAL:
+                if (link->state & DEV_CONFIG)
+                        pcmcia_release_configuration(link->handle);
+                break;
+        case CS_EVENT_PM_RESUME:
+                link->state &= ~DEV_SUSPEND;
+                /* Fall through... */
+        case CS_EVENT_CARD_RESET:
+                if (link->state & DEV_CONFIG)
+                        pcmcia_request_configuration(link->handle, &link->conf);
+                DBG(0, "reset sl811-hcd here?\n");
+                break;
+        }
+        return 0;
+}
+static dev_link_t *sl811_cs_attach(void)
+{
+        local_info_t *local;
+        dev_link_t *link;
+        client_reg_t client_reg;
+        int ret, i;
+        local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
+        if (!local)
+                return NULL;
+        memset(local, 0, sizeof(local_info_t));
+        link = &local->link;
+        link->priv = local;
+        /* Initialize */
+        link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
+        link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
+        if (irq_list[0] == -1)
+                link->irq.IRQInfo2 = irq_mask;
+        else
+                for (i = 0; i < irq_list_count; i++)
+                        link->irq.IRQInfo2 |= 1 << irq_list[i];
+        link->irq.Handler = NULL;
+        link->conf.Attributes = 0;
+        link->conf.Vcc = 33;
+        link->conf.IntType = INT_MEMORY_AND_IO;
+        /* Register with Card Services */
+        link->next = dev_list;
+        dev_list = link;
+        client_reg.dev_info = (dev_info_t *) &driver_name;
+        client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
+        client_reg.EventMask =
+                CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
+                CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
+                CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
+        client_reg.event_handler = &sl811_cs_event;
+        client_reg.Version = 0x0210;
+        client_reg.event_callback_args.client_data = link;
+        ret = pcmcia_register_client(&link->handle, &client_reg);
+        if (ret != CS_SUCCESS) {
+                cs_error(link->handle, RegisterClient, ret);
+                sl811_cs_detach(link);
+                return NULL;
+        }
+        return link;
+}
+static struct pcmcia_driver sl811_cs_driver = {
+        .owner          = THIS_MODULE,
+        .drv            = {
+                .name   = (char *)driver_name,
+        },
+        .attach         = sl811_cs_attach,
+        .detach         = sl811_cs_detach,
+};
+/*====================================================================*/
+static int __init init_sl811_cs(void)
+{
+        return pcmcia_register_driver(&sl811_cs_driver);
+}
+module_init(init_sl811_cs);
+static void __exit exit_sl811_cs(void)
+{
+        pcmcia_unregister_driver(&sl811_cs_driver);
+}
+module_exit(exit_sl811_cs);
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index 869ff73690ac..2d8bd9dcc6ed 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -1315,6 +1315,8 @@ void hid_init_reports(struct hid_device *hid)
 #define USB_DEVICE_ID_WACOM_INTUOS2     0x0040
 #define USB_DEVICE_ID_WACOM_VOLITO      0x0060
 #define USB_DEVICE_ID_WACOM_PTU         0x0003
+#define USB_DEVICE_ID_WACOM_INTUOS3     0x00B0
+#define USB_DEVICE_ID_WACOM_CINTIQ      0x003F
 #define USB_VENDOR_ID_KBGEAR            0x084e
 #define USB_DEVICE_ID_KBGEAR_JAMSTUDIO  0x1001
@@ -1401,6 +1403,7 @@ void hid_init_reports(struct hid_device *hid)
 #define USB_VENDOR_ID_DELORME           0x1163
 #define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100
+#define USB_DEVICE_ID_DELORME_EM_LT20   0x0200
 #define USB_VENDOR_ID_MCC               0x09db
 #define USB_DEVICE_ID_MCC_PMD1024LS     0x0076
@@ -1412,6 +1415,12 @@ void hid_init_reports(struct hid_device *hid)
 #define USB_VENDOR_ID_BTC               0x046e
 #define USB_DEVICE_ID_BTC_KEYBOARD      0x5303
+#define USB_VENDOR_ID_VERNIER           0x08f7
+#define USB_DEVICE_ID_VERNIER_LABPRO    0x0001
+#define USB_DEVICE_ID_VERNIER_GOTEMP    0x0002
+#define USB_DEVICE_ID_VERNIER_SKIP      0x0003
+#define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
 /*
 * Alphabetically sorted blacklist by quirk type.
@@ -1437,6 +1446,7 @@ static struct hid_blacklist {
        { USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOW28, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30, HID_QUIRK_IGNORE },
@@ -1456,6 +1466,10 @@ static struct hid_blacklist {
        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PENPARTNER, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 1, HID_QUIRK_IGNORE },
@@ -1481,6 +1495,10 @@ static struct hid_blacklist {
        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 7, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_VOLITO, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PTU, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS3, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS3 + 1, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS3 + 2, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_CINTIQ, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20, HID_QUIRK_IGNORE },
        { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20, HID_QUIRK_IGNORE },
diff --git a/drivers/usb/media/pwc/ChangeLog b/drivers/usb/media/pwc/ChangeLog
deleted file mode 100644
index b2eb71a9afb5..000000000000
--- a/drivers/usb/media/pwc/ChangeLog
+++ /dev/null
@@ -1,143 +0,0 @@
-9.0.2
-* Adding #ifdef to compile PWC before and after 2.6.5
-9.0.1
-9.0
-8.12
-* Implement motorized pan/tilt feature for Logitech QuickCam Orbit/Spere.
-8.11.1
-* Fix for PCVC720/40, would not be able to set videomode
-* Fix for Samsung MPC models, appearantly they are based on a newer chipset
-8.11
-* 20 dev_hints (per request)
-* Hot unplugging should be better, no more dangling pointers or memory leaks
-* Added reserved Logitech webcam IDs
-* Device now remembers size & fps between close()/open()
-* Removed palette stuff altogether
-8.10.1
-* Added IDs for PCVC720K/40 and Creative Labs Webcam Pro
-8.10
-* Fixed ID for QuickCam Notebook pro
-* Added GREALSIZE ioctl() call
-* Fixed bug in case PWCX was not loaded and invalid size was set
-8.9
-* Merging with kernel 2.5.49
-* Adding IDs for QuickCam Zoom & QuickCam Notebook
-8.8
-* Fixing 'leds' parameter
-* Adding IDs for Logitech QuickCam Pro 4000
-* Making URB init/cleanup a little nicer
-8.7
-* Incorporating changes in ioctl() parameter passing
-* Also changes to URB mechanism
-8.6
-* Added ID's for Visionite VCS UM100 and UC300
-* Removed YUV420-interlaced palette altogether (was confusing)
-* Removed MIRROR stuff as it didn't work anyway
-* Fixed a problem with the 'leds' parameter (wouldn't blink)
-* Added ioctl()s for advanced features: 'extended' whitebalance ioctl()s,
-  CONTOUR, BACKLIGHT, FLICKER, DYNNOISE.
-* VIDIOCGCAP.name now contains real camera model name instead of
-  'Philips xxx webcam'
-* Added PROBE ioctl (see previous point & API doc)
-8.5
-* Adding IDs for Creative Labs Webcam 5
-* Adding IDs for SOTEC CMS-001 webcam
-* Solving possible hang in VIDIOCSYNC when unplugging the cam 
-* Forgot to return structure in VIDIOCPWCGAWB, oops
-* Time interval for the LEDs are now in milliseconds
-8.4
-* Fixing power_save option for Vesta range
-* Handling new error codes in ISOC callback
-* Adding dev_hint module parameter, to specify /dev/videoX device nodes
-8.3
-* Adding Samsung C10 and C30 cameras
-* Removing palette module parameter
-* Fixed typo in ID of QuickCam 3000 Pro
-* Adding LED settings (blinking while in use) for ToUCam cameras.
-* Turns LED off when camera is not in use.
-8.2
-* Making module more silent when trace = 0 
-* Adding QuickCam 3000 Pro IDs
-* Chrominance control for the Vesta cameras
-* Hopefully fixed problems on machines with BIGMEM and > 1GB of RAM
-* Included Oliver Neukem's lock_kernel() patch
-* Allocates less memory for image buffers
-* Adds ioctl()s for the whitebalancing
-8.1
-* Adding support for 750
-* Adding V4L GAUDIO/SAUDIO/UNIT ioctl() calls
-8.0
-* 'damage control' after inclusion in 2.4.5.
-* Changed wait-queue mechanism in read/mmap/poll according to the book.
-* Included YUV420P palette.
-* Changed interface to decompressor module.
-* Cleaned up pwc structure a bit.
-7.0
-* Fixed bug in vcvt_420i_yuyv; extra variables on stack were misaligned.
-* There is now a clear error message when an image size is selected that
-  is only supported using the decompressor, and the decompressor isn't
-  loaded.
-* When the decompressor wasn't loaded, selecting large image size
-  would create skewed or double images.
-6.3
-* Introduced spinlocks for the buffer pointer manipulation; a number of
-  reports seem to suggest the down()/up() semaphores were the cause of
-  lockups, since they are not suitable for interrupt/user locking.
-* Separated decompressor and core code into 2 modules.
-6.2
-* Non-integral image sizes are now padded with gray or black.
-* Added SHUTTERSPEED ioctl().
-* Fixed buglet in VIDIOCPWCSAGC; the function would always return an error,
-  even though the call succeeded.
-* Added hotplug support for 2.4.*.
-* Memory: the 645/646 uses less memory now.
-6.1
-* VIDIOCSPICT returns -EINVAL with invalid palettes.
-* Added saturation control.
-* Split decompressors from rest.
-* Fixed bug that would reset the framerate to the default framerate if 
-  the rate field was set to 0 (which is not what I intended, nl. do not 
-  change the framerate!).
-* VIDIOCPWCSCQUAL (setting compression quality) now takes effect immediately.
-* Workaround for a bug in the 730 sensor.
diff --git a/drivers/usb/net/usbnet.c b/drivers/usb/net/usbnet.c
index 85476e76b244..4cbb408af727 100644
--- a/drivers/usb/net/usbnet.c
+++ b/drivers/usb/net/usbnet.c
@@ -2765,7 +2765,7 @@ static int blan_mdlm_bind (struct usbnet *dev, struct usb_interface *intf)
                        }
                        /* expect bcdVersion 1.0, ignore */
                        if (memcmp(&desc->bGUID, blan_guid, 16)
-                                    && memcmp(&desc->bGUID, blan_guid, 16) ) {
+                                    && memcmp(&desc->bGUID, safe_guid, 16) ) {
                                /* hey, this one might _really_ be MDLM! */
                                dev_dbg (&intf->dev, "MDLM guid\n");
                                goto bad_desc;
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index bc798edf0358..9438909e87a5 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -455,6 +455,17 @@ config USB_SERIAL_XIRCOM
          To compile this driver as a module, choose M here: the
          module will be called keyspan_pda.
+config USB_SERIAL_OPTION
+        tristate "USB Option PCMCIA serial driver"
+        depends on USB_SERIAL && USB_OHCI_HCD && PCCARD
+        help
+          Say Y here if you want to use an Option card. This is a
+          GSM card, controlled by three serial ports which are connected
+          via an OHCI adapter located on a PC card.
+          To compile this driver as a module, choose M here: the
+          module will be called option.
 config USB_SERIAL_OMNINET
        tristate "USB ZyXEL omni.net LCD Plus Driver (EXPERIMENTAL)"
        depends on USB_SERIAL && EXPERIMENTAL
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index d56ff6d86cce..6c7cdcc99a9e 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -32,6 +32,7 @@ obj-$(CONFIG_USB_SERIAL_KLSI)			+= kl5kusb105.o
 obj-$(CONFIG_USB_SERIAL_KOBIL_SCT)              += kobil_sct.o
 obj-$(CONFIG_USB_SERIAL_MCT_U232)               += mct_u232.o
 obj-$(CONFIG_USB_SERIAL_OMNINET)                += omninet.o
+obj-$(CONFIG_USB_SERIAL_OPTION)                 += option.o
 obj-$(CONFIG_USB_SERIAL_PL2303)                 += pl2303.o
 obj-$(CONFIG_USB_SERIAL_SAFE)                   += safe_serial.o
 obj-$(CONFIG_USB_SERIAL_TI)                     += ti_usb_3410_5052.o
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index 7e9bb63eb466..4ace9964fc6b 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -7,6 +7,14 @@
 *      modify it under the terms of the GNU General Public License version
 *      2 as published by the Free Software Foundation.
 *
+ * Support to set flow control line levels using TIOCMGET and TIOCMSET
+ * thanks to Karl Hiramoto karl@hiramoto.org. RTSCTS hardware flow
+ * control thanks to Munir Nassar nassarmu@real-time.com
+ *
+ * Outstanding Issues:
+ *  Buffers are not flushed when the port is opened.
+ *  Multiple calls to write() may fail with "Resource temporarily unavailable"
+ *
 */
 #include <linux/config.h>
@@ -24,7 +32,7 @@
 /*
 * Version Information
 */
-#define DRIVER_VERSION "v0.03"
+#define DRIVER_VERSION "v0.04"
 #define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver"
 /*
@@ -35,6 +43,9 @@ static void cp2101_cleanup(struct usb_serial_port*);
 static void cp2101_close(struct usb_serial_port*, struct file*);
 static void cp2101_get_termios(struct usb_serial_port*);
 static void cp2101_set_termios(struct usb_serial_port*, struct termios*);
+static int cp2101_tiocmget (struct usb_serial_port *, struct file *);
+static int cp2101_tiocmset (struct usb_serial_port *, struct file *,
+                unsigned int, unsigned int);
 static void cp2101_break_ctl(struct usb_serial_port*, int);
 static int cp2101_startup (struct usb_serial *);
 static void cp2101_shutdown(struct usb_serial*);
@@ -43,9 +54,10 @@ static void cp2101_shutdown(struct usb_serial*);
 static int debug;
 static struct usb_device_id id_table [] = {
-        {USB_DEVICE(0x10c4, 0xea60) },  /*Silicon labs factory default*/
+        { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
-        {USB_DEVICE(0x10ab, 0x10c5) },  /*Siemens MC60 Cable*/
+        { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
-        { } /* Terminating Entry*/
+        { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
+        { } /* Terminating Entry */
 };
 MODULE_DEVICE_TABLE (usb, id_table);
@@ -70,32 +82,35 @@ static struct usb_serial_device_type cp2101_device = {
        .close                  = cp2101_close,
        .break_ctl              = cp2101_break_ctl,
        .set_termios            = cp2101_set_termios,
+        .tiocmget               = cp2101_tiocmget,
+        .tiocmset               = cp2101_tiocmset,
        .attach                 = cp2101_startup,
        .shutdown               = cp2101_shutdown,
 };
-/*Config request types*/
+/* Config request types */
 #define REQTYPE_HOST_TO_DEVICE  0x41
 #define REQTYPE_DEVICE_TO_HOST  0xc1
-/*Config SET requests. To GET, add 1 to the request number*/
+/* Config SET requests. To GET, add 1 to the request number */
-#define CP2101_UART             0x00    /*Enable / Disable*/
+#define CP2101_UART             0x00    /* Enable / Disable */
-#define CP2101_BAUDRATE         0x01    /*(BAUD_RATE_GEN_FREQ / baudrate)*/
+#define CP2101_BAUDRATE         0x01    /* (BAUD_RATE_GEN_FREQ / baudrate) */
-#define CP2101_BITS             0x03    /*0x(0)(data bits)(parity)(stop bits)*/
+#define CP2101_BITS             0x03    /* 0x(0)(databits)(parity)(stopbits) */
-#define CP2101_BREAK            0x05    /*On / Off*/
+#define CP2101_BREAK            0x05    /* On / Off */
-#define CP2101_DTRRTS           0x07    /*101 / 202  ???*/
+#define CP2101_CONTROL          0x07    /* Flow control line states */
-#define CP2101_CONFIG_16        0x13    /*16 bytes of config data ???*/
+#define CP2101_MODEMCTL         0x13    /* Modem controls */
-#define CP2101_CONFIG_6         0x19    /*6 bytes of config data ???*/
+#define CP2101_CONFIG_6         0x19    /* 6 bytes of config data ??? */
-/*CP2101_UART*/
+/* CP2101_UART */
 #define UART_ENABLE             0x0001
 #define UART_DISABLE            0x0000
-/*CP2101_BAUDRATE*/
+/* CP2101_BAUDRATE */
 #define BAUD_RATE_GEN_FREQ      0x384000
-/*CP2101_BITS*/
+/* CP2101_BITS */
 #define BITS_DATA_MASK          0X0f00
+#define BITS_DATA_5             0X0500
 #define BITS_DATA_6             0X0600
 #define BITS_DATA_7             0X0700
 #define BITS_DATA_8             0X0800
@@ -112,64 +127,137 @@ static struct usb_serial_device_type cp2101_device = {
 #define BITS_STOP_1             0x0000
 #define BITS_STOP_1_5           0x0001
 #define BITS_STOP_2             0x0002
+/* CP2101_BREAK */
 #define BREAK_ON                0x0000
 #define BREAK_OFF               0x0001
+/* CP2101_CONTROL */
+#define CONTROL_DTR             0x0001
+#define CONTROL_RTS             0x0002
+#define CONTROL_CTS             0x0010
+#define CONTROL_DSR             0x0020
+#define CONTROL_RING            0x0040
+#define CONTROL_DCD             0x0080
+#define CONTROL_WRITE_DTR       0x0100
+#define CONTROL_WRITE_RTS       0x0200
-static int cp2101_get_config(struct usb_serial_port* port, u8 request)
+/*
+ * cp2101_get_config
+ * Reads from the CP2101 configuration registers
+ * 'size' is specified in bytes.
+ * 'data' is a pointer to a pre-allocated array of integers large
+ * enough to hold 'size' bytes (with 4 bytes to each integer)
+ */
+static int cp2101_get_config(struct usb_serial_port* port, u8 request,
+                unsigned int *data, int size)
 {
        struct usb_serial *serial = port->serial;
-        unsigned char buf[4];
+        u32 *buf;
-        unsigned int value;
+        int result, i, length;
-        int result, i;
+        /* Number of integers required to contain the array */
+        length = (((size - 1) | 3) + 1)/4;
+        buf = kmalloc (length * sizeof(u32), GFP_KERNEL);
+        memset(buf, 0, length * sizeof(u32));
+        if (!buf) {
+                dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
+                return -ENOMEM;
+        }
-        /*For get requests, the request number must be incremented*/
+        /* For get requests, the request number must be incremented */
        request++;
-        /*Issue the request, attempting to read 4 bytes*/
+        /* Issue the request, attempting to read 'size' bytes */
        result = usb_control_msg (serial->dev,usb_rcvctrlpipe (serial->dev, 0),
                                request, REQTYPE_DEVICE_TO_HOST, 0x0000,
-                                0, buf, 4, 300);
+                                0, buf, size, 300);
-        if (result < 0) {
+        /* Convert data into an array of integers */
-                dev_err(&port->dev, "%s - Unable to send config request, "
+        for (i=0; i<length; i++)
-                                "request=0x%x result=%d\n",
+                data[i] = le32_to_cpu(buf[i]);
-                                __FUNCTION__, request, result);
-                return result;
-        }
-        /*Assemble each byte read into an integer value*/
+        kfree(buf);
-        value = 0;
-        for (i=0; i<4 && i<result; i++)
-                value |= (buf[i] << (i * 8));
-        dbg( " %s - request=0x%x result=%d value=0x%x",
+        if (result != size) {
-                        __FUNCTION__, request, result, value);
+                dev_err(&port->dev, "%s - Unable to send config request, "
+                                "request=0x%x size=%d result=%d\n",
+                                __FUNCTION__, request, size, result);
+                return -EPROTO;
+        }
-        return value;
+        return 0;
 }
-static int cp2101_set_config(struct usb_serial_port* port, u8 request, u16 value)
+/*
+ * cp2101_set_config
+ * Writes to the CP2101 configuration registers
+ * Values less than 16 bits wide are sent directly
+ * 'size' is specified in bytes.
+ */
+static int cp2101_set_config(struct usb_serial_port* port, u8 request,
+                unsigned int *data, int size)
 {
        struct usb_serial *serial = port->serial;
-        int result;
+        u32 *buf;
-        result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0),
+        int result, i, length;
-                        request, REQTYPE_HOST_TO_DEVICE, value,
-                        0, NULL, 0, 300);
-        if (result <0) {
+        /* Number of integers required to contain the array */
-                dev_err(&port->dev, "%s - Unable to send config request, "
+        length = (((size - 1) | 3) + 1)/4;
-                                "request=0x%x value=0x%x result=%d\n",
-                                __FUNCTION__, request, value, result);
+        buf = kmalloc(length * sizeof(u32), GFP_KERNEL);
-                return result;
+        if (!buf) {
+                dev_err(&port->dev, "%s - out of memory.\n",
+                                __FUNCTION__);
+                return -ENOMEM;
+        }
+        /* Array of integers into bytes */
+        for (i = 0; i < length; i++)
+                buf[i] = cpu_to_le32(data[i]);
+        if (size > 2) {
+                result = usb_control_msg (serial->dev,
+                                usb_sndctrlpipe(serial->dev, 0),
+                                request, REQTYPE_HOST_TO_DEVICE, 0x0000,
+                                0, buf, size, 300);
+        } else {
+                result = usb_control_msg (serial->dev,
+                                usb_sndctrlpipe(serial->dev, 0),
+                                request, REQTYPE_HOST_TO_DEVICE, data[0],
+                                0, NULL, 0, 300);
        }
-        dbg(" %s - request=0x%x value=0x%x result=%d",
+        kfree(buf);
-                        __FUNCTION__, request, value, result);
+        if ((size > 2 && result != size) || result < 0) {
+                dev_err(&port->dev, "%s - Unable to send request, "
+                                "request=0x%x size=%d result=%d\n",
+                                __FUNCTION__, request, size, result);
+                return -EPROTO;
+        }
+        /* Single data value */
+        result = usb_control_msg (serial->dev,
+                        usb_sndctrlpipe(serial->dev, 0),
+                        request, REQTYPE_HOST_TO_DEVICE, data[0],
+                        0, NULL, 0, 300);
        return 0;
 }
+/*
+ * cp2101_set_config_single
+ * Convenience function for calling cp2101_set_config on single data values
+ * without requiring an integer pointer
+ */
+static inline int cp2101_set_config_single(struct usb_serial_port* port,
+                u8 request, unsigned int data)
+{
+        return cp2101_set_config(port, request, &data, 2);
+}
 static int cp2101_open (struct usb_serial_port *port, struct file *filp)
 {
        struct usb_serial *serial = port->serial;
@@ -177,7 +265,7 @@ static int cp2101_open (struct usb_serial_port *port, struct file *filp)
        dbg("%s - port %d", __FUNCTION__, port->number);
-        if (cp2101_set_config(port, CP2101_UART, UART_ENABLE)) {
+        if (cp2101_set_config_single(port, CP2101_UART, UART_ENABLE)) {
                dev_err(&port->dev, "%s - Unable to enable UART\n",
                                __FUNCTION__);
                return -EPROTO;
@@ -198,9 +286,12 @@ static int cp2101_open (struct usb_serial_port *port, struct file *filp)
                return result;
        }
-        /*Configure the termios structure*/
+        /* Configure the termios structure */
        cp2101_get_termios(port);
+        /* Set the DTR and RTS pins low */
+        cp2101_tiocmset(port, NULL, TIOCM_DTR | TIOCM_RTS, 0);
        return 0;
 }
@@ -228,16 +319,18 @@ static void cp2101_close (struct usb_serial_port *port, struct file * filp)
        usb_kill_urb(port->write_urb);
        usb_kill_urb(port->read_urb);
-        cp2101_set_config(port, CP2101_UART, UART_DISABLE);
+        cp2101_set_config_single(port, CP2101_UART, UART_DISABLE);
 }
-/* cp2101_get_termios*/
+/*
-/* Reads the baud rate, data bits, parity and stop bits from the device*/
+ * cp2101_get_termios
-/* Corrects any unsupported values*/
+ * Reads the baud rate, data bits, parity, stop bits and flow control mode
-/* Configures the termios structure to reflect the state of the device*/
+ * from the device, corrects any unsupported values, and configures the
+ * termios structure to reflect the state of the device
+ */
 static void cp2101_get_termios (struct usb_serial_port *port)
 {
-        unsigned int cflag;
+        unsigned int cflag, modem_ctl[4];
        int baud;
        int bits;
@@ -249,15 +342,16 @@ static void cp2101_get_termios (struct usb_serial_port *port)
        }
        cflag = port->tty->termios->c_cflag;
-        baud = cp2101_get_config(port, CP2101_BAUDRATE);
+        cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);
-        /*Convert to baudrate*/
+        /* Convert to baudrate */
        if (baud)
                baud = BAUD_RATE_GEN_FREQ / baud;
        dbg("%s - baud rate = %d", __FUNCTION__, baud);
        cflag &= ~CBAUD;
        switch (baud) {
-                /* The baud rates which are commented out below
+                /*
+                 * The baud rates which are commented out below
                 * appear to be supported by the device
                 * but are non-standard
                 */
@@ -284,14 +378,18 @@ static void cp2101_get_termios (struct usb_serial_port *port)
                        dbg("%s - Baud rate is not supported, "
                                        "using 9600 baud", __FUNCTION__);
                        cflag |= B9600;
-                        cp2101_set_config(port, CP2101_BAUDRATE,
+                        cp2101_set_config_single(port, CP2101_BAUDRATE,
                                        (BAUD_RATE_GEN_FREQ/9600));
                        break;
        }
-        bits = cp2101_get_config(port, CP2101_BITS);
+        cp2101_get_config(port, CP2101_BITS, &bits, 2);
        cflag &= ~CSIZE;
        switch(bits & BITS_DATA_MASK) {
+                case BITS_DATA_5:
+                        dbg("%s - data bits = 5", __FUNCTION__);
+                        cflag |= CS5;
+                        break;
                case BITS_DATA_6:
                        dbg("%s - data bits = 6", __FUNCTION__);
                        cflag |= CS6;
@@ -310,7 +408,7 @@ static void cp2101_get_termios (struct usb_serial_port *port)
                        cflag |= CS8;
                        bits &= ~BITS_DATA_MASK;
                        bits |= BITS_DATA_8;
-                        cp2101_set_config(port, CP2101_BITS, bits);
+                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
                default:
                        dbg("%s - Unknown number of data bits, "
@@ -318,7 +416,7 @@ static void cp2101_get_termios (struct usb_serial_port *port)
                        cflag |= CS8;
                        bits &= ~BITS_DATA_MASK;
                        bits |= BITS_DATA_8;
-                        cp2101_set_config(port, CP2101_BITS, bits);
+                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
        }
@@ -341,21 +439,21 @@ static void cp2101_get_termios (struct usb_serial_port *port)
                                        "disabling parity)", __FUNCTION__);
                        cflag &= ~PARENB;
                        bits &= ~BITS_PARITY_MASK;
-                        cp2101_set_config(port, CP2101_BITS, bits);
+                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
                case BITS_PARITY_SPACE:
                        dbg("%s - parity = SPACE (not supported, "
                                        "disabling parity)", __FUNCTION__);
                        cflag &= ~PARENB;
                        bits &= ~BITS_PARITY_MASK;
-                        cp2101_set_config(port, CP2101_BITS, bits);
+                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
                default:
                        dbg("%s - Unknown parity mode, "
                                        "disabling parity", __FUNCTION__);
                        cflag &= ~PARENB;
                        bits &= ~BITS_PARITY_MASK;
-                        cp2101_set_config(port, CP2101_BITS, bits);
+                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
        }
@@ -366,9 +464,9 @@ static void cp2101_get_termios (struct usb_serial_port *port)
                        break;
                case BITS_STOP_1_5:
                        dbg("%s - stop bits = 1.5 (not supported, "
-                                        "using 1 stop bit", __FUNCTION__);
+                                        "using 1 stop bit)", __FUNCTION__);
                        bits &= ~BITS_STOP_MASK;
-                        cp2101_set_config(port, CP2101_BITS, bits);
+                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
                case BITS_STOP_2:
                        dbg("%s - stop bits = 2", __FUNCTION__);
@@ -378,10 +476,19 @@ static void cp2101_get_termios (struct usb_serial_port *port)
                        dbg("%s - Unknown number of stop bits, "
                                        "using 1 stop bit", __FUNCTION__);
                        bits &= ~BITS_STOP_MASK;
-                        cp2101_set_config(port, CP2101_BITS, bits);
+                        cp2101_set_config(port, CP2101_BITS, &bits, 2);
                        break;
        }
+        cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
+        if (modem_ctl[0] & 0x0008) {
+                dbg("%s - flow control = CRTSCTS", __FUNCTION__);
+                cflag |= CRTSCTS;
+        } else {
+                dbg("%s - flow control = NONE", __FUNCTION__);
+                cflag &= ~CRTSCTS;
+        }
        port->tty->termios->c_cflag = cflag;
 }
@@ -389,8 +496,8 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                struct termios *old_termios)
 {
        unsigned int cflag, old_cflag=0;
-        int baud=0;
+        int baud=0, bits;
-        int bits;
+        unsigned int modem_ctl[4];
        dbg("%s - port %d", __FUNCTION__, port->number);
@@ -400,7 +507,7 @@ static void cp2101_set_termios (struct usb_serial_port *port,
        }
        cflag = port->tty->termios->c_cflag;
-        /* check that they really want us to change something */
+        /* Check that they really want us to change something */
        if (old_termios) {
                if ((cflag == old_termios->c_cflag) &&
                                (RELEVANT_IFLAG(port->tty->termios->c_iflag)
@@ -415,7 +522,8 @@ static void cp2101_set_termios (struct usb_serial_port *port,
        /* If the baud rate is to be updated*/
        if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
                switch (cflag & CBAUD) {
-                        /* The baud rates which are commented out below
+                        /*
+                         * The baud rates which are commented out below
                         * appear to be supported by the device
                         * but are non-standard
                         */
@@ -448,18 +556,22 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                if (baud) {
                        dbg("%s - Setting baud rate to %d baud", __FUNCTION__,
                                        baud);
-                        if (cp2101_set_config(port, CP2101_BAUDRATE,
+                        if (cp2101_set_config_single(port, CP2101_BAUDRATE,
                                                (BAUD_RATE_GEN_FREQ / baud)))
                                dev_err(&port->dev, "Baud rate requested not "
                                                "supported by device\n");
                }
        }
-        /*If the number of data bits is to be updated*/
+        /* If the number of data bits is to be updated */
        if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
-                bits = cp2101_get_config(port, CP2101_BITS);
+                cp2101_get_config(port, CP2101_BITS, &bits, 2);
                bits &= ~BITS_DATA_MASK;
                switch (cflag & CSIZE) {
+                        case CS5:
+                                bits |= BITS_DATA_5;
+                                dbg("%s - data bits = 5", __FUNCTION__);
+                                break;
                        case CS6:
                                bits |= BITS_DATA_6;
                                dbg("%s - data bits = 6", __FUNCTION__);
@@ -483,13 +595,13 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                                bits |= BITS_DATA_8;
                                break;
                }
-                if (cp2101_set_config(port, CP2101_BITS, bits))
+                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
                        dev_err(&port->dev, "Number of data bits requested "
                                        "not supported by device\n");
        }
        if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))) {
-                bits = cp2101_get_config(port, CP2101_BITS);
+                cp2101_get_config(port, CP2101_BITS, &bits, 2);
                bits &= ~BITS_PARITY_MASK;
                if (cflag & PARENB) {
                        if (cflag & PARODD) {
@@ -500,13 +612,13 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                                dbg("%s - parity = EVEN", __FUNCTION__);
                        }
                }
-                if (cp2101_set_config(port, CP2101_BITS, bits))
+                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
                        dev_err(&port->dev, "Parity mode not supported "
                                        "by device\n");
        }
        if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
-                bits = cp2101_get_config(port, CP2101_BITS);
+                cp2101_get_config(port, CP2101_BITS, &bits, 2);
                bits &= ~BITS_STOP_MASK;
                if (cflag & CSTOPB) {
                        bits |= BITS_STOP_2;
@@ -515,15 +627,90 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                        bits |= BITS_STOP_1;
                        dbg("%s - stop bits = 1", __FUNCTION__);
                }
-                if (cp2101_set_config(port, CP2101_BITS, bits))
+                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
                        dev_err(&port->dev, "Number of stop bits requested "
                                        "not supported by device\n");
        }
+        if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
+                cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
+                dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
+                                __FUNCTION__, modem_ctl[0], modem_ctl[1],
+                                modem_ctl[2], modem_ctl[3]);
+                if (cflag & CRTSCTS) {
+                        modem_ctl[0] &= ~0x7B;
+                        modem_ctl[0] |= 0x09;
+                        modem_ctl[1] = 0x80;
+                        dbg("%s - flow control = CRTSCTS", __FUNCTION__);
+                } else {
+                        modem_ctl[0] &= ~0x7B;
+                        modem_ctl[0] |= 0x01;
+                        modem_ctl[1] |= 0x40;
+                        dbg("%s - flow control = NONE", __FUNCTION__);
+                }
+                dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
+                                __FUNCTION__, modem_ctl[0], modem_ctl[1],
+                                modem_ctl[2], modem_ctl[3]);
+                cp2101_set_config(port, CP2101_MODEMCTL, modem_ctl, 16);
+        }
+}
+static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
+                unsigned int set, unsigned int clear)
+{
+        int control = 0;
+        dbg("%s - port %d", __FUNCTION__, port->number);
+        if (set & TIOCM_RTS) {
+                control |= CONTROL_RTS;
+                control |= CONTROL_WRITE_RTS;
+        }
+        if (set & TIOCM_DTR) {
+                control |= CONTROL_DTR;
+                control |= CONTROL_WRITE_DTR;
+        }
+        if (clear & TIOCM_RTS) {
+                control &= ~CONTROL_RTS;
+                control |= CONTROL_WRITE_RTS;
+        }
+        if (clear & TIOCM_DTR) {
+                control &= ~CONTROL_DTR;
+                control |= CONTROL_WRITE_DTR;
+        }
+        dbg("%s - control = 0x%.4x", __FUNCTION__, control);
+        return cp2101_set_config(port, CP2101_CONTROL, &control, 2);
+}
+static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
+{
+        int control, result;
+        dbg("%s - port %d", __FUNCTION__, port->number);
+        cp2101_get_config(port, CP2101_CONTROL, &control, 1);
+        result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
+                |((control & CONTROL_RTS) ? TIOCM_RTS : 0)
+                |((control & CONTROL_CTS) ? TIOCM_CTS : 0)
+                |((control & CONTROL_DSR) ? TIOCM_DSR : 0)
+                |((control & CONTROL_RING)? TIOCM_RI  : 0)
+                |((control & CONTROL_DCD) ? TIOCM_CD  : 0);
+        dbg("%s - control = 0x%.2x", __FUNCTION__, control);
+        return result;
 }
 static void cp2101_break_ctl (struct usb_serial_port *port, int break_state)
 {
-        u16 state;
+        int state;
        dbg("%s - port %d", __FUNCTION__, port->number);
        if (break_state == 0)
@@ -532,12 +719,12 @@ static void cp2101_break_ctl (struct usb_serial_port *port, int break_state)
                state = BREAK_ON;
        dbg("%s - turning break %s", __FUNCTION__,
                        state==BREAK_OFF ? "off" : "on");
-        cp2101_set_config(port, CP2101_BREAK, state);
+        cp2101_set_config(port, CP2101_BREAK, &state, 2);
 }
 static int cp2101_startup (struct usb_serial *serial)
 {
-        /*CP2101 buffers behave strangely unless device is reset*/
+        /* CP2101 buffers behave strangely unless device is reset */
        usb_reset_device(serial->dev);
        return 0;
 }
@@ -548,7 +735,7 @@ static void cp2101_shutdown (struct usb_serial *serial)
        dbg("%s", __FUNCTION__);
-        /* stop reads and writes on all ports */
+        /* Stop reads and writes on all ports */
        for (i=0; i < serial->num_ports; ++i) {
                cp2101_cleanup(serial->port[i]);
        }
@@ -560,16 +747,16 @@ static int __init cp2101_init (void)
        retval = usb_serial_register(&cp2101_device);
        if (retval)
-                return retval; /*Failed to register*/
+                return retval; /* Failed to register */
        retval = usb_register(&cp2101_driver);
        if (retval) {
-                /*Failed to register*/
+                /* Failed to register */
                usb_serial_deregister(&cp2101_device);
                return retval;
        }
-        /*Success*/
+        /* Success */
        info(DRIVER_DESC " " DRIVER_VERSION);
        return 0;
 }
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 52394f08a947..051c3a77b41b 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -364,6 +364,7 @@ static struct usb_device_id id_table_8U232AM [] = {
        { USB_DEVICE_VER(FTDI_VID, PROTEGO_SPECIAL_3, 0, 0x3ff) },
        { USB_DEVICE_VER(FTDI_VID, PROTEGO_SPECIAL_4, 0, 0x3ff) },
        { USB_DEVICE_VER(FTDI_VID, FTDI_ELV_UO100_PID, 0, 0x3ff) },
+        { USB_DEVICE_VER(FTDI_VID, FTDI_ELV_UM100_PID, 0, 0x3ff) },
        { USB_DEVICE_VER(FTDI_VID, INSIDE_ACCESSO, 0, 0x3ff) },
        { USB_DEVICE_VER(INTREPID_VID, INTREPID_VALUECAN_PID, 0, 0x3ff) },
        { USB_DEVICE_VER(INTREPID_VID, INTREPID_NEOVI_PID, 0, 0x3ff) },
@@ -475,6 +476,7 @@ static struct usb_device_id id_table_FT232BM [] = {
        { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88E_PID, 0x400, 0xffff) },
        { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88F_PID, 0x400, 0xffff) },
        { USB_DEVICE_VER(FTDI_VID, FTDI_ELV_UO100_PID, 0x400, 0xffff) },
+        { USB_DEVICE_VER(FTDI_VID, FTDI_ELV_UM100_PID, 0x400, 0xffff) },
        { USB_DEVICE_VER(FTDI_VID, LINX_SDMUSBQSS_PID, 0x400, 0xffff) },
        { USB_DEVICE_VER(FTDI_VID, LINX_MASTERDEVEL2_PID, 0x400, 0xffff) },
        { USB_DEVICE_VER(FTDI_VID, LINX_FUTURE_0_PID, 0x400, 0xffff) },
@@ -618,6 +620,7 @@ static struct usb_device_id id_table_combined [] = {
        { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88E_PID, 0x400, 0xffff) },
        { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88F_PID, 0x400, 0xffff) },
        { USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
        { USB_DEVICE_VER(FTDI_VID, LINX_SDMUSBQSS_PID, 0x400, 0xffff) },
        { USB_DEVICE_VER(FTDI_VID, LINX_MASTERDEVEL2_PID, 0x400, 0xffff) },
        { USB_DEVICE_VER(FTDI_VID, LINX_FUTURE_0_PID, 0x400, 0xffff) },
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index a52bb13a9ce4..8866376823a5 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -144,6 +144,8 @@
 /* ELV USB Module UO100 (PID sent by Stefan Frings) */
 #define FTDI_ELV_UO100_PID      0xFB58  /* Product Id */
+/* ELV USB Module UM100 (PID sent by Arnim Laeuger) */
+#define FTDI_ELV_UM100_PID      0xFB5A  /* Product Id */
 /*
 * Definitions for ID TECH (www.idt-net.com) devices
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
new file mode 100644
index 000000000000..b722175f108f
--- /dev/null
+++ b/drivers/usb/serial/option.c
@@ -0,0 +1,729 @@
+/*
+  Option Card (PCMCIA to) USB to Serial Driver
+  Copyright (C) 2005  Matthias Urlichs <smurf@smurf.noris.de>
+  This driver is free software; you can redistribute it and/or modify
+  it under the terms of Version 2 of the GNU General Public License as
+  published by the Free Software Foundation.
+  Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org>
+  History:
+  2005-05-19  v0.1   Initial version, based on incomplete docs
+                     and analysis of misbehavior of the standard driver
+  2005-05-20  v0.2   Extended the input buffer to avoid losing
+                     random 64-byte chunks of data
+  2005-05-21  v0.3   implemented chars_in_buffer()
+                     turned on low_latency
+                     simplified the code somewhat
+*/
+#define DRIVER_VERSION "v0.3"
+#define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>"
+#define DRIVER_DESC "Option Card (PC-Card to) USB to Serial Driver"
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/jiffies.h>
+#include <linux/errno.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include "usb-serial.h"
+/* Function prototypes */
+static int  option_open (struct usb_serial_port *port, struct file *filp);
+static void option_close (struct usb_serial_port *port, struct file *filp);
+static int  option_startup (struct usb_serial *serial);
+static void option_shutdown (struct usb_serial *serial);
+static void option_rx_throttle (struct usb_serial_port *port);
+static void option_rx_unthrottle (struct usb_serial_port *port);
+static int  option_write_room (struct usb_serial_port *port);
+static void option_instat_callback(struct urb *urb, struct pt_regs *regs);
+static int  option_write (struct usb_serial_port *port,
+                          const unsigned char *buf, int count);
+static int  option_chars_in_buffer (struct usb_serial_port *port);
+static int  option_ioctl (struct usb_serial_port *port, struct file *file,
+                          unsigned int cmd, unsigned long arg);
+static void option_set_termios (struct usb_serial_port *port,
+                                struct termios *old);
+static void option_break_ctl (struct usb_serial_port *port, int break_state);
+static int  option_tiocmget (struct usb_serial_port *port, struct file *file);
+static int  option_tiocmset (struct usb_serial_port *port, struct file *file,
+                             unsigned int set, unsigned int clear);
+static int  option_send_setup (struct usb_serial_port *port);
+/* Vendor and product IDs */
+#define OPTION_VENDOR_ID                0x0AF0
+#define OPTION_PRODUCT_OLD              0x5000
+#define OPTION_PRODUCT_WLAN             0x6000
+static struct usb_device_id option_ids[] = {
+        { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
+        { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_WLAN) },
+        { } /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, option_ids);
+static struct usb_driver option_driver = {
+        .owner      = THIS_MODULE,
+        .name       = "option",
+        .probe      = usb_serial_probe,
+        .disconnect = usb_serial_disconnect,
+        .id_table   = option_ids,
+};
+/* The card has three separate interfaces, wich the serial driver
+ * recognizes separately, thus num_port=1.
+ */
+static struct usb_serial_device_type option_3port_device = {
+        .owner                  = THIS_MODULE,
+        .name                   = "Option 3-port card",
+        .short_name             = "option",
+        .id_table               = option_ids,
+        .num_interrupt_in       = NUM_DONT_CARE,
+        .num_bulk_in            = NUM_DONT_CARE,
+        .num_bulk_out           = NUM_DONT_CARE,
+        .num_ports              = 1, /* 3 */
+        .open                   = option_open,
+        .close                  = option_close,
+        .write                  = option_write,
+        .write_room             = option_write_room,
+        .chars_in_buffer        = option_chars_in_buffer,
+        .throttle               = option_rx_throttle,
+        .unthrottle             = option_rx_unthrottle,
+        .ioctl                  = option_ioctl,
+        .set_termios            = option_set_termios,
+        .break_ctl              = option_break_ctl,
+        .tiocmget               = option_tiocmget,
+        .tiocmset               = option_tiocmset,
+        .attach                 = option_startup,
+        .shutdown               = option_shutdown,
+        .read_int_callback      = option_instat_callback,
+};
+static int debug;
+/* per port private data */
+#define N_IN_URB        4
+#define N_OUT_URB       1
+#define IN_BUFLEN       1024
+#define OUT_BUFLEN      1024
+struct option_port_private {
+        /* Input endpoints and buffer for this port */
+        struct urb      *in_urbs[N_IN_URB];
+        char            in_buffer[N_IN_URB][IN_BUFLEN];
+        /* Output endpoints and buffer for this port */
+        struct urb      *out_urbs[N_OUT_URB];
+        char            out_buffer[N_OUT_URB][OUT_BUFLEN];
+        /* Settings for the port */
+        int             rts_state;      /* Handshaking pins (outputs) */
+        int             dtr_state;
+        int             cts_state;      /* Handshaking pins (inputs) */
+        int             dsr_state;
+        int             dcd_state;
+        int             ri_state;
+        // int          break_on;
+        unsigned long   tx_start_time[N_OUT_URB];
+};
+/* Functions used by new usb-serial code. */
+static int __init
+option_init (void)
+{
+        int retval;
+        retval = usb_serial_register(&option_3port_device);
+        if (retval)
+                goto failed_3port_device_register;
+        retval = usb_register(&option_driver);
+        if (retval)
+                goto failed_driver_register;
+        info(DRIVER_DESC ": " DRIVER_VERSION);
+        return 0;
+failed_driver_register:
+        usb_serial_deregister (&option_3port_device);
+failed_3port_device_register:
+        return retval;
+}
+static void __exit
+option_exit (void)
+{
+        usb_deregister (&option_driver);
+        usb_serial_deregister (&option_3port_device);
+}
+module_init(option_init);
+module_exit(option_exit);
+static void
+option_rx_throttle (struct usb_serial_port *port)
+{
+        dbg("%s", __FUNCTION__);
+}
+static void
+option_rx_unthrottle (struct usb_serial_port *port)
+{
+        dbg("%s", __FUNCTION__);
+}
+static void
+option_break_ctl (struct usb_serial_port *port, int break_state)
+{
+        /* Unfortunately, I don't know how to send a break */
+        dbg("%s", __FUNCTION__);
+}
+static void
+option_set_termios (struct usb_serial_port *port,
+                                     struct termios *old_termios)
+{
+        dbg("%s", __FUNCTION__);
+        option_send_setup(port);
+}
+static int
+option_tiocmget(struct usb_serial_port *port, struct file *file)
+{
+        unsigned int                    value;
+        struct option_port_private      *portdata;
+        portdata = usb_get_serial_port_data(port);
+        value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
+                ((portdata->dtr_state) ? TIOCM_DTR : 0) |
+                ((portdata->cts_state) ? TIOCM_CTS : 0) |
+                ((portdata->dsr_state) ? TIOCM_DSR : 0) |
+                ((portdata->dcd_state) ? TIOCM_CAR : 0) |
+                ((portdata->ri_state) ? TIOCM_RNG : 0);
+        return value;
+}
+static int
+option_tiocmset (struct usb_serial_port *port, struct file *file,
+                 unsigned int set, unsigned int clear)
+{
+        struct option_port_private      *portdata;
+        portdata = usb_get_serial_port_data(port);
+        if (set & TIOCM_RTS)
+                portdata->rts_state = 1;
+        if (set & TIOCM_DTR)
+                portdata->dtr_state = 1;
+        if (clear & TIOCM_RTS)
+                portdata->rts_state = 0;
+        if (clear & TIOCM_DTR)
+                portdata->dtr_state = 0;
+        return option_send_setup(port);
+}
+static int
+option_ioctl (struct usb_serial_port *port, struct file *file,
+              unsigned int cmd, unsigned long arg)
+{
+        return -ENOIOCTLCMD;
+}
+/* Write */
+static int
+option_write(struct usb_serial_port *port,
+                         const unsigned char *buf, int count)
+{
+        struct option_port_private      *portdata;
+        int                             i;
+        int                             left, todo;
+        struct urb                      *this_urb = NULL; /* spurious */
+        int                             err;
+        portdata = usb_get_serial_port_data(port);
+        dbg("%s: write (%d chars)", __FUNCTION__, count);
+#if 0
+        spin_lock(&port->lock);
+        if (port->write_urb_busy) {
+                spin_unlock(&port->lock);
+                dbg("%s: already writing", __FUNCTION__);
+                return 0;
+        }
+        port->write_urb_busy = 1;
+        spin_unlock(&port->lock);
+#endif
+        i = 0;
+        left = count;
+        while (left>0) {
+                todo = left;
+                if (todo > OUT_BUFLEN)
+                        todo = OUT_BUFLEN;
+                for (;i < N_OUT_URB; i++) {
+                        /* Check we have a valid urb/endpoint before we use it... */
+                        this_urb = portdata->out_urbs[i];
+                        if (this_urb->status != -EINPROGRESS)
+                                break;
+                        if (this_urb->transfer_flags & URB_ASYNC_UNLINK)
+                                continue;
+                        if (time_before(jiffies, portdata->tx_start_time[i] + 10 * HZ))
+                                continue;
+                        this_urb->transfer_flags |= URB_ASYNC_UNLINK;
+                        usb_unlink_urb(this_urb);
+                }
+                if (i == N_OUT_URB) {
+                        /* no bulk out free! */
+                        dbg("%s: no output urb -- left %d", __FUNCTION__,count-left);
+#if 0
+                        port->write_urb_busy = 0;
+#endif
+                        return count-left;
+                }
+                dbg("%s: endpoint %d buf %d", __FUNCTION__, usb_pipeendpoint(this_urb->pipe), i);
+                memcpy (this_urb->transfer_buffer, buf, todo);
+                /* send the data out the bulk port */
+                this_urb->transfer_buffer_length = todo;
+                this_urb->transfer_flags &= ~URB_ASYNC_UNLINK;
+                this_urb->dev = port->serial->dev;
+                err = usb_submit_urb(this_urb, GFP_ATOMIC);
+                if (err) {
+                        dbg("usb_submit_urb %p (write bulk) failed (%d,, has %d)", this_urb, err, this_urb->status);
+                        continue;
+                }
+                portdata->tx_start_time[i] = jiffies;
+                buf += todo;
+                left -= todo;
+        }
+        count -= left;
+#if 0
+        port->write_urb_busy = 0;
+#endif
+        dbg("%s: wrote (did %d)", __FUNCTION__, count);
+        return count;
+}
+static void
+option_indat_callback (struct urb *urb, struct pt_regs *regs)
+{
+        int     i, err;
+        int endpoint;
+        struct usb_serial_port *port;
+        struct tty_struct *tty;
+        unsigned char *data = urb->transfer_buffer;
+        dbg("%s: %p", __FUNCTION__, urb);
+        endpoint = usb_pipeendpoint(urb->pipe);
+        port = (struct usb_serial_port *) urb->context;
+        if (urb->status) {
+                dbg("%s: nonzero status: %d on endpoint %02x.",
+                    __FUNCTION__, urb->status, endpoint);
+        } else {
+                tty = port->tty;
+                if (urb->actual_length) {
+                        for (i = 0; i < urb->actual_length ; ++i) {
+                                if (tty->flip.count >= TTY_FLIPBUF_SIZE)
+                                        tty_flip_buffer_push(tty);
+                                tty_insert_flip_char(tty, data[i], 0);
+                        }
+                        tty_flip_buffer_push(tty);
+                } else {
+                        dbg("%s: empty read urb received", __FUNCTION__);
+                }
+                /* Resubmit urb so we continue receiving */
+                if (port->open_count && urb->status != -ESHUTDOWN) {
+                        err = usb_submit_urb(urb, GFP_ATOMIC);
+                        if (err)
+                                printk(KERN_ERR "%s: resubmit read urb failed. (%d)", __FUNCTION__, err);
+                }
+        }
+        return;
+}
+static void
+option_outdat_callback (struct urb *urb, struct pt_regs *regs)
+{
+        struct usb_serial_port *port;
+        dbg("%s", __FUNCTION__);
+        port = (struct usb_serial_port *) urb->context;
+        if (port->open_count)
+                schedule_work(&port->work);
+}
+static void
+option_instat_callback (struct urb *urb, struct pt_regs *regs)
+{
+        int err;
+        struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
+        struct option_port_private *portdata = usb_get_serial_port_data(port);
+        struct usb_serial *serial = port->serial;
+        dbg("%s", __FUNCTION__);
+        dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
+        if (urb->status == 0) {
+                struct usb_ctrlrequest *req_pkt =
+                                (struct usb_ctrlrequest *)urb->transfer_buffer;
+                if (!req_pkt) {
+                        dbg("%s: NULL req_pkt\n", __FUNCTION__);
+                        return;
+                }
+                if ((req_pkt->bRequestType == 0xA1) && (req_pkt->bRequest == 0x20)) {
+                        int old_dcd_state;
+                        unsigned char signals = *((unsigned char *)
+                                        urb->transfer_buffer + sizeof(struct usb_ctrlrequest));
+                        dbg("%s: signal x%x", __FUNCTION__, signals);
+                        old_dcd_state = portdata->dcd_state;
+                        portdata->cts_state = 1;
+                        portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
+                        portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
+                        portdata->ri_state = ((signals & 0x08) ? 1 : 0);
+                        if (port->tty && !C_CLOCAL(port->tty)
+                                        && old_dcd_state && !portdata->dcd_state) {
+                                tty_hangup(port->tty);
+                        }
+                } else
+                        dbg("%s: type %x req %x", __FUNCTION__, req_pkt->bRequestType,req_pkt->bRequest);
+        } else
+                dbg("%s: error %d", __FUNCTION__, urb->status);
+        /* Resubmit urb so we continue receiving IRQ data */
+        if (urb->status != -ESHUTDOWN) {
+                urb->dev = serial->dev;
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (err)
+                        dbg("%s: resubmit intr urb failed. (%d)", __FUNCTION__, err);
+        }
+}
+static int
+option_write_room (struct usb_serial_port *port)
+{
+        struct option_port_private *portdata;
+        int i;
+        int data_len = 0;
+        struct urb *this_urb;
+        portdata = usb_get_serial_port_data(port);
+        for (i=0; i < N_OUT_URB; i++)
+                this_urb = portdata->out_urbs[i];
+                if (this_urb && this_urb->status != -EINPROGRESS)
+                        data_len += OUT_BUFLEN;
+        dbg("%s: %d", __FUNCTION__, data_len);
+        return data_len;
+}
+static int
+option_chars_in_buffer (struct usb_serial_port *port)
+{
+        struct option_port_private *portdata;
+        int i;
+        int data_len = 0;
+        struct urb *this_urb;
+        portdata = usb_get_serial_port_data(port);
+        for (i=0; i < N_OUT_URB; i++)
+                this_urb = portdata->out_urbs[i];
+                if (this_urb && this_urb->status == -EINPROGRESS)
+                        data_len += this_urb->transfer_buffer_length;
+        dbg("%s: %d", __FUNCTION__, data_len);
+        return data_len;
+}
+static int
+option_open (struct usb_serial_port *port, struct file *filp)
+{
+        struct option_port_private      *portdata;
+        struct usb_serial               *serial = port->serial;
+        int                             i, err;
+        struct urb                      *urb;
+        portdata = usb_get_serial_port_data(port);
+        dbg("%s", __FUNCTION__);
+        /* Set some sane defaults */
+        portdata->rts_state = 1;
+        portdata->dtr_state = 1;
+        /* Reset low level data toggle and start reading from endpoints */
+        for (i = 0; i < N_IN_URB; i++) {
+                urb = portdata->in_urbs[i];
+                if (! urb)
+                        continue;
+                if (urb->dev != serial->dev) {
+                        dbg("%s: dev %p != %p", __FUNCTION__, urb->dev, serial->dev);
+                        continue;
+                }
+                /* make sure endpoint data toggle is synchronized with the device */
+                usb_clear_halt(urb->dev, urb->pipe);
+                err = usb_submit_urb(urb, GFP_KERNEL);
+                if (err) {
+                        dbg("%s: submit urb %d failed (%d) %d", __FUNCTION__, i, err,
+                                urb->transfer_buffer_length);
+                }
+        }
+        /* Reset low level data toggle on out endpoints */
+        for (i = 0; i < N_OUT_URB; i++) {
+                urb = portdata->out_urbs[i];
+                if (! urb)
+                        continue;
+                urb->dev = serial->dev;
+                /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe), 0); */
+        }
+        port->tty->low_latency = 1;
+        option_send_setup(port);
+        return (0);
+}
+static inline void
+stop_urb(struct urb *urb)
+{
+        if (urb && urb->status == -EINPROGRESS) {
+                urb->transfer_flags &= ~URB_ASYNC_UNLINK;
+                usb_kill_urb(urb);
+        }
+}
+static void
+option_close(struct usb_serial_port *port, struct file *filp)
+{
+        int                     i;
+        struct usb_serial       *serial = port->serial;
+        struct option_port_private      *portdata;
+        dbg("%s", __FUNCTION__);
+        portdata = usb_get_serial_port_data(port);
+        portdata->rts_state = 0;
+        portdata->dtr_state = 0;
+        if (serial->dev) {
+                option_send_setup(port);
+                /* Stop reading/writing urbs */
+                for (i = 0; i < N_IN_URB; i++)
+                        stop_urb(portdata->in_urbs[i]);
+                for (i = 0; i < N_OUT_URB; i++)
+                        stop_urb(portdata->out_urbs[i]);
+        }
+        port->tty = NULL;
+}
+/* Helper functions used by option_setup_urbs */
+static struct urb *
+option_setup_urb (struct usb_serial *serial, int endpoint,
+                  int dir, void *ctx, char *buf, int len,
+                  void (*callback)(struct urb *, struct pt_regs *regs))
+{
+        struct urb *urb;
+        if (endpoint == -1)
+                return NULL;            /* endpoint not needed */
+        urb = usb_alloc_urb(0, GFP_KERNEL);             /* No ISO */
+        if (urb == NULL) {
+                dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
+                return NULL;
+        }
+                /* Fill URB using supplied data. */
+        usb_fill_bulk_urb(urb, serial->dev,
+                      usb_sndbulkpipe(serial->dev, endpoint) | dir,
+                      buf, len, callback, ctx);
+        return urb;
+}
+/* Setup urbs */
+static void
+option_setup_urbs(struct usb_serial *serial)
+{
+        int                             j;
+        struct usb_serial_port          *port;
+        struct option_port_private      *portdata;
+        dbg("%s", __FUNCTION__);
+        port = serial->port[0];
+        portdata = usb_get_serial_port_data(port);
+        /* Do indat endpoints first */
+        for (j = 0; j <= N_IN_URB; ++j) {
+                portdata->in_urbs[j] = option_setup_urb (serial,
+                  port->bulk_in_endpointAddress, USB_DIR_IN, port,
+                  portdata->in_buffer[j], IN_BUFLEN, option_indat_callback);
+        }
+        /* outdat endpoints */
+        for (j = 0; j <= N_OUT_URB; ++j) {
+                portdata->out_urbs[j] = option_setup_urb (serial,
+                  port->bulk_out_endpointAddress, USB_DIR_OUT, port,
+                  portdata->out_buffer[j], OUT_BUFLEN, option_outdat_callback);
+        }
+}
+static int
+option_send_setup(struct usb_serial_port *port)
+{
+        struct usb_serial *serial = port->serial;
+        struct option_port_private *portdata;
+        dbg("%s", __FUNCTION__);
+        portdata = usb_get_serial_port_data(port);
+        if (port->tty) {
+                int val = 0;
+                if (portdata->dtr_state)
+                        val |= 0x01;
+                if (portdata->rts_state)
+                        val |= 0x02;
+                return usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
+                                        0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
+        }
+        return 0;
+}
+static int
+option_startup (struct usb_serial *serial)
+{
+        int                             i, err;
+        struct usb_serial_port          *port;
+        struct option_port_private      *portdata;
+        dbg("%s", __FUNCTION__);
+        /* Now setup per port private data */
+        for (i = 0; i < serial->num_ports; i++) {
+                port = serial->port[i];
+                portdata = kmalloc(sizeof(struct option_port_private), GFP_KERNEL);
+                if (!portdata) {
+                        dbg("%s: kmalloc for option_port_private (%d) failed!.", __FUNCTION__, i);
+                        return (1);
+                }
+                memset(portdata, 0, sizeof(struct option_port_private));
+                usb_set_serial_port_data(port, portdata);
+                if (! port->interrupt_in_urb)
+                        continue;
+                err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
+                if (err)
+                        dbg("%s: submit irq_in urb failed %d", __FUNCTION__, err);
+        }
+        option_setup_urbs(serial);
+        return (0);
+}
+static void
+option_shutdown (struct usb_serial *serial)
+{
+        int                             i, j;
+        struct usb_serial_port          *port;
+        struct option_port_private      *portdata;
+        dbg("%s", __FUNCTION__);
+        /* Stop reading/writing urbs */
+        for (i = 0; i < serial->num_ports; ++i) {
+                port = serial->port[i];
+                portdata = usb_get_serial_port_data(port);
+                for (j = 0; j < N_IN_URB; j++)
+                        stop_urb(portdata->in_urbs[j]);
+                for (j = 0; j < N_OUT_URB; j++)
+                        stop_urb(portdata->out_urbs[j]);
+        }
+        /* Now free them */
+        for (i = 0; i < serial->num_ports; ++i) {
+                port = serial->port[i];
+                portdata = usb_get_serial_port_data(port);
+                for (j = 0; j < N_IN_URB; j++) {
+                        if (portdata->in_urbs[j]) {
+                                usb_free_urb(portdata->in_urbs[j]);
+                                portdata->in_urbs[j] = NULL;
+                        }
+                }
+                for (j = 0; j < N_OUT_URB; j++) {
+                        if (portdata->out_urbs[j]) {
+                                usb_free_urb(portdata->out_urbs[j]);
+                                portdata->out_urbs[j] = NULL;
+                        }
+                }
+        }
+        /* Now free per port private data */
+        for (i = 0; i < serial->num_ports; i++) {
+                port = serial->port[i];
+                kfree(usb_get_serial_port_data(port));
+        }
+}
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug messages");
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 4536f63faaea..5da76dd8fb28 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -1297,13 +1297,6 @@ static int __init usb_serial_init(void)
                goto exit_bus;
        }
-        /* register the generic driver, if we should */
-        result = usb_serial_generic_register(debug);
-        if (result < 0) {
-                err("%s - registering generic driver failed", __FUNCTION__);
-                goto exit_generic;
-        }
        usb_serial_tty_driver->owner = THIS_MODULE;
        usb_serial_tty_driver->driver_name = "usbserial";
        usb_serial_tty_driver->devfs_name = "usb/tts/";
@@ -1329,17 +1322,24 @@ static int __init usb_serial_init(void)
                goto exit_tty;
        }
+        /* register the generic driver, if we should */
+        result = usb_serial_generic_register(debug);
+        if (result < 0) {
+                err("%s - registering generic driver failed", __FUNCTION__);
+                goto exit_generic;
+        }
        info(DRIVER_DESC " " DRIVER_VERSION);
        return result;
+exit_generic:
+        usb_deregister(&usb_serial_driver);
 exit_tty:
        tty_unregister_driver(usb_serial_tty_driver);
 exit_reg_driver:
-        usb_serial_generic_deregister();
-exit_generic:
        bus_unregister(&usb_serial_bus_type);
 exit_bus:
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index d2891f475793..9fcc7bd1fbe4 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -862,6 +862,15 @@ UNUSUAL_DEV(  0x090a, 0x1001, 0x0100, 0x0100,
                US_SC_DEVICE, US_PR_BULK, NULL,
                US_FL_NEED_OVERRIDE ),
+/* Reported by Filippo Bardelli <filibard@libero.it>
+ * The device reports a subclass of RBC, which is wrong.
+ */
+UNUSUAL_DEV(  0x090a, 0x1050, 0x0100, 0x0100,
+                "Trumpion Microelectronics, Inc.",
+                "33520 USB Digital Voice Recorder",
+                US_SC_UFI, US_PR_DEVICE, NULL,
+                0),
 /* Trumpion Microelectronics MP3 player (felipe_alfaro@linuxmail.org) */
 UNUSUAL_DEV( 0x090a, 0x1200, 0x0000, 0x9999,
                "Trumpion",
author	Anton Altaparmakov <aia21@cantab.net>	2005-06-08 10:45:45 -0400
committer	Anton Altaparmakov <aia21@cantab.net>	2005-06-08 10:45:45 -0400
commit	364f6c717deef4a3ac4982e670fa9846b43cd060 (patch)
tree	47e3967d6e2220130f2c070e300c97709143b28f /drivers
parent	4ff4258a3e558814a3d48c50a59cd22f56bbea2f (diff)
parent	1d6757fbff5bc86e94e59ab0d7bdd7e71351d839 (diff)