video: tegra: host: fix integer overflows
[linux-2.6.git] / drivers / block / umem.c
index a3614e6..031ca72 100644 (file)
  *                      - set initialised bit then.
  */
 
-//#define DEBUG /* uncomment if you want debugging info (pr_debug) */
-#include <linux/config.h>
-#include <linux/sched.h>
+#undef DEBUG   /* #define DEBUG if you want debugging info (pr_debug) */
 #include <linux/fs.h>
 #include <linux/bio.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/mman.h>
+#include <linux/gfp.h>
 #include <linux/ioctl.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/smp_lock.h>
 #include <linux/timer.h>
 #include <linux/pci.h>
-#include <linux/slab.h>
+#include <linux/dma-mapping.h>
 
 #include <linux/fcntl.h>        /* O_ACCMODE */
 #include <linux/hdreg.h>  /* HDIO_GETGEO */
 
-#include <linux/umem.h>
+#include "umem.h"
 
 #include <asm/uaccess.h>
 #include <asm/io.h>
  * Version Information
  */
 
-#define DRIVER_VERSION "v2.3"
-#define DRIVER_AUTHOR "San Mehat, Johannes Erdfelt, NeilBrown"
-#define DRIVER_DESC "Micro Memory(tm) PCI memory board block driver"
+#define DRIVER_NAME    "umem"
+#define DRIVER_VERSION "v2.3"
+#define DRIVER_AUTHOR  "San Mehat, Johannes Erdfelt, NeilBrown"
+#define DRIVER_DESC    "Micro Memory(tm) PCI memory board block driver"
 
 static int debug;
 /* #define HW_TRACE(x)     writeb(x,cards[0].csr_remap + MEMCTRLSTATUS_MAGIC) */
@@ -99,21 +98,9 @@ static int major_nr;
 #include <linux/blkpg.h>
 
 struct cardinfo {
-       int             card_number;
        struct pci_dev  *dev;
 
-       int             irq;
-
-       unsigned long   csr_base;
        unsigned char   __iomem *csr_remap;
-       unsigned long   csr_len;
-#ifdef CONFIG_MM_MAP_MEMORY
-       unsigned long   mem_base;
-       unsigned char   __iomem *mem_remap;
-       unsigned long   mem_len;
-#endif
-
-       unsigned int    win_size; /* PCI window size */
        unsigned int    mm_size;  /* size in kbytes */
 
        unsigned int    init_size; /* initial segment, in sectors,
@@ -121,14 +108,17 @@ struct cardinfo {
                                    * have been written
                                    */
        struct bio      *bio, *currentbio, **biotail;
+       int             current_idx;
+       sector_t        current_sector;
 
-       request_queue_t *queue;
+       struct request_queue *queue;
 
        struct mm_page {
                dma_addr_t              page_dma;
                struct mm_dma_desc      *desc;
                int                     cnt, headcnt;
                struct bio              *bio, **biotail;
+               int                     idx;
        } mm_pages[2];
 #define DESC_PER_PAGE ((PAGE_SIZE*2)/sizeof(struct mm_dma_desc))
 
@@ -150,20 +140,14 @@ struct cardinfo {
 };
 
 static struct cardinfo cards[MM_MAXCARDS];
-static struct block_device_operations mm_fops;
 static struct timer_list battery_timer;
 
-static int num_cards = 0;
+static int num_cards;
 
 static struct gendisk *mm_gendisk[MM_MAXCARDS];
 
 static void check_batteries(struct cardinfo *card);
 
-/*
------------------------------------------------------------------------------------
---                           get_userbit
------------------------------------------------------------------------------------
-*/
 static int get_userbit(struct cardinfo *card, int bit)
 {
        unsigned char led;
@@ -171,11 +155,7 @@ static int get_userbit(struct cardinfo *card, int bit)
        led = readb(card->csr_remap + MEMCTRLCMD_LEDCTRL);
        return led & bit;
 }
-/*
------------------------------------------------------------------------------------
---                            set_userbit
------------------------------------------------------------------------------------
-*/
+
 static int set_userbit(struct cardinfo *card, int bit, unsigned char state)
 {
        unsigned char led;
@@ -189,11 +169,7 @@ static int set_userbit(struct cardinfo *card, int bit, unsigned char state)
 
        return 0;
 }
-/*
------------------------------------------------------------------------------------
---                             set_led
------------------------------------------------------------------------------------
-*/
+
 /*
  * NOTE: For the power LED, use the LED_POWER_* macros since they differ
  */
@@ -213,11 +189,6 @@ static void set_led(struct cardinfo *card, int shift, unsigned char state)
 }
 
 #ifdef MM_DIAG
-/*
------------------------------------------------------------------------------------
---                              dump_regs
------------------------------------------------------------------------------------
-*/
 static void dump_regs(struct cardinfo *card)
 {
        unsigned char *p;
@@ -234,32 +205,28 @@ static void dump_regs(struct cardinfo *card)
        }
 }
 #endif
-/*
------------------------------------------------------------------------------------
---                            dump_dmastat
------------------------------------------------------------------------------------
-*/
+
 static void dump_dmastat(struct cardinfo *card, unsigned int dmastat)
 {
-       printk(KERN_DEBUG "MM%d*: DMAstat - ", card->card_number);
+       dev_printk(KERN_DEBUG, &card->dev->dev, "DMAstat - ");
        if (dmastat & DMASCR_ANY_ERR)
-               printk("ANY_ERR ");
+               printk(KERN_CONT "ANY_ERR ");
        if (dmastat & DMASCR_MBE_ERR)
-               printk("MBE_ERR ");
+               printk(KERN_CONT "MBE_ERR ");
        if (dmastat & DMASCR_PARITY_ERR_REP)
-               printk("PARITY_ERR_REP ");
+               printk(KERN_CONT "PARITY_ERR_REP ");
        if (dmastat & DMASCR_PARITY_ERR_DET)
-               printk("PARITY_ERR_DET ");
+               printk(KERN_CONT "PARITY_ERR_DET ");
        if (dmastat & DMASCR_SYSTEM_ERR_SIG)
-               printk("SYSTEM_ERR_SIG ");
+               printk(KERN_CONT "SYSTEM_ERR_SIG ");
        if (dmastat & DMASCR_TARGET_ABT)
-               printk("TARGET_ABT ");
+               printk(KERN_CONT "TARGET_ABT ");
        if (dmastat & DMASCR_MASTER_ABT)
-               printk("MASTER_ABT ");
+               printk(KERN_CONT "MASTER_ABT ");
        if (dmastat & DMASCR_CHAIN_COMPLETE)
-               printk("CHAIN_COMPLETE ");
+               printk(KERN_CONT "CHAIN_COMPLETE ");
        if (dmastat & DMASCR_DMA_COMPLETE)
-               printk("DMA_COMPLETE ");
+               printk(KERN_CONT "DMA_COMPLETE ");
        printk("\n");
 }
 
@@ -274,8 +241,7 @@ static void dump_dmastat(struct cardinfo *card, unsigned int dmastat)
  *
  * Whenever IO on the active page completes, the Ready page is activated
  * and the ex-Active page is clean out and made Ready.
- * Otherwise the Ready page is only activated when it becomes full, or
- * when mm_unplug_device is called via the unplug_io_fn.
+ * Otherwise the Ready page is only activated when it becomes full.
  *
  * If a request arrives while both pages a full, it is queued, and b_rdev is
  * overloaded to record whether it was a read or a write.
@@ -296,14 +262,15 @@ static void mm_start_io(struct cardinfo *card)
 
        /* make the last descriptor end the chain */
        page = &card->mm_pages[card->Active];
-       pr_debug("start_io: %d %d->%d\n", card->Active, page->headcnt, page->cnt-1);
+       pr_debug("start_io: %d %d->%d\n",
+               card->Active, page->headcnt, page->cnt - 1);
        desc = &page->desc[page->cnt-1];
 
        desc->control_bits |= cpu_to_le32(DMASCR_CHAIN_COMP_EN);
        desc->control_bits &= ~cpu_to_le32(DMASCR_CHAIN_EN);
        desc->sem_control_bits = desc->control_bits;
 
-                              
+
        if (debug & DEBUG_LED_ON_TRANSFER)
                set_led(card, LED_REMOVE, LED_ON);
 
@@ -320,8 +287,8 @@ static void mm_start_io(struct cardinfo *card)
        writel(0, card->csr_remap + DMA_SEMAPHORE_ADDR);
        writel(0, card->csr_remap + DMA_SEMAPHORE_ADDR + 4);
 
-       offset = ((char*)desc) - ((char*)page->desc);
-       writel(cpu_to_le32((page->page_dma+offset)&0xffffffff),
+       offset = ((char *)desc) - ((char *)page->desc);
+       writel(cpu_to_le32((page->page_dma+offset) & 0xffffffff),
               card->csr_remap + DMA_DESCRIPTOR_ADDR);
        /* Force the value to u64 before shifting otherwise >> 32 is undefined C
         * and on some ports will do nothing ! */
@@ -337,7 +304,7 @@ static int add_bio(struct cardinfo *card);
 
 static void activate(struct cardinfo *card)
 {
-       /* if No page is Active, and Ready is 
+       /* if No page is Active, and Ready is
         * not empty, then switch Ready page
         * to active and start IO.
         * Then add any bh's that are available to Ready
@@ -362,21 +329,10 @@ static inline void reset_page(struct mm_page *page)
        page->cnt = 0;
        page->headcnt = 0;
        page->bio = NULL;
-       page->biotail = & page->bio;
-}
-
-static void mm_unplug_device(request_queue_t *q)
-{
-       struct cardinfo *card = q->queuedata;
-       unsigned long flags;
-
-       spin_lock_irqsave(&card->lock, flags);
-       if (blk_remove_plug(q))
-               activate(card);
-       spin_unlock_irqrestore(&card->lock, flags);
+       page->biotail = &page->bio;
 }
 
-/* 
+/*
  * If there is room on Ready page, take
  * one bh off list and add it.
  * return 1 if there was room, else 0.
@@ -388,12 +344,16 @@ static int add_bio(struct cardinfo *card)
        dma_addr_t dma_handle;
        int offset;
        struct bio *bio;
+       struct bio_vec *vec;
+       int idx;
        int rw;
        int len;
 
        bio = card->currentbio;
        if (!bio && card->bio) {
                card->currentbio = card->bio;
+               card->current_idx = card->bio->bi_idx;
+               card->current_sector = card->bio->bi_sector;
                card->bio = card->bio->bi_next;
                if (card->bio == NULL)
                        card->biotail = &card->bio;
@@ -402,22 +362,26 @@ static int add_bio(struct cardinfo *card)
        }
        if (!bio)
                return 0;
+       idx = card->current_idx;
 
        rw = bio_rw(bio);
        if (card->mm_pages[card->Ready].cnt >= DESC_PER_PAGE)
                return 0;
 
-       len = bio_iovec(bio)->bv_len;
-       dma_handle = pci_map_page(card->dev, 
-                                 bio_page(bio),
-                                 bio_offset(bio),
+       vec = bio_iovec_idx(bio, idx);
+       len = vec->bv_len;
+       dma_handle = pci_map_page(card->dev,
+                                 vec->bv_page,
+                                 vec->bv_offset,
                                  len,
-                                 (rw==READ) ?
+                                 (rw == READ) ?
                                  PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
 
        p = &card->mm_pages[card->Ready];
        desc = &p->desc[p->cnt];
        p->cnt++;
+       if (p->bio == NULL)
+               p->idx = idx;
        if ((p->biotail) != &bio->bi_next) {
                *(p->biotail) = bio;
                p->biotail = &(bio->bi_next);
@@ -427,12 +391,12 @@ static int add_bio(struct cardinfo *card)
        desc->data_dma_handle = dma_handle;
 
        desc->pci_addr = cpu_to_le64((u64)desc->data_dma_handle);
-       desc->local_addr= cpu_to_le64(bio->bi_sector << 9);
+       desc->local_addr = cpu_to_le64(card->current_sector << 9);
        desc->transfer_size = cpu_to_le32(len);
-       offset = ( ((char*)&desc->sem_control_bits) - ((char*)p->desc));
+       offset = (((char *)&desc->sem_control_bits) - ((char *)p->desc));
        desc->sem_addr = cpu_to_le64((u64)(p->page_dma+offset));
        desc->zero1 = desc->zero2 = 0;
-       offset = ( ((char*)(desc+1)) - ((char*)p->desc));
+       offset = (((char *)(desc+1)) - ((char *)p->desc));
        desc->next_desc_addr = cpu_to_le64(p->page_dma+offset);
        desc->control_bits = cpu_to_le32(DMASCR_GO|DMASCR_ERR_INT_EN|
                                         DMASCR_PARITY_INT_EN|
@@ -443,10 +407,10 @@ static int add_bio(struct cardinfo *card)
                desc->control_bits |= cpu_to_le32(DMASCR_TRANSFER_READ);
        desc->sem_control_bits = desc->control_bits;
 
-       bio->bi_sector += (len>>9);
-       bio->bi_size -= len;
-       bio->bi_idx++;
-       if (bio->bi_idx >= bio->bi_vcnt) 
+       card->current_sector += (len >> 9);
+       idx++;
+       card->current_idx = idx;
+       if (idx >= bio->bi_vcnt)
                card->currentbio = NULL;
 
        return 1;
@@ -457,11 +421,11 @@ static void process_page(unsigned long data)
        /* check if any of the requests in the page are DMA_COMPLETE,
         * and deal with them appropriately.
         * If we find a descriptor without DMA_COMPLETE in the semaphore, then
-        * dma must have hit an error on that descriptor, so use dma_status instead
-        * and assume that all following descriptors must be re-tried.
+        * dma must have hit an error on that descriptor, so use dma_status
+        * instead and assume that all following descriptors must be re-tried.
         */
        struct mm_page *page;
-       struct bio *return_bio=NULL;
+       struct bio *return_bio = NULL;
        struct cardinfo *card = (struct cardinfo *)data;
        unsigned int dma_status = card->dma_status;
 
@@ -469,42 +433,46 @@ static void process_page(unsigned long data)
        if (card->Active < 0)
                goto out_unlock;
        page = &card->mm_pages[card->Active];
-       
+
        while (page->headcnt < page->cnt) {
                struct bio *bio = page->bio;
                struct mm_dma_desc *desc = &page->desc[page->headcnt];
                int control = le32_to_cpu(desc->sem_control_bits);
-               int last=0;
+               int last = 0;
                int idx;
 
                if (!(control & DMASCR_DMA_COMPLETE)) {
                        control = dma_status;
-                       last=1; 
+                       last = 1;
                }
                page->headcnt++;
-               idx = bio->bi_phys_segments;
-               bio->bi_phys_segments++;
-               if (bio->bi_phys_segments >= bio->bi_vcnt)
+               idx = page->idx;
+               page->idx++;
+               if (page->idx >= bio->bi_vcnt) {
                        page->bio = bio->bi_next;
+                       if (page->bio)
+                               page->idx = page->bio->bi_idx;
+               }
 
-               pci_unmap_page(card->dev, desc->data_dma_handle, 
-                              bio_iovec_idx(bio,idx)->bv_len,
-                                (control& DMASCR_TRANSFER_READ) ?
+               pci_unmap_page(card->dev, desc->data_dma_handle,
+                              bio_iovec_idx(bio, idx)->bv_len,
+                                (control & DMASCR_TRANSFER_READ) ?
                                PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
                if (control & DMASCR_HARD_ERROR) {
                        /* error */
                        clear_bit(BIO_UPTODATE, &bio->bi_flags);
-                       printk(KERN_WARNING "MM%d: I/O error on sector %d/%d\n",
-                              card->card_number, 
-                              le32_to_cpu(desc->local_addr)>>9,
-                              le32_to_cpu(desc->transfer_size));
+                       dev_printk(KERN_WARNING, &card->dev->dev,
+                               "I/O error on sector %d/%d\n",
+                               le32_to_cpu(desc->local_addr)>>9,
+                               le32_to_cpu(desc->transfer_size));
                        dump_dmastat(card, control);
-               } else if (test_bit(BIO_RW, &bio->bi_rw) &&
-                          le32_to_cpu(desc->local_addr)>>9 == card->init_size) {
-                       card->init_size += le32_to_cpu(desc->transfer_size)>>9;
-                       if (card->init_size>>1 >= card->mm_size) {
-                               printk(KERN_INFO "MM%d: memory now initialised\n",
-                                      card->card_number);
+               } else if ((bio->bi_rw & REQ_WRITE) &&
+                          le32_to_cpu(desc->local_addr) >> 9 ==
+                               card->init_size) {
+                       card->init_size += le32_to_cpu(desc->transfer_size) >> 9;
+                       if (card->init_size >> 1 >= card->mm_size) {
+                               dev_printk(KERN_INFO, &card->dev->dev,
+                                       "memory now initialised\n");
                                set_userbit(card, MEMORY_INITIALIZED, 1);
                        }
                }
@@ -513,7 +481,8 @@ static void process_page(unsigned long data)
                        return_bio = bio;
                }
 
-               if (last) break;
+               if (last)
+                       break;
        }
 
        if (debug & DEBUG_LED_ON_TRANSFER)
@@ -535,42 +504,31 @@ static void process_page(unsigned long data)
  out_unlock:
        spin_unlock_bh(&card->lock);
 
-       while(return_bio) {
+       while (return_bio) {
                struct bio *bio = return_bio;
 
                return_bio = bio->bi_next;
                bio->bi_next = NULL;
-               bio_endio(bio, bio->bi_size, 0);
+               bio_endio(bio, 0);
        }
 }
 
-/*
------------------------------------------------------------------------------------
---                              mm_make_request
------------------------------------------------------------------------------------
-*/
-static int mm_make_request(request_queue_t *q, struct bio *bio)
+static int mm_make_request(struct request_queue *q, struct bio *bio)
 {
        struct cardinfo *card = q->queuedata;
-       pr_debug("mm_make_request %ld %d\n", bh->b_rsector, bh->b_size);
+       pr_debug("mm_make_request %llu %u\n",
+                (unsigned long long)bio->bi_sector, bio->bi_size);
 
-       bio->bi_phys_segments = bio->bi_idx; /* count of completed segments*/
        spin_lock_irq(&card->lock);
        *card->biotail = bio;
        bio->bi_next = NULL;
        card->biotail = &bio->bi_next;
-       blk_plug_device(q);
        spin_unlock_irq(&card->lock);
 
        return 0;
 }
 
-/*
------------------------------------------------------------------------------------
---                              mm_interrupt
------------------------------------------------------------------------------------
-*/
-static irqreturn_t mm_interrupt(int irq, void *__card, struct pt_regs *regs)
+static irqreturn_t mm_interrupt(int irq, void *__card)
 {
        struct cardinfo *card = (struct cardinfo *) __card;
        unsigned int dma_status;
@@ -583,16 +541,16 @@ HW_TRACE(0x30);
        if (!(dma_status & (DMASCR_ERROR_MASK | DMASCR_CHAIN_COMPLETE))) {
                /* interrupt wasn't for me ... */
                return IRQ_NONE;
-        }
+       }
 
        /* clear COMPLETION interrupts */
        if (card->flags & UM_FLAG_NO_BYTE_STATUS)
                writel(cpu_to_le32(DMASCR_DMA_COMPLETE|DMASCR_CHAIN_COMPLETE),
-                      card->csr_remap+ DMA_STATUS_CTRL);
+                      card->csr_remap + DMA_STATUS_CTRL);
        else
                writeb((DMASCR_DMA_COMPLETE|DMASCR_CHAIN_COMPLETE) >> 16,
-                      card->csr_remap+ DMA_STATUS_CTRL + 2);
-       
+                      card->csr_remap + DMA_STATUS_CTRL + 2);
+
        /* log errors and clear interrupt status */
        if (dma_status & DMASCR_ANY_ERR) {
                unsigned int    data_log1, data_log2;
@@ -601,9 +559,12 @@ HW_TRACE(0x30);
 
                stat = readb(card->csr_remap + MEMCTRLCMD_ERRSTATUS);
 
-               data_log1 = le32_to_cpu(readl(card->csr_remap + ERROR_DATA_LOG));
-               data_log2 = le32_to_cpu(readl(card->csr_remap + ERROR_DATA_LOG + 4));
-               addr_log1 = le32_to_cpu(readl(card->csr_remap + ERROR_ADDR_LOG));
+               data_log1 = le32_to_cpu(readl(card->csr_remap +
+                                               ERROR_DATA_LOG));
+               data_log2 = le32_to_cpu(readl(card->csr_remap +
+                                               ERROR_DATA_LOG + 4));
+               addr_log1 = le32_to_cpu(readl(card->csr_remap +
+                                               ERROR_ADDR_LOG));
                addr_log2 = readb(card->csr_remap + ERROR_ADDR_LOG + 4);
 
                count = readb(card->csr_remap + ERROR_COUNT);
@@ -613,46 +574,51 @@ HW_TRACE(0x30);
                dump_dmastat(card, dma_status);
 
                if (stat & 0x01)
-                       printk(KERN_ERR "MM%d*: Memory access error detected (err count %d)\n",
-                               card->card_number, count);
+                       dev_printk(KERN_ERR, &card->dev->dev,
+                               "Memory access error detected (err count %d)\n",
+                               count);
                if (stat & 0x02)
-                       printk(KERN_ERR "MM%d*: Multi-bit EDC error\n",
-                               card->card_number);
+                       dev_printk(KERN_ERR, &card->dev->dev,
+                               "Multi-bit EDC error\n");
 
-               printk(KERN_ERR "MM%d*: Fault Address 0x%02x%08x, Fault Data 0x%08x%08x\n",
-                       card->card_number, addr_log2, addr_log1, data_log2, data_log1);
-               printk(KERN_ERR "MM%d*: Fault Check 0x%02x, Fault Syndrome 0x%02x\n",
-                       card->card_number, check, syndrome);
+               dev_printk(KERN_ERR, &card->dev->dev,
+                       "Fault Address 0x%02x%08x, Fault Data 0x%08x%08x\n",
+                       addr_log2, addr_log1, data_log2, data_log1);
+               dev_printk(KERN_ERR, &card->dev->dev,
+                       "Fault Check 0x%02x, Fault Syndrome 0x%02x\n",
+                       check, syndrome);
 
                writeb(0, card->csr_remap + ERROR_COUNT);
        }
 
        if (dma_status & DMASCR_PARITY_ERR_REP) {
-               printk(KERN_ERR "MM%d*: PARITY ERROR REPORTED\n", card->card_number);
+               dev_printk(KERN_ERR, &card->dev->dev,
+                       "PARITY ERROR REPORTED\n");
                pci_read_config_word(card->dev, PCI_STATUS, &cfg_status);
                pci_write_config_word(card->dev, PCI_STATUS, cfg_status);
        }
 
        if (dma_status & DMASCR_PARITY_ERR_DET) {
-               printk(KERN_ERR "MM%d*: PARITY ERROR DETECTED\n", card->card_number); 
+               dev_printk(KERN_ERR, &card->dev->dev,
+                       "PARITY ERROR DETECTED\n");
                pci_read_config_word(card->dev, PCI_STATUS, &cfg_status);
                pci_write_config_word(card->dev, PCI_STATUS, cfg_status);
        }
 
        if (dma_status & DMASCR_SYSTEM_ERR_SIG) {
-               printk(KERN_ERR "MM%d*: SYSTEM ERROR\n", card->card_number); 
+               dev_printk(KERN_ERR, &card->dev->dev, "SYSTEM ERROR\n");
                pci_read_config_word(card->dev, PCI_STATUS, &cfg_status);
                pci_write_config_word(card->dev, PCI_STATUS, cfg_status);
        }
 
        if (dma_status & DMASCR_TARGET_ABT) {
-               printk(KERN_ERR "MM%d*: TARGET ABORT\n", card->card_number); 
+               dev_printk(KERN_ERR, &card->dev->dev, "TARGET ABORT\n");
                pci_read_config_word(card->dev, PCI_STATUS, &cfg_status);
                pci_write_config_word(card->dev, PCI_STATUS, cfg_status);
        }
 
        if (dma_status & DMASCR_MASTER_ABT) {
-               printk(KERN_ERR "MM%d*: MASTER ABORT\n", card->card_number); 
+               dev_printk(KERN_ERR, &card->dev->dev, "MASTER ABORT\n");
                pci_read_config_word(card->dev, PCI_STATUS, &cfg_status);
                pci_write_config_word(card->dev, PCI_STATUS, cfg_status);
        }
@@ -663,13 +629,9 @@ HW_TRACE(0x30);
 
 HW_TRACE(0x36);
 
-       return IRQ_HANDLED; 
+       return IRQ_HANDLED;
 }
-/*
------------------------------------------------------------------------------------
---                         set_fault_to_battery_status
------------------------------------------------------------------------------------
-*/
+
 /*
  * If both batteries are good, no LED
  * If either battery has been warned, solid LED
@@ -690,12 +652,6 @@ static void set_fault_to_battery_status(struct cardinfo *card)
 
 static void init_battery_timer(void);
 
-
-/*
------------------------------------------------------------------------------------
---                            check_battery
------------------------------------------------------------------------------------
-*/
 static int check_battery(struct cardinfo *card, int battery, int status)
 {
        if (status != card->battery[battery].good) {
@@ -703,20 +659,20 @@ static int check_battery(struct cardinfo *card, int battery, int status)
                card->battery[battery].last_change = jiffies;
 
                if (card->battery[battery].good) {
-                       printk(KERN_ERR "MM%d: Battery %d now good\n",
-                               card->card_number, battery + 1);
+                       dev_printk(KERN_ERR, &card->dev->dev,
+                               "Battery %d now good\n", battery + 1);
                        card->battery[battery].warned = 0;
                } else
-                       printk(KERN_ERR "MM%d: Battery %d now FAILED\n",
-                               card->card_number, battery + 1);
+                       dev_printk(KERN_ERR, &card->dev->dev,
+                               "Battery %d now FAILED\n", battery + 1);
 
                return 1;
        } else if (!card->battery[battery].good &&
                   !card->battery[battery].warned &&
                   time_after_eq(jiffies, card->battery[battery].last_change +
                                 (HZ * 60 * 60 * 5))) {
-               printk(KERN_ERR "MM%d: Battery %d still FAILED after 5 hours\n",
-                       card->card_number, battery + 1);
+               dev_printk(KERN_ERR, &card->dev->dev,
+                       "Battery %d still FAILED after 5 hours\n", battery + 1);
                card->battery[battery].warned = 1;
 
                return 1;
@@ -724,11 +680,7 @@ static int check_battery(struct cardinfo *card, int battery, int status)
 
        return 0;
 }
-/*
------------------------------------------------------------------------------------
---                              check_batteries
------------------------------------------------------------------------------------
-*/
+
 static void check_batteries(struct cardinfo *card)
 {
        /* NOTE: this must *never* be called while the card
@@ -740,8 +692,8 @@ static void check_batteries(struct cardinfo *card)
 
        status = readb(card->csr_remap + MEMCTRLSTATUS_BATTERY);
        if (debug & DEBUG_BATTERY_POLLING)
-               printk(KERN_DEBUG "MM%d: checking battery status, 1 = %s, 2 = %s\n",
-                      card->card_number,
+               dev_printk(KERN_DEBUG, &card->dev->dev,
+                       "checking battery status, 1 = %s, 2 = %s\n",
                       (status & BATTERY_1_FAILURE) ? "FAILURE" : "OK",
                       (status & BATTERY_2_FAILURE) ? "FAILURE" : "OK");
 
@@ -756,7 +708,7 @@ static void check_all_batteries(unsigned long ptr)
 {
        int i;
 
-       for (i = 0; i < num_cards; i++) 
+       for (i = 0; i < num_cards; i++)
                if (!(cards[i].flags & UM_FLAG_NO_BATT)) {
                        struct cardinfo *card = &cards[i];
                        spin_lock_bh(&card->lock);
@@ -769,11 +721,7 @@ static void check_all_batteries(unsigned long ptr)
 
        init_battery_timer();
 }
-/*
------------------------------------------------------------------------------------
---                            init_battery_timer
------------------------------------------------------------------------------------
-*/
+
 static void init_battery_timer(void)
 {
        init_timer(&battery_timer);
@@ -781,20 +729,12 @@ static void init_battery_timer(void)
        battery_timer.expires = jiffies + (HZ * 60);
        add_timer(&battery_timer);
 }
-/*
------------------------------------------------------------------------------------
---                              del_battery_timer
------------------------------------------------------------------------------------
-*/
+
 static void del_battery_timer(void)
 {
        del_timer(&battery_timer);
 }
-/*
------------------------------------------------------------------------------------
---                                mm_revalidate
------------------------------------------------------------------------------------
-*/
+
 /*
  * Note no locks taken out here.  In a worst case scenario, we could drop
  * a chunk of system memory.  But that should never happen, since validation
@@ -826,106 +766,72 @@ static int mm_getgeo(struct block_device *bdev, struct hd_geometry *geo)
        return 0;
 }
 
-/*
------------------------------------------------------------------------------------
---                                mm_check_change
------------------------------------------------------------------------------------
-  Future support for removable devices
-*/
-static int mm_check_change(struct gendisk *disk)
-{
-/*  struct cardinfo *dev = disk->private_data; */
-       return 0;
-}
-/*
------------------------------------------------------------------------------------
---                             mm_fops
------------------------------------------------------------------------------------
-*/
-static struct block_device_operations mm_fops = {
+static const struct block_device_operations mm_fops = {
        .owner          = THIS_MODULE,
        .getgeo         = mm_getgeo,
-       .revalidate_disk= mm_revalidate,
-       .media_changed  = mm_check_change,
+       .revalidate_disk = mm_revalidate,
 };
-/*
------------------------------------------------------------------------------------
---                                mm_pci_probe
------------------------------------------------------------------------------------
-*/
-static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
+
+static int __devinit mm_pci_probe(struct pci_dev *dev,
+                               const struct pci_device_id *id)
 {
        int ret = -ENODEV;
        struct cardinfo *card = &cards[num_cards];
        unsigned char   mem_present;
        unsigned char   batt_status;
        unsigned int    saved_bar, data;
+       unsigned long   csr_base;
+       unsigned long   csr_len;
        int             magic_number;
+       static int      printed_version;
 
-       if (pci_enable_device(dev) < 0)
-               return -ENODEV;
+       if (!printed_version++)
+               printk(KERN_INFO DRIVER_VERSION " : " DRIVER_DESC "\n");
+
+       ret = pci_enable_device(dev);
+       if (ret)
+               return ret;
 
        pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xF8);
        pci_set_master(dev);
 
        card->dev         = dev;
-       card->card_number = num_cards;
 
-       card->csr_base = pci_resource_start(dev, 0);
-       card->csr_len  = pci_resource_len(dev, 0);
-#ifdef CONFIG_MM_MAP_MEMORY
-       card->mem_base = pci_resource_start(dev, 1);
-       card->mem_len  = pci_resource_len(dev, 1);
-#endif
+       csr_base = pci_resource_start(dev, 0);
+       csr_len  = pci_resource_len(dev, 0);
+       if (!csr_base || !csr_len)
+               return -ENODEV;
 
-       printk(KERN_INFO "Micro Memory(tm) controller #%d found at %02x:%02x (PCI Mem Module (Battery Backup))\n",
-              card->card_number, dev->bus->number, dev->devfn);
+       dev_printk(KERN_INFO, &dev->dev,
+         "Micro Memory(tm) controller found (PCI Mem Module (Battery Backup))\n");
 
-       if (pci_set_dma_mask(dev, 0xffffffffffffffffLL) &&
-           !pci_set_dma_mask(dev, 0xffffffffLL)) {
-               printk(KERN_WARNING "MM%d: NO suitable DMA found\n",num_cards);
+       if (pci_set_dma_mask(dev, DMA_BIT_MASK(64)) &&
+           pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
+               dev_printk(KERN_WARNING, &dev->dev, "NO suitable DMA found\n");
                return  -ENOMEM;
        }
-       if (!request_mem_region(card->csr_base, card->csr_len, "Micro Memory")) {
-               printk(KERN_ERR "MM%d: Unable to request memory region\n", card->card_number);
-               ret = -ENOMEM;
 
+       ret = pci_request_regions(dev, DRIVER_NAME);
+       if (ret) {
+               dev_printk(KERN_ERR, &card->dev->dev,
+                       "Unable to request memory region\n");
                goto failed_req_csr;
        }
 
-       card->csr_remap = ioremap_nocache(card->csr_base, card->csr_len);
+       card->csr_remap = ioremap_nocache(csr_base, csr_len);
        if (!card->csr_remap) {
-               printk(KERN_ERR "MM%d: Unable to remap memory region\n", card->card_number);
+               dev_printk(KERN_ERR, &card->dev->dev,
+                       "Unable to remap memory region\n");
                ret = -ENOMEM;
 
                goto failed_remap_csr;
        }
 
-       printk(KERN_INFO "MM%d: CSR 0x%08lx -> 0x%p (0x%lx)\n", card->card_number,
-              card->csr_base, card->csr_remap, card->csr_len);
-
-#ifdef CONFIG_MM_MAP_MEMORY
-       if (!request_mem_region(card->mem_base, card->mem_len, "Micro Memory")) {
-               printk(KERN_ERR "MM%d: Unable to request memory region\n", card->card_number);
-               ret = -ENOMEM;
-
-               goto failed_req_mem;
-       }
-
-       if (!(card->mem_remap = ioremap(card->mem_base, cards->mem_len))) {
-               printk(KERN_ERR "MM%d: Unable to remap memory region\n", card->card_number);
-               ret = -ENOMEM;
-
-               goto failed_remap_mem;
-       }
+       dev_printk(KERN_INFO, &card->dev->dev,
+               "CSR 0x%08lx -> 0x%p (0x%lx)\n",
+              csr_base, card->csr_remap, csr_len);
 
-       printk(KERN_INFO "MM%d: MEM 0x%8lx -> 0x%8lx (0x%lx)\n", card->card_number,
-              card->mem_base, card->mem_remap, card->mem_len);
-#else
-       printk(KERN_INFO "MM%d: MEM area not remapped (CONFIG_MM_MAP_MEMORY not set)\n",
-              card->card_number);
-#endif
-       switch(card->dev->device) {
+       switch (card->dev->device) {
        case 0x5415:
                card->flags |= UM_FLAG_NO_BYTE_STATUS | UM_FLAG_NO_BATTREG;
                magic_number = 0x59;
@@ -937,7 +843,8 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
                break;
 
        case 0x6155:
-               card->flags |= UM_FLAG_NO_BYTE_STATUS | UM_FLAG_NO_BATTREG | UM_FLAG_NO_BATT;
+               card->flags |= UM_FLAG_NO_BYTE_STATUS |
+                               UM_FLAG_NO_BATTREG | UM_FLAG_NO_BATT;
                magic_number = 0x99;
                break;
 
@@ -947,20 +854,20 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
        }
 
        if (readb(card->csr_remap + MEMCTRLSTATUS_MAGIC) != magic_number) {
-               printk(KERN_ERR "MM%d: Magic number invalid\n", card->card_number);
+               dev_printk(KERN_ERR, &card->dev->dev, "Magic number invalid\n");
                ret = -ENOMEM;
                goto failed_magic;
        }
 
        card->mm_pages[0].desc = pci_alloc_consistent(card->dev,
-                                                     PAGE_SIZE*2,
-                                                     &card->mm_pages[0].page_dma);
+                                               PAGE_SIZE * 2,
+                                               &card->mm_pages[0].page_dma);
        card->mm_pages[1].desc = pci_alloc_consistent(card->dev,
-                                                     PAGE_SIZE*2,
-                                                     &card->mm_pages[1].page_dma);
+                                               PAGE_SIZE * 2,
+                                               &card->mm_pages[1].page_dma);
        if (card->mm_pages[0].desc == NULL ||
            card->mm_pages[1].desc == NULL) {
-               printk(KERN_ERR "MM%d: alloc failed\n", card->card_number);
+               dev_printk(KERN_ERR, &card->dev->dev, "alloc failed\n");
                goto failed_alloc;
        }
        reset_page(&card->mm_pages[0]);
@@ -975,13 +882,13 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
                goto failed_alloc;
 
        blk_queue_make_request(card->queue, mm_make_request);
+       card->queue->queue_lock = &card->lock;
        card->queue->queuedata = card;
-       card->queue->unplug_fn = mm_unplug_device;
 
        tasklet_init(&card->tasklet, process_page, (unsigned long)card);
 
        card->check_batteries = 0;
-       
+
        mem_present = readb(card->csr_remap + MEMCTRLSTATUS_MEMORY);
        switch (mem_present) {
        case MEM_128_MB:
@@ -1014,15 +921,16 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
        card->battery[1].good = !(batt_status & BATTERY_2_FAILURE);
        card->battery[0].last_change = card->battery[1].last_change = jiffies;
 
-       if (card->flags & UM_FLAG_NO_BATT) 
-               printk(KERN_INFO "MM%d: Size %d KB\n",
-                      card->card_number, card->mm_size);
+       if (card->flags & UM_FLAG_NO_BATT)
+               dev_printk(KERN_INFO, &card->dev->dev,
+                       "Size %d KB\n", card->mm_size);
        else {
-               printk(KERN_INFO "MM%d: Size %d KB, Battery 1 %s (%s), Battery 2 %s (%s)\n",
-                      card->card_number, card->mm_size,
-                      (batt_status & BATTERY_1_DISABLED ? "Disabled" : "Enabled"),
+               dev_printk(KERN_INFO, &card->dev->dev,
+                       "Size %d KB, Battery 1 %s (%s), Battery 2 %s (%s)\n",
+                      card->mm_size,
+                      batt_status & BATTERY_1_DISABLED ? "Disabled" : "Enabled",
                       card->battery[0].good ? "OK" : "FAILURE",
-                      (batt_status & BATTERY_2_DISABLED ? "Disabled" : "Enabled"),
+                      batt_status & BATTERY_2_DISABLED ? "Disabled" : "Enabled",
                       card->battery[1].good ? "OK" : "FAILURE");
 
                set_fault_to_battery_status(card);
@@ -1037,21 +945,18 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
        data = ~data;
        data += 1;
 
-       card->win_size = data;
-
-
-       if (request_irq(dev->irq, mm_interrupt, SA_SHIRQ, "pci-umem", card)) {
-               printk(KERN_ERR "MM%d: Unable to allocate IRQ\n", card->card_number);
+       if (request_irq(dev->irq, mm_interrupt, IRQF_SHARED, DRIVER_NAME,
+                       card)) {
+               dev_printk(KERN_ERR, &card->dev->dev,
+                       "Unable to allocate IRQ\n");
                ret = -ENODEV;
-
                goto failed_req_irq;
        }
 
-       card->irq = dev->irq;
-       printk(KERN_INFO "MM%d: Window size %d bytes, IRQ %d\n", card->card_number,
-              card->win_size, card->irq);
+       dev_printk(KERN_INFO, &card->dev->dev,
+               "Window size %d bytes, IRQ %d\n", data, dev->irq);
 
-        spin_lock_init(&card->lock);
+       spin_lock_init(&card->lock);
 
        pci_set_drvdata(dev, card);
 
@@ -1069,10 +974,12 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
        num_cards++;
 
        if (!get_userbit(card, MEMORY_INITIALIZED)) {
-               printk(KERN_INFO "MM%d: memory NOT initialized. Consider over-writing whole device.\n", card->card_number);
+               dev_printk(KERN_INFO, &card->dev->dev,
+                 "memory NOT initialized. Consider over-writing whole device.\n");
                card->init_size = 0;
        } else {
-               printk(KERN_INFO "MM%d: memory already initialized\n", card->card_number);
+               dev_printk(KERN_INFO, &card->dev->dev,
+                       "memory already initialized\n");
                card->init_size = card->mm_size;
        }
 
@@ -1092,36 +999,21 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
                                    card->mm_pages[1].desc,
                                    card->mm_pages[1].page_dma);
  failed_magic:
-#ifdef CONFIG_MM_MAP_MEMORY
-       iounmap(card->mem_remap);
- failed_remap_mem:
-       release_mem_region(card->mem_base, card->mem_len);
- failed_req_mem:
-#endif
        iounmap(card->csr_remap);
  failed_remap_csr:
-       release_mem_region(card->csr_base, card->csr_len);
+       pci_release_regions(dev);
  failed_req_csr:
 
        return ret;
 }
-/*
------------------------------------------------------------------------------------
---                              mm_pci_remove
------------------------------------------------------------------------------------
-*/
+
 static void mm_pci_remove(struct pci_dev *dev)
 {
        struct cardinfo *card = pci_get_drvdata(dev);
 
        tasklet_kill(&card->tasklet);
+       free_irq(dev->irq, card);
        iounmap(card->csr_remap);
-       release_mem_region(card->csr_base, card->csr_len);
-#ifdef CONFIG_MM_MAP_MEMORY
-       iounmap(card->mem_remap);
-       release_mem_region(card->mem_base, card->mem_len);
-#endif
-       free_irq(card->irq, card);
 
        if (card->mm_pages[0].desc)
                pci_free_consistent(card->dev, PAGE_SIZE*2,
@@ -1131,56 +1023,49 @@ static void mm_pci_remove(struct pci_dev *dev)
                pci_free_consistent(card->dev, PAGE_SIZE*2,
                                    card->mm_pages[1].desc,
                                    card->mm_pages[1].page_dma);
-       blk_put_queue(card->queue);
+       blk_cleanup_queue(card->queue);
+
+       pci_release_regions(dev);
+       pci_disable_device(dev);
 }
 
-static const struct pci_device_id mm_pci_ids[] = { {
-       .vendor =       PCI_VENDOR_ID_MICRO_MEMORY,
-       .device =       PCI_DEVICE_ID_MICRO_MEMORY_5415CN,
-       }, {
-       .vendor =       PCI_VENDOR_ID_MICRO_MEMORY,
-       .device =       PCI_DEVICE_ID_MICRO_MEMORY_5425CN,
-       }, {
-       .vendor =       PCI_VENDOR_ID_MICRO_MEMORY,
-       .device =       PCI_DEVICE_ID_MICRO_MEMORY_6155,
-       }, {
+static const struct pci_device_id mm_pci_ids[] = {
+    {PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY, PCI_DEVICE_ID_MICRO_MEMORY_5415CN)},
+    {PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY, PCI_DEVICE_ID_MICRO_MEMORY_5425CN)},
+    {PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY, PCI_DEVICE_ID_MICRO_MEMORY_6155)},
+    {
        .vendor =       0x8086,
        .device =       0xB555,
-       .subvendor=     0x1332,
-       .subdevice=     0x5460,
-       .class  =       0x050000,
-       .class_mask=    0,
-       }, { /* end: all zeroes */ }
+       .subvendor =    0x1332,
+       .subdevice =    0x5460,
+       .class =        0x050000,
+       .class_mask =   0,
+    }, { /* end: all zeroes */ }
 };
 
 MODULE_DEVICE_TABLE(pci, mm_pci_ids);
 
 static struct pci_driver mm_pci_driver = {
-       .name =         "umem",
-       .id_table =     mm_pci_ids,
-       .probe =        mm_pci_probe,
-       .remove =       mm_pci_remove,
+       .name           = DRIVER_NAME,
+       .id_table       = mm_pci_ids,
+       .probe          = mm_pci_probe,
+       .remove         = mm_pci_remove,
 };
-/*
------------------------------------------------------------------------------------
---                               mm_init
------------------------------------------------------------------------------------
-*/
 
 static int __init mm_init(void)
 {
        int retval, i;
        int err;
 
-       printk(KERN_INFO DRIVER_VERSION " : " DRIVER_DESC "\n");
-
        retval = pci_register_driver(&mm_pci_driver);
        if (retval)
                return -ENOMEM;
 
-       err = major_nr = register_blkdev(0, "umem");
-       if (err < 0)
+       err = major_nr = register_blkdev(0, DRIVER_NAME);
+       if (err < 0) {
+               pci_unregister_driver(&mm_pci_driver);
                return -EIO;
+       }
 
        for (i = 0; i < num_cards; i++) {
                mm_gendisk[i] = alloc_disk(1 << MM_SHIFT);
@@ -1191,7 +1076,6 @@ static int __init mm_init(void)
        for (i = 0; i < num_cards; i++) {
                struct gendisk *disk = mm_gendisk[i];
                sprintf(disk->disk_name, "umem%c", 'a'+i);
-               sprintf(disk->devfs_name, "umem/card%d", i);
                spin_lock_init(&cards[i].lock);
                disk->major = major_nr;
                disk->first_minor  = i << MM_SHIFT;
@@ -1203,35 +1087,32 @@ static int __init mm_init(void)
        }
 
        init_battery_timer();
-       printk("MM: desc_per_page = %ld\n", DESC_PER_PAGE);
+       printk(KERN_INFO "MM: desc_per_page = %ld\n", DESC_PER_PAGE);
 /* printk("mm_init: Done. 10-19-01 9:00\n"); */
        return 0;
 
 out:
-       unregister_blkdev(major_nr, "umem");
+       pci_unregister_driver(&mm_pci_driver);
+       unregister_blkdev(major_nr, DRIVER_NAME);
        while (i--)
                put_disk(mm_gendisk[i]);
        return -ENOMEM;
 }
-/*
------------------------------------------------------------------------------------
---                             mm_cleanup
------------------------------------------------------------------------------------
-*/
+
 static void __exit mm_cleanup(void)
 {
        int i;
 
        del_battery_timer();
 
-       for (i=0; i < num_cards ; i++) {
+       for (i = 0; i < num_cards ; i++) {
                del_gendisk(mm_gendisk[i]);
                put_disk(mm_gendisk[i]);
        }
 
        pci_unregister_driver(&mm_pci_driver);
 
-       unregister_blkdev(major_nr, "umem");
+       unregister_blkdev(major_nr, DRIVER_NAME);
 }
 
 module_init(mm_init);