ia64/linux-2.6.18-xen.hg

view drivers/block/umem.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /*
2 * mm.c - Micro Memory(tm) PCI memory board block device driver - v2.3
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>
7 *
8 * This driver for the Micro Memory PCI Memory Module with Battery Backup
9 * is Copyright Micro Memory Inc 2001-2002. All rights reserved.
10 *
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.
14 *
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
26 * bh's instead.
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.
35 */
37 //#define DEBUG /* uncomment if you want debugging info (pr_debug) */
38 #include <linux/sched.h>
39 #include <linux/fs.h>
40 #include <linux/bio.h>
41 #include <linux/kernel.h>
42 #include <linux/mm.h>
43 #include <linux/mman.h>
44 #include <linux/ioctl.h>
45 #include <linux/module.h>
46 #include <linux/init.h>
47 #include <linux/interrupt.h>
48 #include <linux/smp_lock.h>
49 #include <linux/timer.h>
50 #include <linux/pci.h>
51 #include <linux/slab.h>
52 #include <linux/dma-mapping.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>
60 #include <asm/io.h>
62 #define MM_MAXCARDS 4
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 */
68 /*
69 * Version Information
70 */
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"
76 static int debug;
77 /* #define HW_TRACE(x) writeb(x,cards[0].csr_remap + MEMCTRLSTATUS_MAGIC) */
78 #define HW_TRACE(x)
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");
94 static int pci_cmds;
96 static int major_nr;
98 #include <linux/blkdev.h>
99 #include <linux/blkpg.h>
101 struct cardinfo {
102 int card_number;
103 struct pci_dev *dev;
105 int irq;
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;
114 #endif
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,
120 * that we know to
121 * have been written
122 */
123 struct bio *bio, *currentbio, **biotail;
125 request_queue_t *queue;
127 struct mm_page {
128 dma_addr_t page_dma;
129 struct mm_dma_desc *desc;
130 int cnt, headcnt;
131 struct bio *bio, **biotail;
132 } mm_pages[2];
133 #define DESC_PER_PAGE ((PAGE_SIZE*2)/sizeof(struct mm_dma_desc))
135 int Active, Ready;
137 struct tasklet_struct tasklet;
138 unsigned int dma_status;
140 struct {
141 int good;
142 int warned;
143 unsigned long last_change;
144 } battery[2];
146 spinlock_t lock;
147 int check_batteries;
149 int flags;
150 };
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);
162 /*
163 -----------------------------------------------------------------------------------
164 -- get_userbit
165 -----------------------------------------------------------------------------------
166 */
167 static int get_userbit(struct cardinfo *card, int bit)
168 {
169 unsigned char led;
171 led = readb(card->csr_remap + MEMCTRLCMD_LEDCTRL);
172 return led & bit;
173 }
174 /*
175 -----------------------------------------------------------------------------------
176 -- set_userbit
177 -----------------------------------------------------------------------------------
178 */
179 static int set_userbit(struct cardinfo *card, int bit, unsigned char state)
180 {
181 unsigned char led;
183 led = readb(card->csr_remap + MEMCTRLCMD_LEDCTRL);
184 if (state)
185 led |= bit;
186 else
187 led &= ~bit;
188 writeb(led, card->csr_remap + MEMCTRLCMD_LEDCTRL);
190 return 0;
191 }
192 /*
193 -----------------------------------------------------------------------------------
194 -- set_led
195 -----------------------------------------------------------------------------------
196 */
197 /*
198 * NOTE: For the power LED, use the LED_POWER_* macros since they differ
199 */
200 static void set_led(struct cardinfo *card, int shift, unsigned char state)
201 {
202 unsigned char led;
204 led = readb(card->csr_remap + MEMCTRLCMD_LEDCTRL);
205 if (state == LED_FLIP)
206 led ^= (1<<shift);
207 else {
208 led &= ~(0x03 << shift);
209 led |= (state << shift);
210 }
211 writeb(led, card->csr_remap + MEMCTRLCMD_LEDCTRL);
213 }
215 #ifdef MM_DIAG
216 /*
217 -----------------------------------------------------------------------------------
218 -- dump_regs
219 -----------------------------------------------------------------------------------
220 */
221 static void dump_regs(struct cardinfo *card)
222 {
223 unsigned char *p;
224 int i, i1;
226 p = card->csr_remap;
227 for (i = 0; i < 8; i++) {
228 printk(KERN_DEBUG "%p ", p);
230 for (i1 = 0; i1 < 16; i1++)
231 printk("%02x ", *p++);
233 printk("\n");
234 }
235 }
236 #endif
237 /*
238 -----------------------------------------------------------------------------------
239 -- dump_dmastat
240 -----------------------------------------------------------------------------------
241 */
242 static void dump_dmastat(struct cardinfo *card, unsigned int dmastat)
243 {
244 printk(KERN_DEBUG "MM%d*: DMAstat - ", card->card_number);
245 if (dmastat & DMASCR_ANY_ERR)
246 printk("ANY_ERR ");
247 if (dmastat & DMASCR_MBE_ERR)
248 printk("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 ");
263 printk("\n");
264 }
266 /*
267 * Theory of request handling
268 *
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.
274 *
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.
279 *
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.
282 *
283 * The interrupt handler only polls the device to clear the interrupt.
284 * The processing of the result is done in a tasklet.
285 */
287 static void mm_start_io(struct cardinfo *card)
288 {
289 /* we have the lock, we know there is
290 * no IO active, and we know that card->Active
291 * is set
292 */
293 struct mm_dma_desc *desc;
294 struct mm_page *page;
295 int offset;
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);
331 /* Go, go, go */
332 writel(cpu_to_le32(DMASCR_GO | DMASCR_CHAIN_EN | pci_cmds),
333 card->csr_remap + DMA_STATUS_CTRL);
334 }
336 static int add_bio(struct cardinfo *card);
338 static void activate(struct cardinfo *card)
339 {
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
344 */
346 do {
347 while (add_bio(card))
348 ;
350 if (card->Active == -1 &&
351 card->mm_pages[card->Ready].cnt > 0) {
352 card->Active = card->Ready;
353 card->Ready = 1-card->Ready;
354 mm_start_io(card);
355 }
357 } while (card->Active == -1 && add_bio(card));
358 }
360 static inline void reset_page(struct mm_page *page)
361 {
362 page->cnt = 0;
363 page->headcnt = 0;
364 page->bio = NULL;
365 page->biotail = & page->bio;
366 }
368 static void mm_unplug_device(request_queue_t *q)
369 {
370 struct cardinfo *card = q->queuedata;
371 unsigned long flags;
373 spin_lock_irqsave(&card->lock, flags);
374 if (blk_remove_plug(q))
375 activate(card);
376 spin_unlock_irqrestore(&card->lock, flags);
377 }
379 /*
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.
383 */
384 static int add_bio(struct cardinfo *card)
385 {
386 struct mm_page *p;
387 struct mm_dma_desc *desc;
388 dma_addr_t dma_handle;
389 int offset;
390 struct bio *bio;
391 int rw;
392 int len;
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;
401 return 1;
402 }
403 if (!bio)
404 return 0;
406 rw = bio_rw(bio);
407 if (card->mm_pages[card->Ready].cnt >= DESC_PER_PAGE)
408 return 0;
410 len = bio_iovec(bio)->bv_len;
411 dma_handle = pci_map_page(card->dev,
412 bio_page(bio),
413 bio_offset(bio),
414 len,
415 (rw==READ) ?
416 PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
418 p = &card->mm_pages[card->Ready];
419 desc = &p->desc[p->cnt];
420 p->cnt++;
421 if ((p->biotail) != &bio->bi_next) {
422 *(p->biotail) = bio;
423 p->biotail = &(bio->bi_next);
424 bio->bi_next = NULL;
425 }
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|
439 DMASCR_CHAIN_EN |
440 DMASCR_SEM_EN |
441 pci_cmds);
442 if (rw == WRITE)
443 desc->control_bits |= cpu_to_le32(DMASCR_TRANSFER_READ);
444 desc->sem_control_bits = desc->control_bits;
446 bio->bi_sector += (len>>9);
447 bio->bi_size -= len;
448 bio->bi_idx++;
449 if (bio->bi_idx >= bio->bi_vcnt)
450 card->currentbio = NULL;
452 return 1;
453 }
455 static void process_page(unsigned long data)
456 {
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.
462 */
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)
470 goto out_unlock;
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);
477 int last=0;
478 int idx;
480 if (!(control & DMASCR_DMA_COMPLETE)) {
481 control = dma_status;
482 last=1;
483 }
484 page->headcnt++;
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) {
495 /* error */
496 clear_bit(BIO_UPTODATE, &bio->bi_flags);
497 printk(KERN_WARNING "MM%d: I/O error on sector %d/%d\n",
498 card->card_number,
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",
507 card->card_number);
508 set_userbit(card, MEMORY_INITIALIZED, 1);
509 }
510 }
511 if (bio != page->bio) {
512 bio->bi_next = return_bio;
513 return_bio = bio;
514 }
516 if (last) break;
517 }
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);
525 }
526 if (page->headcnt >= page->cnt) {
527 reset_page(page);
528 card->Active = -1;
529 activate(card);
530 } else {
531 /* haven't finished with this one yet */
532 pr_debug("do some more\n");
533 mm_start_io(card);
534 }
535 out_unlock:
536 spin_unlock_bh(&card->lock);
538 while(return_bio) {
539 struct bio *bio = return_bio;
541 return_bio = bio->bi_next;
542 bio->bi_next = NULL;
543 bio_endio(bio, bio->bi_size, 0);
544 }
545 }
547 /*
548 -----------------------------------------------------------------------------------
549 -- mm_make_request
550 -----------------------------------------------------------------------------------
551 */
552 static int mm_make_request(request_queue_t *q, struct bio *bio)
553 {
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;
560 bio->bi_next = NULL;
561 card->biotail = &bio->bi_next;
562 blk_plug_device(q);
563 spin_unlock_irq(&card->lock);
565 return 0;
566 }
568 /*
569 -----------------------------------------------------------------------------------
570 -- mm_interrupt
571 -----------------------------------------------------------------------------------
572 */
573 static irqreturn_t mm_interrupt(int irq, void *__card, struct pt_regs *regs)
574 {
575 struct cardinfo *card = (struct cardinfo *) __card;
576 unsigned int dma_status;
577 unsigned short cfg_status;
579 HW_TRACE(0x30);
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 ... */
585 return IRQ_NONE;
586 }
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);
592 else
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);
615 if (stat & 0x01)
616 printk(KERN_ERR "MM%d*: Memory access error detected (err count %d)\n",
617 card->card_number, count);
618 if (stat & 0x02)
619 printk(KERN_ERR "MM%d*: Multi-bit EDC error\n",
620 card->card_number);
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);
628 }
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);
634 }
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);
640 }
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);
646 }
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);
652 }
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);
658 }
660 /* and process the DMA descriptors */
661 card->dma_status = dma_status;
662 tasklet_schedule(&card->tasklet);
664 HW_TRACE(0x36);
666 return IRQ_HANDLED;
667 }
668 /*
669 -----------------------------------------------------------------------------------
670 -- set_fault_to_battery_status
671 -----------------------------------------------------------------------------------
672 */
673 /*
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
678 */
679 static void set_fault_to_battery_status(struct cardinfo *card)
680 {
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);
687 else
688 set_led(card, LED_FAULT, LED_FLASH_3_5);
689 }
691 static void init_battery_timer(void);
694 /*
695 -----------------------------------------------------------------------------------
696 -- check_battery
697 -----------------------------------------------------------------------------------
698 */
699 static int check_battery(struct cardinfo *card, int battery, int status)
700 {
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;
709 } else
710 printk(KERN_ERR "MM%d: Battery %d now FAILED\n",
711 card->card_number, battery + 1);
713 return 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;
722 return 1;
723 }
725 return 0;
726 }
727 /*
728 -----------------------------------------------------------------------------------
729 -- check_batteries
730 -----------------------------------------------------------------------------------
731 */
732 static void check_batteries(struct cardinfo *card)
733 {
734 /* NOTE: this must *never* be called while the card
735 * is doing (bus-to-card) DMA, or you will need the
736 * reset switch
737 */
738 unsigned char status;
739 int ret1, ret2;
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",
744 card->card_number,
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));
751 if (ret1 || ret2)
752 set_fault_to_battery_status(card);
753 }
755 static void check_all_batteries(unsigned long ptr)
756 {
757 int i;
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;
765 else
766 check_batteries(card);
767 spin_unlock_bh(&card->lock);
768 }
770 init_battery_timer();
771 }
772 /*
773 -----------------------------------------------------------------------------------
774 -- init_battery_timer
775 -----------------------------------------------------------------------------------
776 */
777 static void init_battery_timer(void)
778 {
779 init_timer(&battery_timer);
780 battery_timer.function = check_all_batteries;
781 battery_timer.expires = jiffies + (HZ * 60);
782 add_timer(&battery_timer);
783 }
784 /*
785 -----------------------------------------------------------------------------------
786 -- del_battery_timer
787 -----------------------------------------------------------------------------------
788 */
789 static void del_battery_timer(void)
790 {
791 del_timer(&battery_timer);
792 }
793 /*
794 -----------------------------------------------------------------------------------
795 -- mm_revalidate
796 -----------------------------------------------------------------------------------
797 */
798 /*
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.
802 *
803 * That's crap, since doing that while some partitions are opened
804 * or mounted will give you really nasty results.
805 */
806 static int mm_revalidate(struct gendisk *disk)
807 {
808 struct cardinfo *card = disk->private_data;
809 set_capacity(disk, card->mm_size << 1);
810 return 0;
811 }
813 static int mm_getgeo(struct block_device *bdev, struct hd_geometry *geo)
814 {
815 struct cardinfo *card = bdev->bd_disk->private_data;
816 int size = card->mm_size * (1024 / MM_HARDSECT);
818 /*
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.
822 */
823 geo->heads = 64;
824 geo->sectors = 32;
825 geo->cylinders = size / (geo->heads * geo->sectors);
826 return 0;
827 }
829 /*
830 -----------------------------------------------------------------------------------
831 -- mm_check_change
832 -----------------------------------------------------------------------------------
833 Future support for removable devices
834 */
835 static int mm_check_change(struct gendisk *disk)
836 {
837 /* struct cardinfo *dev = disk->private_data; */
838 return 0;
839 }
840 /*
841 -----------------------------------------------------------------------------------
842 -- mm_fops
843 -----------------------------------------------------------------------------------
844 */
845 static struct block_device_operations mm_fops = {
846 .owner = THIS_MODULE,
847 .getgeo = mm_getgeo,
848 .revalidate_disk= mm_revalidate,
849 .media_changed = mm_check_change,
850 };
851 /*
852 -----------------------------------------------------------------------------------
853 -- mm_pci_probe
854 -----------------------------------------------------------------------------------
855 */
856 static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
857 {
858 int ret = -ENODEV;
859 struct cardinfo *card = &cards[num_cards];
860 unsigned char mem_present;
861 unsigned char batt_status;
862 unsigned int saved_bar, data;
863 int magic_number;
865 if (pci_enable_device(dev) < 0)
866 return -ENODEV;
868 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xF8);
869 pci_set_master(dev);
871 card->dev = dev;
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);
879 #endif
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, DMA_64BIT_MASK) &&
885 pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
886 printk(KERN_WARNING "MM%d: NO suitable DMA found\n",num_cards);
887 return -ENOMEM;
888 }
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);
891 ret = -ENOMEM;
893 goto failed_req_csr;
894 }
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);
899 ret = -ENOMEM;
901 goto failed_remap_csr;
902 }
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);
910 ret = -ENOMEM;
912 goto failed_req_mem;
913 }
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);
917 ret = -ENOMEM;
919 goto failed_remap_mem;
920 }
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);
924 #else
925 printk(KERN_INFO "MM%d: MEM area not remapped (CONFIG_MM_MAP_MEMORY not set)\n",
926 card->card_number);
927 #endif
928 switch(card->dev->device) {
929 case 0x5415:
930 card->flags |= UM_FLAG_NO_BYTE_STATUS | UM_FLAG_NO_BATTREG;
931 magic_number = 0x59;
932 break;
934 case 0x5425:
935 card->flags |= UM_FLAG_NO_BYTE_STATUS;
936 magic_number = 0x5C;
937 break;
939 case 0x6155:
940 card->flags |= UM_FLAG_NO_BYTE_STATUS | UM_FLAG_NO_BATTREG | UM_FLAG_NO_BATT;
941 magic_number = 0x99;
942 break;
944 default:
945 magic_number = 0x100;
946 break;
947 }
949 if (readb(card->csr_remap + MEMCTRLSTATUS_MAGIC) != magic_number) {
950 printk(KERN_ERR "MM%d: Magic number invalid\n", card->card_number);
951 ret = -ENOMEM;
952 goto failed_magic;
953 }
955 card->mm_pages[0].desc = pci_alloc_consistent(card->dev,
956 PAGE_SIZE*2,
957 &card->mm_pages[0].page_dma);
958 card->mm_pages[1].desc = pci_alloc_consistent(card->dev,
959 PAGE_SIZE*2,
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);
964 goto failed_alloc;
965 }
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 */
970 card->bio = NULL;
971 card->biotail = &card->bio;
973 card->queue = blk_alloc_queue(GFP_KERNEL);
974 if (!card->queue)
975 goto failed_alloc;
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) {
987 case MEM_128_MB:
988 card->mm_size = 1024 * 128;
989 break;
990 case MEM_256_MB:
991 card->mm_size = 1024 * 256;
992 break;
993 case MEM_512_MB:
994 card->mm_size = 1024 * 512;
995 break;
996 case MEM_1_GB:
997 card->mm_size = 1024 * 1024;
998 break;
999 case MEM_2_GB:
1000 card->mm_size = 1024 * 2048;
1001 break;
1002 default:
1003 card->mm_size = 0;
1004 break;
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);
1020 else {
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);
1032 data = 0xffffffff;
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);
1036 data &= 0xfffffff0;
1037 data = ~data;
1038 data += 1;
1040 card->win_size = data;
1043 if (request_irq(dev->irq, mm_interrupt, IRQF_SHARED, "pci-umem", card)) {
1044 printk(KERN_ERR "MM%d: Unable to allocate IRQ\n", card->card_number);
1045 ret = -ENODEV;
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);
1069 num_cards++;
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;
1074 } else {
1075 printk(KERN_INFO "MM%d: memory already initialized\n", card->card_number);
1076 card->init_size = card->mm_size;
1079 /* Enable ECC */
1080 writeb(EDC_STORE_CORRECT, card->csr_remap + MEMCTRLCMD_ERRCTRL);
1082 return 0;
1084 failed_req_irq:
1085 failed_alloc:
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);
1094 failed_magic:
1095 #ifdef CONFIG_MM_MAP_MEMORY
1096 iounmap(card->mem_remap);
1097 failed_remap_mem:
1098 release_mem_region(card->mem_base, card->mem_len);
1099 failed_req_mem:
1100 #endif
1101 iounmap(card->csr_remap);
1102 failed_remap_csr:
1103 release_mem_region(card->csr_base, card->csr_len);
1104 failed_req_csr:
1106 return ret;
1108 /*
1109 -----------------------------------------------------------------------------------
1110 -- mm_pci_remove
1111 -----------------------------------------------------------------------------------
1112 */
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);
1123 #endif
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,
1140 }, {
1141 .vendor = PCI_VENDOR_ID_MICRO_MEMORY,
1142 .device = PCI_DEVICE_ID_MICRO_MEMORY_5425CN,
1143 }, {
1144 .vendor = PCI_VENDOR_ID_MICRO_MEMORY,
1145 .device = PCI_DEVICE_ID_MICRO_MEMORY_6155,
1146 }, {
1147 .vendor = 0x8086,
1148 .device = 0xB555,
1149 .subvendor= 0x1332,
1150 .subdevice= 0x5460,
1151 .class = 0x050000,
1152 .class_mask= 0,
1153 }, { /* end: all zeroes */ }
1154 };
1156 MODULE_DEVICE_TABLE(pci, mm_pci_ids);
1158 static struct pci_driver mm_pci_driver = {
1159 .name = "umem",
1160 .id_table = mm_pci_ids,
1161 .probe = mm_pci_probe,
1162 .remove = mm_pci_remove,
1163 };
1164 /*
1165 -----------------------------------------------------------------------------------
1166 -- mm_init
1167 -----------------------------------------------------------------------------------
1168 */
1170 static int __init mm_init(void)
1172 int retval, i;
1173 int err;
1175 printk(KERN_INFO DRIVER_VERSION " : " DRIVER_DESC "\n");
1177 retval = pci_register_driver(&mm_pci_driver);
1178 if (retval)
1179 return -ENOMEM;
1181 err = major_nr = register_blkdev(0, "umem");
1182 if (err < 0)
1183 return -EIO;
1185 for (i = 0; i < num_cards; i++) {
1186 mm_gendisk[i] = alloc_disk(1 << MM_SHIFT);
1187 if (!mm_gendisk[i])
1188 goto out;
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 spin_lock_init(&cards[i].lock);
1195 disk->major = major_nr;
1196 disk->first_minor = i << MM_SHIFT;
1197 disk->fops = &mm_fops;
1198 disk->private_data = &cards[i];
1199 disk->queue = cards[i].queue;
1200 set_capacity(disk, cards[i].mm_size << 1);
1201 add_disk(disk);
1204 init_battery_timer();
1205 printk("MM: desc_per_page = %ld\n", DESC_PER_PAGE);
1206 /* printk("mm_init: Done. 10-19-01 9:00\n"); */
1207 return 0;
1209 out:
1210 unregister_blkdev(major_nr, "umem");
1211 while (i--)
1212 put_disk(mm_gendisk[i]);
1213 return -ENOMEM;
1215 /*
1216 -----------------------------------------------------------------------------------
1217 -- mm_cleanup
1218 -----------------------------------------------------------------------------------
1219 */
1220 static void __exit mm_cleanup(void)
1222 int i;
1224 del_battery_timer();
1226 for (i=0; i < num_cards ; i++) {
1227 del_gendisk(mm_gendisk[i]);
1228 put_disk(mm_gendisk[i]);
1231 pci_unregister_driver(&mm_pci_driver);
1233 unregister_blkdev(major_nr, "umem");
1236 module_init(mm_init);
1237 module_exit(mm_cleanup);
1239 MODULE_AUTHOR(DRIVER_AUTHOR);
1240 MODULE_DESCRIPTION(DRIVER_DESC);
1241 MODULE_LICENSE("GPL");