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 */ 36 37#undef DEBUG /* #define DEBUG if you want debugging info (pr_debug) */ 38#include <linux/fs.h> 39#include <linux/bio.h> 40#include <linux/kernel.h> 41#include <linux/mm.h> 42#include <linux/mman.h> 43#include <linux/gfp.h> 44#include <linux/ioctl.h> 45#include <linux/module.h> 46#include <linux/init.h> 47#include <linux/interrupt.h> 48#include <linux/timer.h> 49#include <linux/pci.h> 50#include <linux/dma-mapping.h> 51 52#include <linux/fcntl.h> /* O_ACCMODE */ 53#include <linux/hdreg.h> /* HDIO_GETGEO */ 54 55#include "umem.h" 56 57#include <asm/uaccess.h> 58#include <asm/io.h> 59 60#define MM_MAXCARDS 4 61#define MM_RAHEAD 2 /* two sectors */ 62#define MM_BLKSIZE 1024 /* 1k blocks */ 63#define MM_HARDSECT 512 /* 512-byte hardware sectors */ 64#define MM_SHIFT 6 /* max 64 partitions on 4 cards */ 65 66/* 67 * Version Information 68 */ 69 70#define DRIVER_NAME "umem" 71#define DRIVER_VERSION "v2.3" 72#define DRIVER_AUTHOR "San Mehat, Johannes Erdfelt, NeilBrown" 73#define DRIVER_DESC "Micro Memory(tm) PCI memory board block driver" 74 75static int debug; 76/* #define HW_TRACE(x) writeb(x,cards[0].csr_remap + MEMCTRLSTATUS_MAGIC) */ 77#define HW_TRACE(x) 78 79#define DEBUG_LED_ON_TRANSFER 0x01 80#define DEBUG_BATTERY_POLLING 0x02 81 82module_param(debug, int, 0644); 83MODULE_PARM_DESC(debug, "Debug bitmask"); 84 85static int pci_read_cmd = 0x0C; /* Read Multiple */ 86module_param(pci_read_cmd, int, 0); 87MODULE_PARM_DESC(pci_read_cmd, "PCI read command"); 88 89static int pci_write_cmd = 0x0F; /* Write and Invalidate */ 90module_param(pci_write_cmd, int, 0); 91MODULE_PARM_DESC(pci_write_cmd, "PCI write command"); 92 93static int pci_cmds; 94 95static int major_nr; 96 97#include <linux/blkdev.h> 98#include <linux/blkpg.h> 99 100struct cardinfo { 101 struct pci_dev *dev; 102 103 unsigned char __iomem *csr_remap; 104 unsigned int mm_size; /* size in kbytes */ 105 106 unsigned int init_size; /* initial segment, in sectors, 107 * that we know to 108 * have been written 109 */ 110 struct bio *bio, *currentbio, **biotail; 111 int current_idx; 112 sector_t current_sector; 113 114 struct request_queue *queue; 115 116 struct mm_page { 117 dma_addr_t page_dma; 118 struct mm_dma_desc *desc; 119 int cnt, headcnt; 120 struct bio *bio, **biotail; 121 int idx; 122 } mm_pages[2]; 123#define DESC_PER_PAGE ((PAGE_SIZE*2)/sizeof(struct mm_dma_desc)) 124 125 int Active, Ready; 126 127 struct tasklet_struct tasklet; 128 unsigned int dma_status; 129 130 struct { 131 int good; 132 int warned; 133 unsigned long last_change; 134 } battery[2]; 135 136 spinlock_t lock; 137 int check_batteries; 138 139 int flags; 140}; 141 142static struct cardinfo cards[MM_MAXCARDS]; 143static struct timer_list battery_timer; 144 145static int num_cards; 146 147static struct gendisk *mm_gendisk[MM_MAXCARDS]; 148 149static void check_batteries(struct cardinfo *card); 150 151static int get_userbit(struct cardinfo *card, int bit) 152{ 153 unsigned char led; 154 155 led = readb(card->csr_remap + MEMCTRLCMD_LEDCTRL); 156 return led & bit; 157} 158 159static int set_userbit(struct cardinfo *card, int bit, unsigned char state) 160{ 161 unsigned char led; 162 163 led = readb(card->csr_remap + MEMCTRLCMD_LEDCTRL); 164 if (state) 165 led |= bit; 166 else 167 led &= ~bit; 168 writeb(led, card->csr_remap + MEMCTRLCMD_LEDCTRL); 169 170 return 0; 171} 172 173/* 174 * NOTE: For the power LED, use the LED_POWER_* macros since they differ 175 */ 176static void set_led(struct cardinfo *card, int shift, unsigned char state) 177{ 178 unsigned char led; 179 180 led = readb(card->csr_remap + MEMCTRLCMD_LEDCTRL); 181 if (state == LED_FLIP) 182 led ^= (1<<shift); 183 else { 184 led &= ~(0x03 << shift); 185 led |= (state << shift); 186 } 187 writeb(led, card->csr_remap + MEMCTRLCMD_LEDCTRL); 188 189} 190 191#ifdef MM_DIAG 192static void dump_regs(struct cardinfo *card) 193{ 194 unsigned char *p; 195 int i, i1; 196 197 p = card->csr_remap; 198 for (i = 0; i < 8; i++) { 199 printk(KERN_DEBUG "%p ", p); 200 201 for (i1 = 0; i1 < 16; i1++) 202 printk("%02x ", *p++); 203 204 printk("\n"); 205 } 206} 207#endif 208 209static void dump_dmastat(struct cardinfo *card, unsigned int dmastat) 210{ 211 dev_printk(KERN_DEBUG, &card->dev->dev, "DMAstat - "); 212 if (dmastat & DMASCR_ANY_ERR) 213 printk(KERN_CONT "ANY_ERR "); 214 if (dmastat & DMASCR_MBE_ERR) 215 printk(KERN_CONT "MBE_ERR "); 216 if (dmastat & DMASCR_PARITY_ERR_REP) 217 printk(KERN_CONT "PARITY_ERR_REP "); 218 if (dmastat & DMASCR_PARITY_ERR_DET) 219 printk(KERN_CONT "PARITY_ERR_DET "); 220 if (dmastat & DMASCR_SYSTEM_ERR_SIG) 221 printk(KERN_CONT "SYSTEM_ERR_SIG "); 222 if (dmastat & DMASCR_TARGET_ABT) 223 printk(KERN_CONT "TARGET_ABT "); 224 if (dmastat & DMASCR_MASTER_ABT) 225 printk(KERN_CONT "MASTER_ABT "); 226 if (dmastat & DMASCR_CHAIN_COMPLETE) 227 printk(KERN_CONT "CHAIN_COMPLETE "); 228 if (dmastat & DMASCR_DMA_COMPLETE) 229 printk(KERN_CONT "DMA_COMPLETE "); 230 printk("\n"); 231} 232 233 234static void mm_start_io(struct cardinfo *card) 235{ 236 /* we have the lock, we know there is 237 * no IO active, and we know that card->Active 238 * is set 239 */ 240 struct mm_dma_desc *desc; 241 struct mm_page *page; 242 int offset; 243 244 /* make the last descriptor end the chain */ 245 page = &card->mm_pages[card->Active]; 246 pr_debug("start_io: %d %d->%d\n", 247 card->Active, page->headcnt, page->cnt - 1); 248 desc = &page->desc[page->cnt-1]; 249 250 desc->control_bits |= cpu_to_le32(DMASCR_CHAIN_COMP_EN); 251 desc->control_bits &= ~cpu_to_le32(DMASCR_CHAIN_EN); 252 desc->sem_control_bits = desc->control_bits; 253 254 255 if (debug & DEBUG_LED_ON_TRANSFER) 256 set_led(card, LED_REMOVE, LED_ON); 257 258 desc = &page->desc[page->headcnt]; 259 writel(0, card->csr_remap + DMA_PCI_ADDR); 260 writel(0, card->csr_remap + DMA_PCI_ADDR + 4); 261 262 writel(0, card->csr_remap + DMA_LOCAL_ADDR); 263 writel(0, card->csr_remap + DMA_LOCAL_ADDR + 4); 264 265 writel(0, card->csr_remap + DMA_TRANSFER_SIZE); 266 writel(0, card->csr_remap + DMA_TRANSFER_SIZE + 4); 267 268 writel(0, card->csr_remap + DMA_SEMAPHORE_ADDR); 269 writel(0, card->csr_remap + DMA_SEMAPHORE_ADDR + 4); 270 271 offset = ((char *)desc) - ((char *)page->desc); 272 writel(cpu_to_le32((page->page_dma+offset) & 0xffffffff), 273 card->csr_remap + DMA_DESCRIPTOR_ADDR); 274 /* Force the value to u64 before shifting otherwise >> 32 is undefined C 275 * and on some ports will do nothing ! */ 276 writel(cpu_to_le32(((u64)page->page_dma)>>32), 277 card->csr_remap + DMA_DESCRIPTOR_ADDR + 4); 278 279 /* Go, go, go */ 280 writel(cpu_to_le32(DMASCR_GO | DMASCR_CHAIN_EN | pci_cmds), 281 card->csr_remap + DMA_STATUS_CTRL); 282} 283 284static int add_bio(struct cardinfo *card); 285 286static void activate(struct cardinfo *card) 287{ 288 /* if No page is Active, and Ready is 289 * not empty, then switch Ready page 290 * to active and start IO. 291 * Then add any bh's that are available to Ready 292 */ 293 294 do { 295 while (add_bio(card)) 296 ; 297 298 if (card->Active == -1 && 299 card->mm_pages[card->Ready].cnt > 0) { 300 card->Active = card->Ready; 301 card->Ready = 1-card->Ready; 302 mm_start_io(card); 303 } 304 305 } while (card->Active == -1 && add_bio(card)); 306} 307 308static inline void reset_page(struct mm_page *page) 309{ 310 page->cnt = 0; 311 page->headcnt = 0; 312 page->bio = NULL; 313 page->biotail = &page->bio; 314} 315 316static void mm_unplug_device(struct request_queue *q) 317{ 318 struct cardinfo *card = q->queuedata; 319 unsigned long flags; 320 321 spin_lock_irqsave(&card->lock, flags); 322 if (blk_remove_plug(q)) 323 activate(card); 324 spin_unlock_irqrestore(&card->lock, flags); 325} 326 327/* 328 * If there is room on Ready page, take 329 * one bh off list and add it. 330 * return 1 if there was room, else 0. 331 */ 332static int add_bio(struct cardinfo *card) 333{ 334 struct mm_page *p; 335 struct mm_dma_desc *desc; 336 dma_addr_t dma_handle; 337 int offset; 338 struct bio *bio; 339 struct bio_vec *vec; 340 int idx; 341 int rw; 342 int len; 343 344 bio = card->currentbio; 345 if (!bio && card->bio) { 346 card->currentbio = card->bio; 347 card->current_idx = card->bio->bi_idx; 348 card->current_sector = card->bio->bi_sector; 349 card->bio = card->bio->bi_next; 350 if (card->bio == NULL) 351 card->biotail = &card->bio; 352 card->currentbio->bi_next = NULL; 353 return 1; 354 } 355 if (!bio) 356 return 0; 357 idx = card->current_idx; 358 359 rw = bio_rw(bio); 360 if (card->mm_pages[card->Ready].cnt >= DESC_PER_PAGE) 361 return 0; 362 363 vec = bio_iovec_idx(bio, idx); 364 len = vec->bv_len; 365 dma_handle = pci_map_page(card->dev, 366 vec->bv_page, 367 vec->bv_offset, 368 len, 369 (rw == READ) ? 370 PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE); 371 372 p = &card->mm_pages[card->Ready]; 373 desc = &p->desc[p->cnt]; 374 p->cnt++; 375 if (p->bio == NULL) 376 p->idx = idx; 377 if ((p->biotail) != &bio->bi_next) { 378 *(p->biotail) = bio; 379 p->biotail = &(bio->bi_next); 380 bio->bi_next = NULL; 381 } 382 383 desc->data_dma_handle = dma_handle; 384 385 desc->pci_addr = cpu_to_le64((u64)desc->data_dma_handle); 386 desc->local_addr = cpu_to_le64(card->current_sector << 9); 387 desc->transfer_size = cpu_to_le32(len); 388 offset = (((char *)&desc->sem_control_bits) - ((char *)p->desc)); 389 desc->sem_addr = cpu_to_le64((u64)(p->page_dma+offset)); 390 desc->zero1 = desc->zero2 = 0; 391 offset = (((char *)(desc+1)) - ((char *)p->desc)); 392 desc->next_desc_addr = cpu_to_le64(p->page_dma+offset); 393 desc->control_bits = cpu_to_le32(DMASCR_GO|DMASCR_ERR_INT_EN| 394 DMASCR_PARITY_INT_EN| 395 DMASCR_CHAIN_EN | 396 DMASCR_SEM_EN | 397 pci_cmds); 398 if (rw == WRITE) 399 desc->control_bits |= cpu_to_le32(DMASCR_TRANSFER_READ); 400 desc->sem_control_bits = desc->control_bits; 401 402 card->current_sector += (len >> 9); 403 idx++; 404 card->current_idx = idx; 405 if (idx >= bio->bi_vcnt) 406 card->currentbio = NULL; 407 408 return 1; 409} 410 411static void process_page(unsigned long data) 412{ 413 /* check if any of the requests in the page are DMA_COMPLETE, 414 * and deal with them appropriately. 415 * If we find a descriptor without DMA_COMPLETE in the semaphore, then 416 * dma must have hit an error on that descriptor, so use dma_status 417 * instead and assume that all following descriptors must be re-tried. 418 */ 419 struct mm_page *page; 420 struct bio *return_bio = NULL; 421 struct cardinfo *card = (struct cardinfo *)data; 422 unsigned int dma_status = card->dma_status; 423 424 spin_lock_bh(&card->lock); 425 if (card->Active < 0) 426 goto out_unlock; 427 page = &card->mm_pages[card->Active]; 428 429 while (page->headcnt < page->cnt) { 430 struct bio *bio = page->bio; 431 struct mm_dma_desc *desc = &page->desc[page->headcnt]; 432 int control = le32_to_cpu(desc->sem_control_bits); 433 int last = 0; 434 int idx; 435 436 if (!(control & DMASCR_DMA_COMPLETE)) { 437 control = dma_status; 438 last = 1; 439 } 440 page->headcnt++; 441 idx = page->idx; 442 page->idx++; 443 if (page->idx >= bio->bi_vcnt) { 444 page->bio = bio->bi_next; 445 if (page->bio) 446 page->idx = page->bio->bi_idx; 447 } 448 449 pci_unmap_page(card->dev, desc->data_dma_handle, 450 bio_iovec_idx(bio, idx)->bv_len, 451 (control & DMASCR_TRANSFER_READ) ? 452 PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE); 453 if (control & DMASCR_HARD_ERROR) { 454 /* error */ 455 clear_bit(BIO_UPTODATE, &bio->bi_flags); 456 dev_printk(KERN_WARNING, &card->dev->dev, 457 "I/O error on sector %d/%d\n", 458 le32_to_cpu(desc->local_addr)>>9, 459 le32_to_cpu(desc->transfer_size)); 460 dump_dmastat(card, control); 461 } else if ((bio->bi_rw & REQ_WRITE) && 462 le32_to_cpu(desc->local_addr) >> 9 == 463 card->init_size) { 464 card->init_size += le32_to_cpu(desc->transfer_size) >> 9; 465 if (card->init_size >> 1 >= card->mm_size) { 466 dev_printk(KERN_INFO, &card->dev->dev, 467 "memory now initialised\n"); 468 set_userbit(card, MEMORY_INITIALIZED, 1); 469 } 470 } 471 if (bio != page->bio) { 472 bio->bi_next = return_bio; 473 return_bio = bio; 474 } 475 476 if (last) 477 break; 478 } 479 480 if (debug & DEBUG_LED_ON_TRANSFER) 481 set_led(card, LED_REMOVE, LED_OFF); 482 483 if (card->check_batteries) { 484 card->check_batteries = 0; 485 check_batteries(card); 486 } 487 if (page->headcnt >= page->cnt) { 488 reset_page(page); 489 card->Active = -1; 490 activate(card); 491 } else { 492 /* haven't finished with this one yet */ 493 pr_debug("do some more\n"); 494 mm_start_io(card); 495 } 496 out_unlock: 497 spin_unlock_bh(&card->lock); 498 499 while (return_bio) { 500 struct bio *bio = return_bio; 501 502 return_bio = bio->bi_next; 503 bio->bi_next = NULL; 504 bio_endio(bio, 0); 505 } 506} 507 508static int mm_make_request(struct request_queue *q, struct bio *bio) 509{ 510 struct cardinfo *card = q->queuedata; 511 pr_debug("mm_make_request %llu %u\n", 512 (unsigned long long)bio->bi_sector, bio->bi_size); 513 514 spin_lock_irq(&card->lock); 515 *card->biotail = bio; 516 bio->bi_next = NULL; 517 card->biotail = &bio->bi_next; 518 blk_plug_device(q); 519 spin_unlock_irq(&card->lock); 520 521 return 0; 522} 523 524static irqreturn_t mm_interrupt(int irq, void *__card) 525{ 526 struct cardinfo *card = (struct cardinfo *) __card; 527 unsigned int dma_status; 528 unsigned short cfg_status; 529 530HW_TRACE(0x30); 531 532 dma_status = le32_to_cpu(readl(card->csr_remap + DMA_STATUS_CTRL)); 533 534 if (!(dma_status & (DMASCR_ERROR_MASK | DMASCR_CHAIN_COMPLETE))) { 535 /* interrupt wasn't for me ... */ 536 return IRQ_NONE; 537 } 538 539 /* clear COMPLETION interrupts */ 540 if (card->flags & UM_FLAG_NO_BYTE_STATUS) 541 writel(cpu_to_le32(DMASCR_DMA_COMPLETE|DMASCR_CHAIN_COMPLETE), 542 card->csr_remap + DMA_STATUS_CTRL); 543 else 544 writeb((DMASCR_DMA_COMPLETE|DMASCR_CHAIN_COMPLETE) >> 16, 545 card->csr_remap + DMA_STATUS_CTRL + 2); 546 547 /* log errors and clear interrupt status */ 548 if (dma_status & DMASCR_ANY_ERR) { 549 unsigned int data_log1, data_log2; 550 unsigned int addr_log1, addr_log2; 551 unsigned char stat, count, syndrome, check; 552 553 stat = readb(card->csr_remap + MEMCTRLCMD_ERRSTATUS); 554 555 data_log1 = le32_to_cpu(readl(card->csr_remap + 556 ERROR_DATA_LOG)); 557 data_log2 = le32_to_cpu(readl(card->csr_remap + 558 ERROR_DATA_LOG + 4)); 559 addr_log1 = le32_to_cpu(readl(card->csr_remap + 560 ERROR_ADDR_LOG)); 561 addr_log2 = readb(card->csr_remap + ERROR_ADDR_LOG + 4); 562 563 count = readb(card->csr_remap + ERROR_COUNT); 564 syndrome = readb(card->csr_remap + ERROR_SYNDROME); 565 check = readb(card->csr_remap + ERROR_CHECK); 566 567 dump_dmastat(card, dma_status); 568 569 if (stat & 0x01) 570 dev_printk(KERN_ERR, &card->dev->dev, 571 "Memory access error detected (err count %d)\n", 572 count); 573 if (stat & 0x02) 574 dev_printk(KERN_ERR, &card->dev->dev, 575 "Multi-bit EDC error\n"); 576 577 dev_printk(KERN_ERR, &card->dev->dev, 578 "Fault Address 0x%02x%08x, Fault Data 0x%08x%08x\n", 579 addr_log2, addr_log1, data_log2, data_log1); 580 dev_printk(KERN_ERR, &card->dev->dev, 581 "Fault Check 0x%02x, Fault Syndrome 0x%02x\n", 582 check, syndrome); 583 584 writeb(0, card->csr_remap + ERROR_COUNT); 585 } 586 587 if (dma_status & DMASCR_PARITY_ERR_REP) { 588 dev_printk(KERN_ERR, &card->dev->dev, 589 "PARITY ERROR REPORTED\n"); 590 pci_read_config_word(card->dev, PCI_STATUS, &cfg_status); 591 pci_write_config_word(card->dev, PCI_STATUS, cfg_status); 592 } 593 594 if (dma_status & DMASCR_PARITY_ERR_DET) { 595 dev_printk(KERN_ERR, &card->dev->dev, 596 "PARITY ERROR DETECTED\n"); 597 pci_read_config_word(card->dev, PCI_STATUS, &cfg_status); 598 pci_write_config_word(card->dev, PCI_STATUS, cfg_status); 599 } 600 601 if (dma_status & DMASCR_SYSTEM_ERR_SIG) { 602 dev_printk(KERN_ERR, &card->dev->dev, "SYSTEM ERROR\n"); 603 pci_read_config_word(card->dev, PCI_STATUS, &cfg_status); 604 pci_write_config_word(card->dev, PCI_STATUS, cfg_status); 605 } 606 607 if (dma_status & DMASCR_TARGET_ABT) { 608 dev_printk(KERN_ERR, &card->dev->dev, "TARGET ABORT\n"); 609 pci_read_config_word(card->dev, PCI_STATUS, &cfg_status); 610 pci_write_config_word(card->dev, PCI_STATUS, cfg_status); 611 } 612 613 if (dma_status & DMASCR_MASTER_ABT) { 614 dev_printk(KERN_ERR, &card->dev->dev, "MASTER ABORT\n"); 615 pci_read_config_word(card->dev, PCI_STATUS, &cfg_status); 616 pci_write_config_word(card->dev, PCI_STATUS, cfg_status); 617 } 618 619 /* and process the DMA descriptors */ 620 card->dma_status = dma_status; 621 tasklet_schedule(&card->tasklet); 622 623HW_TRACE(0x36); 624 625 return IRQ_HANDLED; 626} 627 628/* 629 * If both batteries are good, no LED 630 * If either battery has been warned, solid LED 631 * If both batteries are bad, flash the LED quickly 632 * If either battery is bad, flash the LED semi quickly 633 */ 634static void set_fault_to_battery_status(struct cardinfo *card) 635{ 636 if (card->battery[0].good && card->battery[1].good) 637 set_led(card, LED_FAULT, LED_OFF); 638 else if (card->battery[0].warned || card->battery[1].warned) 639 set_led(card, LED_FAULT, LED_ON); 640 else if (!card->battery[0].good && !card->battery[1].good) 641 set_led(card, LED_FAULT, LED_FLASH_7_0); 642 else 643 set_led(card, LED_FAULT, LED_FLASH_3_5); 644} 645 646static void init_battery_timer(void); 647 648static int check_battery(struct cardinfo *card, int battery, int status) 649{ 650 if (status != card->battery[battery].good) { 651 card->battery[battery].good = !card->battery[battery].good; 652 card->battery[battery].last_change = jiffies; 653 654 if (card->battery[battery].good) { 655 dev_printk(KERN_ERR, &card->dev->dev, 656 "Battery %d now good\n", battery + 1); 657 card->battery[battery].warned = 0; 658 } else 659 dev_printk(KERN_ERR, &card->dev->dev, 660 "Battery %d now FAILED\n", battery + 1); 661 662 return 1; 663 } else if (!card->battery[battery].good && 664 !card->battery[battery].warned && 665 time_after_eq(jiffies, card->battery[battery].last_change + 666 (HZ * 60 * 60 * 5))) { 667 dev_printk(KERN_ERR, &card->dev->dev, 668 "Battery %d still FAILED after 5 hours\n", battery + 1); 669 card->battery[battery].warned = 1; 670 671 return 1; 672 } 673 674 return 0; 675} 676 677static void check_batteries(struct cardinfo *card) 678{ 679 /* NOTE: this must *never* be called while the card 680 * is doing (bus-to-card) DMA, or you will need the 681 * reset switch 682 */ 683 unsigned char status; 684 int ret1, ret2; 685 686 status = readb(card->csr_remap + MEMCTRLSTATUS_BATTERY); 687 if (debug & DEBUG_BATTERY_POLLING) 688 dev_printk(KERN_DEBUG, &card->dev->dev, 689 "checking battery status, 1 = %s, 2 = %s\n", 690 (status & BATTERY_1_FAILURE) ? "FAILURE" : "OK", 691 (status & BATTERY_2_FAILURE) ? "FAILURE" : "OK"); 692 693 ret1 = check_battery(card, 0, !(status & BATTERY_1_FAILURE)); 694 ret2 = check_battery(card, 1, !(status & BATTERY_2_FAILURE)); 695 696 if (ret1 || ret2) 697 set_fault_to_battery_status(card); 698} 699 700static void check_all_batteries(unsigned long ptr) 701{ 702 int i; 703 704 for (i = 0; i < num_cards; i++) 705 if (!(cards[i].flags & UM_FLAG_NO_BATT)) { 706 struct cardinfo *card = &cards[i]; 707 spin_lock_bh(&card->lock); 708 if (card->Active >= 0) 709 card->check_batteries = 1; 710 else 711 check_batteries(card); 712 spin_unlock_bh(&card->lock); 713 } 714 715 init_battery_timer(); 716} 717 718static void init_battery_timer(void) 719{ 720 init_timer(&battery_timer); 721 battery_timer.function = check_all_batteries; 722 battery_timer.expires = jiffies + (HZ * 60); 723 add_timer(&battery_timer); 724} 725 726static void del_battery_timer(void) 727{ 728 del_timer(&battery_timer); 729} 730 731/* 732 * Note no locks taken out here. In a worst case scenario, we could drop 733 * a chunk of system memory. But that should never happen, since validation 734 * happens at open or mount time, when locks are held. 735 * 736 * That's crap, since doing that while some partitions are opened 737 * or mounted will give you really nasty results. 738 */ 739static int mm_revalidate(struct gendisk *disk) 740{ 741 struct cardinfo *card = disk->private_data; 742 set_capacity(disk, card->mm_size << 1); 743 return 0; 744} 745 746static int mm_getgeo(struct block_device *bdev, struct hd_geometry *geo) 747{ 748 struct cardinfo *card = bdev->bd_disk->private_data; 749 int size = card->mm_size * (1024 / MM_HARDSECT); 750 751 /* 752 * get geometry: we have to fake one... trim the size to a 753 * multiple of 2048 (1M): tell we have 32 sectors, 64 heads, 754 * whatever cylinders. 755 */ 756 geo->heads = 64; 757 geo->sectors = 32; 758 geo->cylinders = size / (geo->heads * geo->sectors); 759 return 0; 760} 761 762/* 763 * Future support for removable devices 764 */ 765static int mm_check_change(struct gendisk *disk) 766{ 767/* struct cardinfo *dev = disk->private_data; */ 768 return 0; 769} 770 771static const struct block_device_operations mm_fops = { 772 .owner = THIS_MODULE, 773 .getgeo = mm_getgeo, 774 .revalidate_disk = mm_revalidate, 775 .media_changed = mm_check_change, 776}; 777 778static int __devinit mm_pci_probe(struct pci_dev *dev, 779 const struct pci_device_id *id) 780{ 781 int ret = -ENODEV; 782 struct cardinfo *card = &cards[num_cards]; 783 unsigned char mem_present; 784 unsigned char batt_status; 785 unsigned int saved_bar, data; 786 unsigned long csr_base; 787 unsigned long csr_len; 788 int magic_number; 789 static int printed_version; 790 791 if (!printed_version++) 792 printk(KERN_INFO DRIVER_VERSION " : " DRIVER_DESC "\n"); 793 794 ret = pci_enable_device(dev); 795 if (ret) 796 return ret; 797 798 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xF8); 799 pci_set_master(dev); 800 801 card->dev = dev; 802 803 csr_base = pci_resource_start(dev, 0); 804 csr_len = pci_resource_len(dev, 0); 805 if (!csr_base || !csr_len) 806 return -ENODEV; 807 808 dev_printk(KERN_INFO, &dev->dev, 809 "Micro Memory(tm) controller found (PCI Mem Module (Battery Backup))\n"); 810 811 if (pci_set_dma_mask(dev, DMA_BIT_MASK(64)) && 812 pci_set_dma_mask(dev, DMA_BIT_MASK(32))) { 813 dev_printk(KERN_WARNING, &dev->dev, "NO suitable DMA found\n"); 814 return -ENOMEM; 815 } 816 817 ret = pci_request_regions(dev, DRIVER_NAME); 818 if (ret) { 819 dev_printk(KERN_ERR, &card->dev->dev, 820 "Unable to request memory region\n"); 821 goto failed_req_csr; 822 } 823 824 card->csr_remap = ioremap_nocache(csr_base, csr_len); 825 if (!card->csr_remap) { 826 dev_printk(KERN_ERR, &card->dev->dev, 827 "Unable to remap memory region\n"); 828 ret = -ENOMEM; 829 830 goto failed_remap_csr; 831 } 832 833 dev_printk(KERN_INFO, &card->dev->dev, 834 "CSR 0x%08lx -> 0x%p (0x%lx)\n", 835 csr_base, card->csr_remap, csr_len); 836 837 switch (card->dev->device) { 838 case 0x5415: 839 card->flags |= UM_FLAG_NO_BYTE_STATUS | UM_FLAG_NO_BATTREG; 840 magic_number = 0x59; 841 break; 842 843 case 0x5425: 844 card->flags |= UM_FLAG_NO_BYTE_STATUS; 845 magic_number = 0x5C; 846 break; 847 848 case 0x6155: 849 card->flags |= UM_FLAG_NO_BYTE_STATUS | 850 UM_FLAG_NO_BATTREG | UM_FLAG_NO_BATT; 851 magic_number = 0x99; 852 break; 853 854 default: 855 magic_number = 0x100; 856 break; 857 } 858 859 if (readb(card->csr_remap + MEMCTRLSTATUS_MAGIC) != magic_number) { 860 dev_printk(KERN_ERR, &card->dev->dev, "Magic number invalid\n"); 861 ret = -ENOMEM; 862 goto failed_magic; 863 } 864 865 card->mm_pages[0].desc = pci_alloc_consistent(card->dev, 866 PAGE_SIZE * 2, 867 &card->mm_pages[0].page_dma); 868 card->mm_pages[1].desc = pci_alloc_consistent(card->dev, 869 PAGE_SIZE * 2, 870 &card->mm_pages[1].page_dma); 871 if (card->mm_pages[0].desc == NULL || 872 card->mm_pages[1].desc == NULL) { 873 dev_printk(KERN_ERR, &card->dev->dev, "alloc failed\n"); 874 goto failed_alloc; 875 } 876 reset_page(&card->mm_pages[0]); 877 reset_page(&card->mm_pages[1]); 878 card->Ready = 0; /* page 0 is ready */ 879 card->Active = -1; /* no page is active */ 880 card->bio = NULL; 881 card->biotail = &card->bio; 882 883 card->queue = blk_alloc_queue(GFP_KERNEL); 884 if (!card->queue) 885 goto failed_alloc; 886 887 blk_queue_make_request(card->queue, mm_make_request); 888 card->queue->queue_lock = &card->lock; 889 card->queue->queuedata = card; 890 card->queue->unplug_fn = mm_unplug_device; 891 892 tasklet_init(&card->tasklet, process_page, (unsigned long)card); 893 894 card->check_batteries = 0; 895 896 mem_present = readb(card->csr_remap + MEMCTRLSTATUS_MEMORY); 897 switch (mem_present) { 898 case MEM_128_MB: 899 card->mm_size = 1024 * 128; 900 break; 901 case MEM_256_MB: 902 card->mm_size = 1024 * 256; 903 break; 904 case MEM_512_MB: 905 card->mm_size = 1024 * 512; 906 break; 907 case MEM_1_GB: 908 card->mm_size = 1024 * 1024; 909 break; 910 case MEM_2_GB: 911 card->mm_size = 1024 * 2048; 912 break; 913 default: 914 card->mm_size = 0; 915 break; 916 } 917 918 /* Clear the LED's we control */ 919 set_led(card, LED_REMOVE, LED_OFF); 920 set_led(card, LED_FAULT, LED_OFF); 921 922 batt_status = readb(card->csr_remap + MEMCTRLSTATUS_BATTERY); 923 924 card->battery[0].good = !(batt_status & BATTERY_1_FAILURE); 925 card->battery[1].good = !(batt_status & BATTERY_2_FAILURE); 926 card->battery[0].last_change = card->battery[1].last_change = jiffies; 927 928 if (card->flags & UM_FLAG_NO_BATT) 929 dev_printk(KERN_INFO, &card->dev->dev, 930 "Size %d KB\n", card->mm_size); 931 else { 932 dev_printk(KERN_INFO, &card->dev->dev, 933 "Size %d KB, Battery 1 %s (%s), Battery 2 %s (%s)\n", 934 card->mm_size, 935 batt_status & BATTERY_1_DISABLED ? "Disabled" : "Enabled", 936 card->battery[0].good ? "OK" : "FAILURE", 937 batt_status & BATTERY_2_DISABLED ? "Disabled" : "Enabled", 938 card->battery[1].good ? "OK" : "FAILURE"); 939 940 set_fault_to_battery_status(card); 941 } 942 943 pci_read_config_dword(dev, PCI_BASE_ADDRESS_1, &saved_bar); 944 data = 0xffffffff; 945 pci_write_config_dword(dev, PCI_BASE_ADDRESS_1, data); 946 pci_read_config_dword(dev, PCI_BASE_ADDRESS_1, &data); 947 pci_write_config_dword(dev, PCI_BASE_ADDRESS_1, saved_bar); 948 data &= 0xfffffff0; 949 data = ~data; 950 data += 1; 951 952 if (request_irq(dev->irq, mm_interrupt, IRQF_SHARED, DRIVER_NAME, 953 card)) { 954 dev_printk(KERN_ERR, &card->dev->dev, 955 "Unable to allocate IRQ\n"); 956 ret = -ENODEV; 957 goto failed_req_irq; 958 } 959 960 dev_printk(KERN_INFO, &card->dev->dev, 961 "Window size %d bytes, IRQ %d\n", data, dev->irq); 962 963 spin_lock_init(&card->lock); 964 965 pci_set_drvdata(dev, card); 966 967 if (pci_write_cmd != 0x0F) /* If not Memory Write & Invalidate */ 968 pci_write_cmd = 0x07; /* then Memory Write command */ 969 970 if (pci_write_cmd & 0x08) { /* use Memory Write and Invalidate */ 971 unsigned short cfg_command; 972 pci_read_config_word(dev, PCI_COMMAND, &cfg_command); 973 cfg_command |= 0x10; /* Memory Write & Invalidate Enable */ 974 pci_write_config_word(dev, PCI_COMMAND, cfg_command); 975 } 976 pci_cmds = (pci_read_cmd << 28) | (pci_write_cmd << 24); 977 978 num_cards++; 979 980 if (!get_userbit(card, MEMORY_INITIALIZED)) { 981 dev_printk(KERN_INFO, &card->dev->dev, 982 "memory NOT initialized. Consider over-writing whole device.\n"); 983 card->init_size = 0; 984 } else { 985 dev_printk(KERN_INFO, &card->dev->dev, 986 "memory already initialized\n"); 987 card->init_size = card->mm_size; 988 } 989 990 /* Enable ECC */ 991 writeb(EDC_STORE_CORRECT, card->csr_remap + MEMCTRLCMD_ERRCTRL); 992 993 return 0; 994 995 failed_req_irq: 996 failed_alloc: 997 if (card->mm_pages[0].desc) 998 pci_free_consistent(card->dev, PAGE_SIZE*2, 999 card->mm_pages[0].desc, 1000 card->mm_pages[0].page_dma); 1001 if (card->mm_pages[1].desc) 1002 pci_free_consistent(card->dev, PAGE_SIZE*2, 1003 card->mm_pages[1].desc, 1004 card->mm_pages[1].page_dma); 1005 failed_magic: 1006 iounmap(card->csr_remap); 1007 failed_remap_csr: 1008 pci_release_regions(dev); 1009 failed_req_csr: 1010 1011 return ret; 1012} 1013 1014static void mm_pci_remove(struct pci_dev *dev) 1015{ 1016 struct cardinfo *card = pci_get_drvdata(dev); 1017 1018 tasklet_kill(&card->tasklet); 1019 free_irq(dev->irq, card); 1020 iounmap(card->csr_remap); 1021 1022 if (card->mm_pages[0].desc) 1023 pci_free_consistent(card->dev, PAGE_SIZE*2, 1024 card->mm_pages[0].desc, 1025 card->mm_pages[0].page_dma); 1026 if (card->mm_pages[1].desc) 1027 pci_free_consistent(card->dev, PAGE_SIZE*2, 1028 card->mm_pages[1].desc, 1029 card->mm_pages[1].page_dma); 1030 blk_cleanup_queue(card->queue); 1031 1032 pci_release_regions(dev); 1033 pci_disable_device(dev); 1034} 1035 1036static const struct pci_device_id mm_pci_ids[] = { 1037 {PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY, PCI_DEVICE_ID_MICRO_MEMORY_5415CN)}, 1038 {PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY, PCI_DEVICE_ID_MICRO_MEMORY_5425CN)}, 1039 {PCI_DEVICE(PCI_VENDOR_ID_MICRO_MEMORY, PCI_DEVICE_ID_MICRO_MEMORY_6155)}, 1040 { 1041 .vendor = 0x8086, 1042 .device = 0xB555, 1043 .subvendor = 0x1332, 1044 .subdevice = 0x5460, 1045 .class = 0x050000, 1046 .class_mask = 0, 1047 }, { /* end: all zeroes */ } 1048}; 1049 1050MODULE_DEVICE_TABLE(pci, mm_pci_ids); 1051 1052static struct pci_driver mm_pci_driver = { 1053 .name = DRIVER_NAME, 1054 .id_table = mm_pci_ids, 1055 .probe = mm_pci_probe, 1056 .remove = mm_pci_remove, 1057}; 1058 1059static int __init mm_init(void) 1060{ 1061 int retval, i; 1062 int err; 1063 1064 retval = pci_register_driver(&mm_pci_driver); 1065 if (retval) 1066 return -ENOMEM; 1067 1068 err = major_nr = register_blkdev(0, DRIVER_NAME); 1069 if (err < 0) { 1070 pci_unregister_driver(&mm_pci_driver); 1071 return -EIO; 1072 } 1073 1074 for (i = 0; i < num_cards; i++) { 1075 mm_gendisk[i] = alloc_disk(1 << MM_SHIFT); 1076 if (!mm_gendisk[i]) 1077 goto out; 1078 } 1079 1080 for (i = 0; i < num_cards; i++) { 1081 struct gendisk *disk = mm_gendisk[i]; 1082 sprintf(disk->disk_name, "umem%c", 'a'+i); 1083 spin_lock_init(&cards[i].lock); 1084 disk->major = major_nr; 1085 disk->first_minor = i << MM_SHIFT; 1086 disk->fops = &mm_fops; 1087 disk->private_data = &cards[i]; 1088 disk->queue = cards[i].queue; 1089 set_capacity(disk, cards[i].mm_size << 1); 1090 add_disk(disk); 1091 } 1092 1093 init_battery_timer(); 1094 printk(KERN_INFO "MM: desc_per_page = %ld\n", DESC_PER_PAGE); 1095/* printk("mm_init: Done. 10-19-01 9:00\n"); */ 1096 return 0; 1097 1098out: 1099 pci_unregister_driver(&mm_pci_driver); 1100 unregister_blkdev(major_nr, DRIVER_NAME); 1101 while (i--) 1102 put_disk(mm_gendisk[i]); 1103 return -ENOMEM; 1104} 1105 1106static void __exit mm_cleanup(void) 1107{ 1108 int i; 1109 1110 del_battery_timer(); 1111 1112 for (i = 0; i < num_cards ; i++) { 1113 del_gendisk(mm_gendisk[i]); 1114 put_disk(mm_gendisk[i]); 1115 } 1116 1117 pci_unregister_driver(&mm_pci_driver); 1118 1119 unregister_blkdev(major_nr, DRIVER_NAME); 1120} 1121 1122module_init(mm_init); 1123module_exit(mm_cleanup); 1124 1125MODULE_AUTHOR(DRIVER_AUTHOR); 1126MODULE_DESCRIPTION(DRIVER_DESC); 1127MODULE_LICENSE("GPL"); 1128