umem.c 36 KB

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