2 * mm.c - Micro Memory(tm) PCI memory board block device driver - v2.3
4 * (C) 2001 San Mehat <nettwerk@valinux.com>
5 * (C) 2001 Johannes Erdfelt <jerdfelt@valinux.com>
6 * (C) 2001 NeilBrown <neilb@cse.unsw.edu.au>
8 * This driver for the Micro Memory PCI Memory Module with Battery Backup
9 * is Copyright Micro Memory Inc 2001-2002. All rights reserved.
11 * This driver is released to the public under the terms of the
12 * GNU GENERAL PUBLIC LICENSE version 2
13 * See the file COPYING for details.
15 * This driver provides a standard block device interface for Micro Memory(tm)
16 * PCI based RAM boards.
17 * 10/05/01: Phap Nguyen - Rebuilt the driver
18 * 10/22/01: Phap Nguyen - v2.1 Added disk partitioning
19 * 29oct2001:NeilBrown - Use make_request_fn instead of request_fn
20 * - use stand disk partitioning (so fdisk works).
21 * 08nov2001:NeilBrown - change driver name from "mm" to "umem"
22 * - incorporate into main kernel
23 * 08apr2002:NeilBrown - Move some of interrupt handle to tasklet
24 * - use spin_lock_bh instead of _irq
25 * - Never block on make_request. queue
27 * - unregister umem from devfs at mod unload
28 * - Change version to 2.3
29 * 07Nov2001:Phap Nguyen - Select pci read command: 06, 12, 15 (Decimal)
30 * 07Jan2002: P. Nguyen - Used PCI Memory Write & Invalidate for DMA
31 * 15May2002:NeilBrown - convert to bio for 2.5
32 * 17May2002:NeilBrown - remove init_mem initialisation. Instead detect
33 * - a sequence of writes that cover the card, and
34 * - set initialised bit then.
37 //#define DEBUG /* uncomment if you want debugging info (pr_debug) */
38 #include <linux/config.h>
39 #include <linux/sched.h>
41 #include <linux/bio.h>
42 #include <linux/kernel.h>
44 #include <linux/mman.h>
45 #include <linux/ioctl.h>
46 #include <linux/module.h>
47 #include <linux/init.h>
48 #include <linux/interrupt.h>
49 #include <linux/smp_lock.h>
50 #include <linux/timer.h>
51 #include <linux/pci.h>
52 #include <linux/slab.h>
54 #include <linux/fcntl.h> /* O_ACCMODE */
55 #include <linux/hdreg.h> /* HDIO_GETGEO */
57 #include <linux/umem.h>
59 #include <asm/uaccess.h>
63 #define MM_RAHEAD 2 /* two sectors */
64 #define MM_BLKSIZE 1024 /* 1k blocks */
65 #define MM_HARDSECT 512 /* 512-byte hardware sectors */
66 #define MM_SHIFT 6 /* max 64 partitions on 4 cards */
72 #define DRIVER_VERSION "v2.3"
73 #define DRIVER_AUTHOR "San Mehat, Johannes Erdfelt, NeilBrown"
74 #define DRIVER_DESC "Micro Memory(tm) PCI memory board block driver"
77 /* #define HW_TRACE(x) writeb(x,cards[0].csr_remap + MEMCTRLSTATUS_MAGIC) */
80 #define DEBUG_LED_ON_TRANSFER 0x01
81 #define DEBUG_BATTERY_POLLING 0x02
83 module_param(debug
, int, 0644);
84 MODULE_PARM_DESC(debug
, "Debug bitmask");
86 static int pci_read_cmd
= 0x0C; /* Read Multiple */
87 module_param(pci_read_cmd
, int, 0);
88 MODULE_PARM_DESC(pci_read_cmd
, "PCI read command");
90 static int pci_write_cmd
= 0x0F; /* Write and Invalidate */
91 module_param(pci_write_cmd
, int, 0);
92 MODULE_PARM_DESC(pci_write_cmd
, "PCI write command");
98 #include <linux/blkdev.h>
99 #include <linux/blkpg.h>
107 unsigned long csr_base
;
108 unsigned char __iomem
*csr_remap
;
109 unsigned long csr_len
;
110 #ifdef CONFIG_MM_MAP_MEMORY
111 unsigned long mem_base
;
112 unsigned char __iomem
*mem_remap
;
113 unsigned long mem_len
;
116 unsigned int win_size
; /* PCI window size */
117 unsigned int mm_size
; /* size in kbytes */
119 unsigned int init_size
; /* initial segment, in sectors,
123 struct bio
*bio
, *currentbio
, **biotail
;
125 request_queue_t
*queue
;
129 struct mm_dma_desc
*desc
;
131 struct bio
*bio
, **biotail
;
133 #define DESC_PER_PAGE ((PAGE_SIZE*2)/sizeof(struct mm_dma_desc))
137 struct tasklet_struct tasklet
;
138 unsigned int dma_status
;
143 unsigned long last_change
;
152 static struct cardinfo cards
[MM_MAXCARDS
];
153 static struct block_device_operations mm_fops
;
154 static struct timer_list battery_timer
;
156 static int num_cards
= 0;
158 static struct gendisk
*mm_gendisk
[MM_MAXCARDS
];
160 static void check_batteries(struct cardinfo
*card
);
163 -----------------------------------------------------------------------------------
165 -----------------------------------------------------------------------------------
167 static int get_userbit(struct cardinfo
*card
, int bit
)
171 led
= readb(card
->csr_remap
+ MEMCTRLCMD_LEDCTRL
);
175 -----------------------------------------------------------------------------------
177 -----------------------------------------------------------------------------------
179 static int set_userbit(struct cardinfo
*card
, int bit
, unsigned char state
)
183 led
= readb(card
->csr_remap
+ MEMCTRLCMD_LEDCTRL
);
188 writeb(led
, card
->csr_remap
+ MEMCTRLCMD_LEDCTRL
);
193 -----------------------------------------------------------------------------------
195 -----------------------------------------------------------------------------------
198 * NOTE: For the power LED, use the LED_POWER_* macros since they differ
200 static void set_led(struct cardinfo
*card
, int shift
, unsigned char state
)
204 led
= readb(card
->csr_remap
+ MEMCTRLCMD_LEDCTRL
);
205 if (state
== LED_FLIP
)
208 led
&= ~(0x03 << shift
);
209 led
|= (state
<< shift
);
211 writeb(led
, card
->csr_remap
+ MEMCTRLCMD_LEDCTRL
);
217 -----------------------------------------------------------------------------------
219 -----------------------------------------------------------------------------------
221 static void dump_regs(struct cardinfo
*card
)
227 for (i
= 0; i
< 8; i
++) {
228 printk(KERN_DEBUG
"%p ", p
);
230 for (i1
= 0; i1
< 16; i1
++)
231 printk("%02x ", *p
++);
238 -----------------------------------------------------------------------------------
240 -----------------------------------------------------------------------------------
242 static void dump_dmastat(struct cardinfo
*card
, unsigned int dmastat
)
244 printk(KERN_DEBUG
"MM%d*: DMAstat - ", card
->card_number
);
245 if (dmastat
& DMASCR_ANY_ERR
)
247 if (dmastat
& DMASCR_MBE_ERR
)
249 if (dmastat
& DMASCR_PARITY_ERR_REP
)
250 printk("PARITY_ERR_REP ");
251 if (dmastat
& DMASCR_PARITY_ERR_DET
)
252 printk("PARITY_ERR_DET ");
253 if (dmastat
& DMASCR_SYSTEM_ERR_SIG
)
254 printk("SYSTEM_ERR_SIG ");
255 if (dmastat
& DMASCR_TARGET_ABT
)
256 printk("TARGET_ABT ");
257 if (dmastat
& DMASCR_MASTER_ABT
)
258 printk("MASTER_ABT ");
259 if (dmastat
& DMASCR_CHAIN_COMPLETE
)
260 printk("CHAIN_COMPLETE ");
261 if (dmastat
& DMASCR_DMA_COMPLETE
)
262 printk("DMA_COMPLETE ");
267 * Theory of request handling
269 * Each bio is assigned to one mm_dma_desc - which may not be enough FIXME
270 * We have two pages of mm_dma_desc, holding about 64 descriptors
271 * each. These are allocated at init time.
272 * One page is "Ready" and is either full, or can have request added.
273 * The other page might be "Active", which DMA is happening on it.
275 * Whenever IO on the active page completes, the Ready page is activated
276 * and the ex-Active page is clean out and made Ready.
277 * Otherwise the Ready page is only activated when it becomes full, or
278 * when mm_unplug_device is called via the unplug_io_fn.
280 * If a request arrives while both pages a full, it is queued, and b_rdev is
281 * overloaded to record whether it was a read or a write.
283 * The interrupt handler only polls the device to clear the interrupt.
284 * The processing of the result is done in a tasklet.
287 static void mm_start_io(struct cardinfo
*card
)
289 /* we have the lock, we know there is
290 * no IO active, and we know that card->Active
293 struct mm_dma_desc
*desc
;
294 struct mm_page
*page
;
297 /* make the last descriptor end the chain */
298 page
= &card
->mm_pages
[card
->Active
];
299 pr_debug("start_io: %d %d->%d\n", card
->Active
, page
->headcnt
, page
->cnt
-1);
300 desc
= &page
->desc
[page
->cnt
-1];
302 desc
->control_bits
|= cpu_to_le32(DMASCR_CHAIN_COMP_EN
);
303 desc
->control_bits
&= ~cpu_to_le32(DMASCR_CHAIN_EN
);
304 desc
->sem_control_bits
= desc
->control_bits
;
307 if (debug
& DEBUG_LED_ON_TRANSFER
)
308 set_led(card
, LED_REMOVE
, LED_ON
);
310 desc
= &page
->desc
[page
->headcnt
];
311 writel(0, card
->csr_remap
+ DMA_PCI_ADDR
);
312 writel(0, card
->csr_remap
+ DMA_PCI_ADDR
+ 4);
314 writel(0, card
->csr_remap
+ DMA_LOCAL_ADDR
);
315 writel(0, card
->csr_remap
+ DMA_LOCAL_ADDR
+ 4);
317 writel(0, card
->csr_remap
+ DMA_TRANSFER_SIZE
);
318 writel(0, card
->csr_remap
+ DMA_TRANSFER_SIZE
+ 4);
320 writel(0, card
->csr_remap
+ DMA_SEMAPHORE_ADDR
);
321 writel(0, card
->csr_remap
+ DMA_SEMAPHORE_ADDR
+ 4);
323 offset
= ((char*)desc
) - ((char*)page
->desc
);
324 writel(cpu_to_le32((page
->page_dma
+offset
)&0xffffffff),
325 card
->csr_remap
+ DMA_DESCRIPTOR_ADDR
);
326 /* Force the value to u64 before shifting otherwise >> 32 is undefined C
327 * and on some ports will do nothing ! */
328 writel(cpu_to_le32(((u64
)page
->page_dma
)>>32),
329 card
->csr_remap
+ DMA_DESCRIPTOR_ADDR
+ 4);
332 writel(cpu_to_le32(DMASCR_GO
| DMASCR_CHAIN_EN
| pci_cmds
),
333 card
->csr_remap
+ DMA_STATUS_CTRL
);
336 static int add_bio(struct cardinfo
*card
);
338 static void activate(struct cardinfo
*card
)
340 /* if No page is Active, and Ready is
341 * not empty, then switch Ready page
342 * to active and start IO.
343 * Then add any bh's that are available to Ready
347 while (add_bio(card
))
350 if (card
->Active
== -1 &&
351 card
->mm_pages
[card
->Ready
].cnt
> 0) {
352 card
->Active
= card
->Ready
;
353 card
->Ready
= 1-card
->Ready
;
357 } while (card
->Active
== -1 && add_bio(card
));
360 static inline void reset_page(struct mm_page
*page
)
365 page
->biotail
= & page
->bio
;
368 static void mm_unplug_device(request_queue_t
*q
)
370 struct cardinfo
*card
= q
->queuedata
;
373 spin_lock_irqsave(&card
->lock
, flags
);
374 if (blk_remove_plug(q
))
376 spin_unlock_irqrestore(&card
->lock
, flags
);
380 * If there is room on Ready page, take
381 * one bh off list and add it.
382 * return 1 if there was room, else 0.
384 static int add_bio(struct cardinfo
*card
)
387 struct mm_dma_desc
*desc
;
388 dma_addr_t dma_handle
;
394 bio
= card
->currentbio
;
395 if (!bio
&& card
->bio
) {
396 card
->currentbio
= card
->bio
;
397 card
->bio
= card
->bio
->bi_next
;
398 if (card
->bio
== NULL
)
399 card
->biotail
= &card
->bio
;
400 card
->currentbio
->bi_next
= NULL
;
407 if (card
->mm_pages
[card
->Ready
].cnt
>= DESC_PER_PAGE
)
410 len
= bio_iovec(bio
)->bv_len
;
411 dma_handle
= pci_map_page(card
->dev
,
416 PCI_DMA_FROMDEVICE
: PCI_DMA_TODEVICE
);
418 p
= &card
->mm_pages
[card
->Ready
];
419 desc
= &p
->desc
[p
->cnt
];
421 if ((p
->biotail
) != &bio
->bi_next
) {
423 p
->biotail
= &(bio
->bi_next
);
427 desc
->data_dma_handle
= dma_handle
;
429 desc
->pci_addr
= cpu_to_le64((u64
)desc
->data_dma_handle
);
430 desc
->local_addr
= cpu_to_le64(bio
->bi_sector
<< 9);
431 desc
->transfer_size
= cpu_to_le32(len
);
432 offset
= ( ((char*)&desc
->sem_control_bits
) - ((char*)p
->desc
));
433 desc
->sem_addr
= cpu_to_le64((u64
)(p
->page_dma
+offset
));
434 desc
->zero1
= desc
->zero2
= 0;
435 offset
= ( ((char*)(desc
+1)) - ((char*)p
->desc
));
436 desc
->next_desc_addr
= cpu_to_le64(p
->page_dma
+offset
);
437 desc
->control_bits
= cpu_to_le32(DMASCR_GO
|DMASCR_ERR_INT_EN
|
438 DMASCR_PARITY_INT_EN
|
443 desc
->control_bits
|= cpu_to_le32(DMASCR_TRANSFER_READ
);
444 desc
->sem_control_bits
= desc
->control_bits
;
446 bio
->bi_sector
+= (len
>>9);
449 if (bio
->bi_idx
>= bio
->bi_vcnt
)
450 card
->currentbio
= NULL
;
455 static void process_page(unsigned long data
)
457 /* check if any of the requests in the page are DMA_COMPLETE,
458 * and deal with them appropriately.
459 * If we find a descriptor without DMA_COMPLETE in the semaphore, then
460 * dma must have hit an error on that descriptor, so use dma_status instead
461 * and assume that all following descriptors must be re-tried.
463 struct mm_page
*page
;
464 struct bio
*return_bio
=NULL
;
465 struct cardinfo
*card
= (struct cardinfo
*)data
;
466 unsigned int dma_status
= card
->dma_status
;
468 spin_lock_bh(&card
->lock
);
469 if (card
->Active
< 0)
471 page
= &card
->mm_pages
[card
->Active
];
473 while (page
->headcnt
< page
->cnt
) {
474 struct bio
*bio
= page
->bio
;
475 struct mm_dma_desc
*desc
= &page
->desc
[page
->headcnt
];
476 int control
= le32_to_cpu(desc
->sem_control_bits
);
480 if (!(control
& DMASCR_DMA_COMPLETE
)) {
481 control
= dma_status
;
485 idx
= bio
->bi_phys_segments
;
486 bio
->bi_phys_segments
++;
487 if (bio
->bi_phys_segments
>= bio
->bi_vcnt
)
488 page
->bio
= bio
->bi_next
;
490 pci_unmap_page(card
->dev
, desc
->data_dma_handle
,
491 bio_iovec_idx(bio
,idx
)->bv_len
,
492 (control
& DMASCR_TRANSFER_READ
) ?
493 PCI_DMA_TODEVICE
: PCI_DMA_FROMDEVICE
);
494 if (control
& DMASCR_HARD_ERROR
) {
496 clear_bit(BIO_UPTODATE
, &bio
->bi_flags
);
497 printk(KERN_WARNING
"MM%d: I/O error on sector %d/%d\n",
499 le32_to_cpu(desc
->local_addr
)>>9,
500 le32_to_cpu(desc
->transfer_size
));
501 dump_dmastat(card
, control
);
502 } else if (test_bit(BIO_RW
, &bio
->bi_rw
) &&
503 le32_to_cpu(desc
->local_addr
)>>9 == card
->init_size
) {
504 card
->init_size
+= le32_to_cpu(desc
->transfer_size
)>>9;
505 if (card
->init_size
>>1 >= card
->mm_size
) {
506 printk(KERN_INFO
"MM%d: memory now initialised\n",
508 set_userbit(card
, MEMORY_INITIALIZED
, 1);
511 if (bio
!= page
->bio
) {
512 bio
->bi_next
= return_bio
;
519 if (debug
& DEBUG_LED_ON_TRANSFER
)
520 set_led(card
, LED_REMOVE
, LED_OFF
);
522 if (card
->check_batteries
) {
523 card
->check_batteries
= 0;
524 check_batteries(card
);
526 if (page
->headcnt
>= page
->cnt
) {
531 /* haven't finished with this one yet */
532 pr_debug("do some more\n");
536 spin_unlock_bh(&card
->lock
);
539 struct bio
*bio
= return_bio
;
541 return_bio
= bio
->bi_next
;
543 bio_endio(bio
, bio
->bi_size
, 0);
548 -----------------------------------------------------------------------------------
550 -----------------------------------------------------------------------------------
552 static int mm_make_request(request_queue_t
*q
, struct bio
*bio
)
554 struct cardinfo
*card
= q
->queuedata
;
555 pr_debug("mm_make_request %ld %d\n", bh
->b_rsector
, bh
->b_size
);
557 bio
->bi_phys_segments
= bio
->bi_idx
; /* count of completed segments*/
558 spin_lock_irq(&card
->lock
);
559 *card
->biotail
= bio
;
561 card
->biotail
= &bio
->bi_next
;
563 spin_unlock_irq(&card
->lock
);
569 -----------------------------------------------------------------------------------
571 -----------------------------------------------------------------------------------
573 static irqreturn_t
mm_interrupt(int irq
, void *__card
, struct pt_regs
*regs
)
575 struct cardinfo
*card
= (struct cardinfo
*) __card
;
576 unsigned int dma_status
;
577 unsigned short cfg_status
;
581 dma_status
= le32_to_cpu(readl(card
->csr_remap
+ DMA_STATUS_CTRL
));
583 if (!(dma_status
& (DMASCR_ERROR_MASK
| DMASCR_CHAIN_COMPLETE
))) {
584 /* interrupt wasn't for me ... */
588 /* clear COMPLETION interrupts */
589 if (card
->flags
& UM_FLAG_NO_BYTE_STATUS
)
590 writel(cpu_to_le32(DMASCR_DMA_COMPLETE
|DMASCR_CHAIN_COMPLETE
),
591 card
->csr_remap
+ DMA_STATUS_CTRL
);
593 writeb((DMASCR_DMA_COMPLETE
|DMASCR_CHAIN_COMPLETE
) >> 16,
594 card
->csr_remap
+ DMA_STATUS_CTRL
+ 2);
596 /* log errors and clear interrupt status */
597 if (dma_status
& DMASCR_ANY_ERR
) {
598 unsigned int data_log1
, data_log2
;
599 unsigned int addr_log1
, addr_log2
;
600 unsigned char stat
, count
, syndrome
, check
;
602 stat
= readb(card
->csr_remap
+ MEMCTRLCMD_ERRSTATUS
);
604 data_log1
= le32_to_cpu(readl(card
->csr_remap
+ ERROR_DATA_LOG
));
605 data_log2
= le32_to_cpu(readl(card
->csr_remap
+ ERROR_DATA_LOG
+ 4));
606 addr_log1
= le32_to_cpu(readl(card
->csr_remap
+ ERROR_ADDR_LOG
));
607 addr_log2
= readb(card
->csr_remap
+ ERROR_ADDR_LOG
+ 4);
609 count
= readb(card
->csr_remap
+ ERROR_COUNT
);
610 syndrome
= readb(card
->csr_remap
+ ERROR_SYNDROME
);
611 check
= readb(card
->csr_remap
+ ERROR_CHECK
);
613 dump_dmastat(card
, dma_status
);
616 printk(KERN_ERR
"MM%d*: Memory access error detected (err count %d)\n",
617 card
->card_number
, count
);
619 printk(KERN_ERR
"MM%d*: Multi-bit EDC error\n",
622 printk(KERN_ERR
"MM%d*: Fault Address 0x%02x%08x, Fault Data 0x%08x%08x\n",
623 card
->card_number
, addr_log2
, addr_log1
, data_log2
, data_log1
);
624 printk(KERN_ERR
"MM%d*: Fault Check 0x%02x, Fault Syndrome 0x%02x\n",
625 card
->card_number
, check
, syndrome
);
627 writeb(0, card
->csr_remap
+ ERROR_COUNT
);
630 if (dma_status
& DMASCR_PARITY_ERR_REP
) {
631 printk(KERN_ERR
"MM%d*: PARITY ERROR REPORTED\n", card
->card_number
);
632 pci_read_config_word(card
->dev
, PCI_STATUS
, &cfg_status
);
633 pci_write_config_word(card
->dev
, PCI_STATUS
, cfg_status
);
636 if (dma_status
& DMASCR_PARITY_ERR_DET
) {
637 printk(KERN_ERR
"MM%d*: PARITY ERROR DETECTED\n", card
->card_number
);
638 pci_read_config_word(card
->dev
, PCI_STATUS
, &cfg_status
);
639 pci_write_config_word(card
->dev
, PCI_STATUS
, cfg_status
);
642 if (dma_status
& DMASCR_SYSTEM_ERR_SIG
) {
643 printk(KERN_ERR
"MM%d*: SYSTEM ERROR\n", card
->card_number
);
644 pci_read_config_word(card
->dev
, PCI_STATUS
, &cfg_status
);
645 pci_write_config_word(card
->dev
, PCI_STATUS
, cfg_status
);
648 if (dma_status
& DMASCR_TARGET_ABT
) {
649 printk(KERN_ERR
"MM%d*: TARGET ABORT\n", card
->card_number
);
650 pci_read_config_word(card
->dev
, PCI_STATUS
, &cfg_status
);
651 pci_write_config_word(card
->dev
, PCI_STATUS
, cfg_status
);
654 if (dma_status
& DMASCR_MASTER_ABT
) {
655 printk(KERN_ERR
"MM%d*: MASTER ABORT\n", card
->card_number
);
656 pci_read_config_word(card
->dev
, PCI_STATUS
, &cfg_status
);
657 pci_write_config_word(card
->dev
, PCI_STATUS
, cfg_status
);
660 /* and process the DMA descriptors */
661 card
->dma_status
= dma_status
;
662 tasklet_schedule(&card
->tasklet
);
669 -----------------------------------------------------------------------------------
670 -- set_fault_to_battery_status
671 -----------------------------------------------------------------------------------
674 * If both batteries are good, no LED
675 * If either battery has been warned, solid LED
676 * If both batteries are bad, flash the LED quickly
677 * If either battery is bad, flash the LED semi quickly
679 static void set_fault_to_battery_status(struct cardinfo
*card
)
681 if (card
->battery
[0].good
&& card
->battery
[1].good
)
682 set_led(card
, LED_FAULT
, LED_OFF
);
683 else if (card
->battery
[0].warned
|| card
->battery
[1].warned
)
684 set_led(card
, LED_FAULT
, LED_ON
);
685 else if (!card
->battery
[0].good
&& !card
->battery
[1].good
)
686 set_led(card
, LED_FAULT
, LED_FLASH_7_0
);
688 set_led(card
, LED_FAULT
, LED_FLASH_3_5
);
691 static void init_battery_timer(void);
695 -----------------------------------------------------------------------------------
697 -----------------------------------------------------------------------------------
699 static int check_battery(struct cardinfo
*card
, int battery
, int status
)
701 if (status
!= card
->battery
[battery
].good
) {
702 card
->battery
[battery
].good
= !card
->battery
[battery
].good
;
703 card
->battery
[battery
].last_change
= jiffies
;
705 if (card
->battery
[battery
].good
) {
706 printk(KERN_ERR
"MM%d: Battery %d now good\n",
707 card
->card_number
, battery
+ 1);
708 card
->battery
[battery
].warned
= 0;
710 printk(KERN_ERR
"MM%d: Battery %d now FAILED\n",
711 card
->card_number
, battery
+ 1);
714 } else if (!card
->battery
[battery
].good
&&
715 !card
->battery
[battery
].warned
&&
716 time_after_eq(jiffies
, card
->battery
[battery
].last_change
+
717 (HZ
* 60 * 60 * 5))) {
718 printk(KERN_ERR
"MM%d: Battery %d still FAILED after 5 hours\n",
719 card
->card_number
, battery
+ 1);
720 card
->battery
[battery
].warned
= 1;
728 -----------------------------------------------------------------------------------
730 -----------------------------------------------------------------------------------
732 static void check_batteries(struct cardinfo
*card
)
734 /* NOTE: this must *never* be called while the card
735 * is doing (bus-to-card) DMA, or you will need the
738 unsigned char status
;
741 status
= readb(card
->csr_remap
+ MEMCTRLSTATUS_BATTERY
);
742 if (debug
& DEBUG_BATTERY_POLLING
)
743 printk(KERN_DEBUG
"MM%d: checking battery status, 1 = %s, 2 = %s\n",
745 (status
& BATTERY_1_FAILURE
) ? "FAILURE" : "OK",
746 (status
& BATTERY_2_FAILURE
) ? "FAILURE" : "OK");
748 ret1
= check_battery(card
, 0, !(status
& BATTERY_1_FAILURE
));
749 ret2
= check_battery(card
, 1, !(status
& BATTERY_2_FAILURE
));
752 set_fault_to_battery_status(card
);
755 static void check_all_batteries(unsigned long ptr
)
759 for (i
= 0; i
< num_cards
; i
++)
760 if (!(cards
[i
].flags
& UM_FLAG_NO_BATT
)) {
761 struct cardinfo
*card
= &cards
[i
];
762 spin_lock_bh(&card
->lock
);
763 if (card
->Active
>= 0)
764 card
->check_batteries
= 1;
766 check_batteries(card
);
767 spin_unlock_bh(&card
->lock
);
770 init_battery_timer();
773 -----------------------------------------------------------------------------------
774 -- init_battery_timer
775 -----------------------------------------------------------------------------------
777 static void init_battery_timer(void)
779 init_timer(&battery_timer
);
780 battery_timer
.function
= check_all_batteries
;
781 battery_timer
.expires
= jiffies
+ (HZ
* 60);
782 add_timer(&battery_timer
);
785 -----------------------------------------------------------------------------------
787 -----------------------------------------------------------------------------------
789 static void del_battery_timer(void)
791 del_timer(&battery_timer
);
794 -----------------------------------------------------------------------------------
796 -----------------------------------------------------------------------------------
799 * Note no locks taken out here. In a worst case scenario, we could drop
800 * a chunk of system memory. But that should never happen, since validation
801 * happens at open or mount time, when locks are held.
803 * That's crap, since doing that while some partitions are opened
804 * or mounted will give you really nasty results.
806 static int mm_revalidate(struct gendisk
*disk
)
808 struct cardinfo
*card
= disk
->private_data
;
809 set_capacity(disk
, card
->mm_size
<< 1);
813 static int mm_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
815 struct cardinfo
*card
= bdev
->bd_disk
->private_data
;
816 int size
= card
->mm_size
* (1024 / MM_HARDSECT
);
819 * get geometry: we have to fake one... trim the size to a
820 * multiple of 2048 (1M): tell we have 32 sectors, 64 heads,
821 * whatever cylinders.
825 geo
->cylinders
= size
/ (geo
->heads
* geo
->sectors
);
830 -----------------------------------------------------------------------------------
832 -----------------------------------------------------------------------------------
833 Future support for removable devices
835 static int mm_check_change(struct gendisk
*disk
)
837 /* struct cardinfo *dev = disk->private_data; */
841 -----------------------------------------------------------------------------------
843 -----------------------------------------------------------------------------------
845 static struct block_device_operations mm_fops
= {
846 .owner
= THIS_MODULE
,
848 .revalidate_disk
= mm_revalidate
,
849 .media_changed
= mm_check_change
,
852 -----------------------------------------------------------------------------------
854 -----------------------------------------------------------------------------------
856 static int __devinit
mm_pci_probe(struct pci_dev
*dev
, const struct pci_device_id
*id
)
859 struct cardinfo
*card
= &cards
[num_cards
];
860 unsigned char mem_present
;
861 unsigned char batt_status
;
862 unsigned int saved_bar
, data
;
865 if (pci_enable_device(dev
) < 0)
868 pci_write_config_byte(dev
, PCI_LATENCY_TIMER
, 0xF8);
872 card
->card_number
= num_cards
;
874 card
->csr_base
= pci_resource_start(dev
, 0);
875 card
->csr_len
= pci_resource_len(dev
, 0);
876 #ifdef CONFIG_MM_MAP_MEMORY
877 card
->mem_base
= pci_resource_start(dev
, 1);
878 card
->mem_len
= pci_resource_len(dev
, 1);
881 printk(KERN_INFO
"Micro Memory(tm) controller #%d found at %02x:%02x (PCI Mem Module (Battery Backup))\n",
882 card
->card_number
, dev
->bus
->number
, dev
->devfn
);
884 if (pci_set_dma_mask(dev
, 0xffffffffffffffffLL
) &&
885 pci_set_dma_mask(dev
, 0xffffffffLL
)) {
886 printk(KERN_WARNING
"MM%d: NO suitable DMA found\n",num_cards
);
889 if (!request_mem_region(card
->csr_base
, card
->csr_len
, "Micro Memory")) {
890 printk(KERN_ERR
"MM%d: Unable to request memory region\n", card
->card_number
);
896 card
->csr_remap
= ioremap_nocache(card
->csr_base
, card
->csr_len
);
897 if (!card
->csr_remap
) {
898 printk(KERN_ERR
"MM%d: Unable to remap memory region\n", card
->card_number
);
901 goto failed_remap_csr
;
904 printk(KERN_INFO
"MM%d: CSR 0x%08lx -> 0x%p (0x%lx)\n", card
->card_number
,
905 card
->csr_base
, card
->csr_remap
, card
->csr_len
);
907 #ifdef CONFIG_MM_MAP_MEMORY
908 if (!request_mem_region(card
->mem_base
, card
->mem_len
, "Micro Memory")) {
909 printk(KERN_ERR
"MM%d: Unable to request memory region\n", card
->card_number
);
915 if (!(card
->mem_remap
= ioremap(card
->mem_base
, cards
->mem_len
))) {
916 printk(KERN_ERR
"MM%d: Unable to remap memory region\n", card
->card_number
);
919 goto failed_remap_mem
;
922 printk(KERN_INFO
"MM%d: MEM 0x%8lx -> 0x%8lx (0x%lx)\n", card
->card_number
,
923 card
->mem_base
, card
->mem_remap
, card
->mem_len
);
925 printk(KERN_INFO
"MM%d: MEM area not remapped (CONFIG_MM_MAP_MEMORY not set)\n",
928 switch(card
->dev
->device
) {
930 card
->flags
|= UM_FLAG_NO_BYTE_STATUS
| UM_FLAG_NO_BATTREG
;
935 card
->flags
|= UM_FLAG_NO_BYTE_STATUS
;
940 card
->flags
|= UM_FLAG_NO_BYTE_STATUS
| UM_FLAG_NO_BATTREG
| UM_FLAG_NO_BATT
;
945 magic_number
= 0x100;
949 if (readb(card
->csr_remap
+ MEMCTRLSTATUS_MAGIC
) != magic_number
) {
950 printk(KERN_ERR
"MM%d: Magic number invalid\n", card
->card_number
);
955 card
->mm_pages
[0].desc
= pci_alloc_consistent(card
->dev
,
957 &card
->mm_pages
[0].page_dma
);
958 card
->mm_pages
[1].desc
= pci_alloc_consistent(card
->dev
,
960 &card
->mm_pages
[1].page_dma
);
961 if (card
->mm_pages
[0].desc
== NULL
||
962 card
->mm_pages
[1].desc
== NULL
) {
963 printk(KERN_ERR
"MM%d: alloc failed\n", card
->card_number
);
966 reset_page(&card
->mm_pages
[0]);
967 reset_page(&card
->mm_pages
[1]);
968 card
->Ready
= 0; /* page 0 is ready */
969 card
->Active
= -1; /* no page is active */
971 card
->biotail
= &card
->bio
;
973 card
->queue
= blk_alloc_queue(GFP_KERNEL
);
977 blk_queue_make_request(card
->queue
, mm_make_request
);
978 card
->queue
->queuedata
= card
;
979 card
->queue
->unplug_fn
= mm_unplug_device
;
981 tasklet_init(&card
->tasklet
, process_page
, (unsigned long)card
);
983 card
->check_batteries
= 0;
985 mem_present
= readb(card
->csr_remap
+ MEMCTRLSTATUS_MEMORY
);
986 switch (mem_present
) {
988 card
->mm_size
= 1024 * 128;
991 card
->mm_size
= 1024 * 256;
994 card
->mm_size
= 1024 * 512;
997 card
->mm_size
= 1024 * 1024;
1000 card
->mm_size
= 1024 * 2048;
1007 /* Clear the LED's we control */
1008 set_led(card
, LED_REMOVE
, LED_OFF
);
1009 set_led(card
, LED_FAULT
, LED_OFF
);
1011 batt_status
= readb(card
->csr_remap
+ MEMCTRLSTATUS_BATTERY
);
1013 card
->battery
[0].good
= !(batt_status
& BATTERY_1_FAILURE
);
1014 card
->battery
[1].good
= !(batt_status
& BATTERY_2_FAILURE
);
1015 card
->battery
[0].last_change
= card
->battery
[1].last_change
= jiffies
;
1017 if (card
->flags
& UM_FLAG_NO_BATT
)
1018 printk(KERN_INFO
"MM%d: Size %d KB\n",
1019 card
->card_number
, card
->mm_size
);
1021 printk(KERN_INFO
"MM%d: Size %d KB, Battery 1 %s (%s), Battery 2 %s (%s)\n",
1022 card
->card_number
, card
->mm_size
,
1023 (batt_status
& BATTERY_1_DISABLED
? "Disabled" : "Enabled"),
1024 card
->battery
[0].good
? "OK" : "FAILURE",
1025 (batt_status
& BATTERY_2_DISABLED
? "Disabled" : "Enabled"),
1026 card
->battery
[1].good
? "OK" : "FAILURE");
1028 set_fault_to_battery_status(card
);
1031 pci_read_config_dword(dev
, PCI_BASE_ADDRESS_1
, &saved_bar
);
1033 pci_write_config_dword(dev
, PCI_BASE_ADDRESS_1
, data
);
1034 pci_read_config_dword(dev
, PCI_BASE_ADDRESS_1
, &data
);
1035 pci_write_config_dword(dev
, PCI_BASE_ADDRESS_1
, saved_bar
);
1040 card
->win_size
= data
;
1043 if (request_irq(dev
->irq
, mm_interrupt
, SA_SHIRQ
, "pci-umem", card
)) {
1044 printk(KERN_ERR
"MM%d: Unable to allocate IRQ\n", card
->card_number
);
1047 goto failed_req_irq
;
1050 card
->irq
= dev
->irq
;
1051 printk(KERN_INFO
"MM%d: Window size %d bytes, IRQ %d\n", card
->card_number
,
1052 card
->win_size
, card
->irq
);
1054 spin_lock_init(&card
->lock
);
1056 pci_set_drvdata(dev
, card
);
1058 if (pci_write_cmd
!= 0x0F) /* If not Memory Write & Invalidate */
1059 pci_write_cmd
= 0x07; /* then Memory Write command */
1061 if (pci_write_cmd
& 0x08) { /* use Memory Write and Invalidate */
1062 unsigned short cfg_command
;
1063 pci_read_config_word(dev
, PCI_COMMAND
, &cfg_command
);
1064 cfg_command
|= 0x10; /* Memory Write & Invalidate Enable */
1065 pci_write_config_word(dev
, PCI_COMMAND
, cfg_command
);
1067 pci_cmds
= (pci_read_cmd
<< 28) | (pci_write_cmd
<< 24);
1071 if (!get_userbit(card
, MEMORY_INITIALIZED
)) {
1072 printk(KERN_INFO
"MM%d: memory NOT initialized. Consider over-writing whole device.\n", card
->card_number
);
1073 card
->init_size
= 0;
1075 printk(KERN_INFO
"MM%d: memory already initialized\n", card
->card_number
);
1076 card
->init_size
= card
->mm_size
;
1080 writeb(EDC_STORE_CORRECT
, card
->csr_remap
+ MEMCTRLCMD_ERRCTRL
);
1086 if (card
->mm_pages
[0].desc
)
1087 pci_free_consistent(card
->dev
, PAGE_SIZE
*2,
1088 card
->mm_pages
[0].desc
,
1089 card
->mm_pages
[0].page_dma
);
1090 if (card
->mm_pages
[1].desc
)
1091 pci_free_consistent(card
->dev
, PAGE_SIZE
*2,
1092 card
->mm_pages
[1].desc
,
1093 card
->mm_pages
[1].page_dma
);
1095 #ifdef CONFIG_MM_MAP_MEMORY
1096 iounmap(card
->mem_remap
);
1098 release_mem_region(card
->mem_base
, card
->mem_len
);
1101 iounmap(card
->csr_remap
);
1103 release_mem_region(card
->csr_base
, card
->csr_len
);
1109 -----------------------------------------------------------------------------------
1111 -----------------------------------------------------------------------------------
1113 static void mm_pci_remove(struct pci_dev
*dev
)
1115 struct cardinfo
*card
= pci_get_drvdata(dev
);
1117 tasklet_kill(&card
->tasklet
);
1118 iounmap(card
->csr_remap
);
1119 release_mem_region(card
->csr_base
, card
->csr_len
);
1120 #ifdef CONFIG_MM_MAP_MEMORY
1121 iounmap(card
->mem_remap
);
1122 release_mem_region(card
->mem_base
, card
->mem_len
);
1124 free_irq(card
->irq
, card
);
1126 if (card
->mm_pages
[0].desc
)
1127 pci_free_consistent(card
->dev
, PAGE_SIZE
*2,
1128 card
->mm_pages
[0].desc
,
1129 card
->mm_pages
[0].page_dma
);
1130 if (card
->mm_pages
[1].desc
)
1131 pci_free_consistent(card
->dev
, PAGE_SIZE
*2,
1132 card
->mm_pages
[1].desc
,
1133 card
->mm_pages
[1].page_dma
);
1134 blk_cleanup_queue(card
->queue
);
1137 static const struct pci_device_id mm_pci_ids
[] = { {
1138 .vendor
= PCI_VENDOR_ID_MICRO_MEMORY
,
1139 .device
= PCI_DEVICE_ID_MICRO_MEMORY_5415CN
,
1141 .vendor
= PCI_VENDOR_ID_MICRO_MEMORY
,
1142 .device
= PCI_DEVICE_ID_MICRO_MEMORY_5425CN
,
1144 .vendor
= PCI_VENDOR_ID_MICRO_MEMORY
,
1145 .device
= PCI_DEVICE_ID_MICRO_MEMORY_6155
,
1153 }, { /* end: all zeroes */ }
1156 MODULE_DEVICE_TABLE(pci
, mm_pci_ids
);
1158 static struct pci_driver mm_pci_driver
= {
1160 .id_table
= mm_pci_ids
,
1161 .probe
= mm_pci_probe
,
1162 .remove
= mm_pci_remove
,
1165 -----------------------------------------------------------------------------------
1167 -----------------------------------------------------------------------------------
1170 static int __init
mm_init(void)
1175 printk(KERN_INFO DRIVER_VERSION
" : " DRIVER_DESC
"\n");
1177 retval
= pci_register_driver(&mm_pci_driver
);
1181 err
= major_nr
= register_blkdev(0, "umem");
1185 for (i
= 0; i
< num_cards
; i
++) {
1186 mm_gendisk
[i
] = alloc_disk(1 << MM_SHIFT
);
1191 for (i
= 0; i
< num_cards
; i
++) {
1192 struct gendisk
*disk
= mm_gendisk
[i
];
1193 sprintf(disk
->disk_name
, "umem%c", 'a'+i
);
1194 sprintf(disk
->devfs_name
, "umem/card%d", i
);
1195 spin_lock_init(&cards
[i
].lock
);
1196 disk
->major
= major_nr
;
1197 disk
->first_minor
= i
<< MM_SHIFT
;
1198 disk
->fops
= &mm_fops
;
1199 disk
->private_data
= &cards
[i
];
1200 disk
->queue
= cards
[i
].queue
;
1201 set_capacity(disk
, cards
[i
].mm_size
<< 1);
1205 init_battery_timer();
1206 printk("MM: desc_per_page = %ld\n", DESC_PER_PAGE
);
1207 /* printk("mm_init: Done. 10-19-01 9:00\n"); */
1211 unregister_blkdev(major_nr
, "umem");
1213 put_disk(mm_gendisk
[i
]);
1217 -----------------------------------------------------------------------------------
1219 -----------------------------------------------------------------------------------
1221 static void __exit
mm_cleanup(void)
1225 del_battery_timer();
1227 for (i
=0; i
< num_cards
; i
++) {
1228 del_gendisk(mm_gendisk
[i
]);
1229 put_disk(mm_gendisk
[i
]);
1232 pci_unregister_driver(&mm_pci_driver
);
1234 unregister_blkdev(major_nr
, "umem");
1237 module_init(mm_init
);
1238 module_exit(mm_cleanup
);
1240 MODULE_AUTHOR(DRIVER_AUTHOR
);
1241 MODULE_DESCRIPTION(DRIVER_DESC
);
1242 MODULE_LICENSE("GPL");