1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83#include <linux/kernel.h>
84#include <linux/module.h>
85#include <asm/uaccess.h>
86#include <linux/types.h>
87#include <linux/init.h>
88#include <linux/ptrace.h>
89#include <linux/slab.h>
90#include <linux/string.h>
91#include <linux/timer.h>
92#include <linux/major.h>
93#include <linux/fs.h>
94#include <linux/ioctl.h>
95#include <asm/io.h>
96#include <asm/system.h>
97#include <linux/pci.h>
98
99#include <linux/mtd/mtd.h>
100#include <linux/mtd/pmc551.h>
101#include <linux/mtd/compatmac.h>
102
103static struct mtd_info *pmc551list;
104
105static int pmc551_erase(struct mtd_info *mtd, struct erase_info *instr)
106{
107 struct mypriv *priv = mtd->priv;
108 u32 soff_hi, soff_lo;
109 u32 eoff_hi, eoff_lo;
110 unsigned long end;
111 u_char *ptr;
112 size_t retlen;
113
114#ifdef CONFIG_MTD_PMC551_DEBUG
115 printk(KERN_DEBUG "pmc551_erase(pos:%ld, len:%ld)\n", (long)instr->addr,
116 (long)instr->len);
117#endif
118
119 end = instr->addr + instr->len - 1;
120
121
122 if (end > mtd->size) {
123#ifdef CONFIG_MTD_PMC551_DEBUG
124 printk(KERN_DEBUG "pmc551_erase() out of bounds (%ld > %ld)\n",
125 (long)end, (long)mtd->size);
126#endif
127 return -EINVAL;
128 }
129
130 eoff_hi = end & ~(priv->asize - 1);
131 soff_hi = instr->addr & ~(priv->asize - 1);
132 eoff_lo = end & (priv->asize - 1);
133 soff_lo = instr->addr & (priv->asize - 1);
134
135 pmc551_point(mtd, instr->addr, instr->len, &retlen,
136 (void **)&ptr, NULL);
137
138 if (soff_hi == eoff_hi || mtd->size == priv->asize) {
139
140
141 memset(ptr, 0xff, instr->len);
142 } else {
143
144
145 while (soff_hi != eoff_hi) {
146#ifdef CONFIG_MTD_PMC551_DEBUG
147 printk(KERN_DEBUG "pmc551_erase() soff_hi: %ld, "
148 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi);
149#endif
150 memset(ptr, 0xff, priv->asize);
151 if (soff_hi + priv->asize >= mtd->size) {
152 goto out;
153 }
154 soff_hi += priv->asize;
155 pmc551_point(mtd, (priv->base_map0 | soff_hi),
156 priv->asize, &retlen,
157 (void **)&ptr, NULL);
158 }
159 memset(ptr, 0xff, eoff_lo);
160 }
161
162 out:
163 instr->state = MTD_ERASE_DONE;
164#ifdef CONFIG_MTD_PMC551_DEBUG
165 printk(KERN_DEBUG "pmc551_erase() done\n");
166#endif
167
168 mtd_erase_callback(instr);
169 return 0;
170}
171
172static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len,
173 size_t *retlen, void **virt, resource_size_t *phys)
174{
175 struct mypriv *priv = mtd->priv;
176 u32 soff_hi;
177 u32 soff_lo;
178
179#ifdef CONFIG_MTD_PMC551_DEBUG
180 printk(KERN_DEBUG "pmc551_point(%ld, %ld)\n", (long)from, (long)len);
181#endif
182
183 if (from + len > mtd->size) {
184#ifdef CONFIG_MTD_PMC551_DEBUG
185 printk(KERN_DEBUG "pmc551_point() out of bounds (%ld > %ld)\n",
186 (long)from + len, (long)mtd->size);
187#endif
188 return -EINVAL;
189 }
190
191
192 if (phys)
193 return -EINVAL;
194
195 soff_hi = from & ~(priv->asize - 1);
196 soff_lo = from & (priv->asize - 1);
197
198
199 if (priv->curr_map0 != from) {
200 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0,
201 (priv->base_map0 | soff_hi));
202 priv->curr_map0 = soff_hi;
203 }
204
205 *virt = priv->start + soff_lo;
206 *retlen = len;
207 return 0;
208}
209
210static void pmc551_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
211{
212#ifdef CONFIG_MTD_PMC551_DEBUG
213 printk(KERN_DEBUG "pmc551_unpoint()\n");
214#endif
215}
216
217static int pmc551_read(struct mtd_info *mtd, loff_t from, size_t len,
218 size_t * retlen, u_char * buf)
219{
220 struct mypriv *priv = mtd->priv;
221 u32 soff_hi, soff_lo;
222 u32 eoff_hi, eoff_lo;
223 unsigned long end;
224 u_char *ptr;
225 u_char *copyto = buf;
226
227#ifdef CONFIG_MTD_PMC551_DEBUG
228 printk(KERN_DEBUG "pmc551_read(pos:%ld, len:%ld) asize: %ld\n",
229 (long)from, (long)len, (long)priv->asize);
230#endif
231
232 end = from + len - 1;
233
234
235 if (end > mtd->size) {
236#ifdef CONFIG_MTD_PMC551_DEBUG
237 printk(KERN_DEBUG "pmc551_read() out of bounds (%ld > %ld)\n",
238 (long)end, (long)mtd->size);
239#endif
240 return -EINVAL;
241 }
242
243 soff_hi = from & ~(priv->asize - 1);
244 eoff_hi = end & ~(priv->asize - 1);
245 soff_lo = from & (priv->asize - 1);
246 eoff_lo = end & (priv->asize - 1);
247
248 pmc551_point(mtd, from, len, retlen, (void **)&ptr, NULL);
249
250 if (soff_hi == eoff_hi) {
251
252
253 memcpy(copyto, ptr, len);
254 copyto += len;
255 } else {
256
257
258 while (soff_hi != eoff_hi) {
259#ifdef CONFIG_MTD_PMC551_DEBUG
260 printk(KERN_DEBUG "pmc551_read() soff_hi: %ld, "
261 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi);
262#endif
263 memcpy(copyto, ptr, priv->asize);
264 copyto += priv->asize;
265 if (soff_hi + priv->asize >= mtd->size) {
266 goto out;
267 }
268 soff_hi += priv->asize;
269 pmc551_point(mtd, soff_hi, priv->asize, retlen,
270 (void **)&ptr, NULL);
271 }
272 memcpy(copyto, ptr, eoff_lo);
273 copyto += eoff_lo;
274 }
275
276 out:
277#ifdef CONFIG_MTD_PMC551_DEBUG
278 printk(KERN_DEBUG "pmc551_read() done\n");
279#endif
280 *retlen = copyto - buf;
281 return 0;
282}
283
284static int pmc551_write(struct mtd_info *mtd, loff_t to, size_t len,
285 size_t * retlen, const u_char * buf)
286{
287 struct mypriv *priv = mtd->priv;
288 u32 soff_hi, soff_lo;
289 u32 eoff_hi, eoff_lo;
290 unsigned long end;
291 u_char *ptr;
292 const u_char *copyfrom = buf;
293
294#ifdef CONFIG_MTD_PMC551_DEBUG
295 printk(KERN_DEBUG "pmc551_write(pos:%ld, len:%ld) asize:%ld\n",
296 (long)to, (long)len, (long)priv->asize);
297#endif
298
299 end = to + len - 1;
300
301 if (end > mtd->size) {
302#ifdef CONFIG_MTD_PMC551_DEBUG
303 printk(KERN_DEBUG "pmc551_write() out of bounds (end: %ld, "
304 "size: %ld, to: %ld)\n", (long)end, (long)mtd->size,
305 (long)to);
306#endif
307 return -EINVAL;
308 }
309
310 soff_hi = to & ~(priv->asize - 1);
311 eoff_hi = end & ~(priv->asize - 1);
312 soff_lo = to & (priv->asize - 1);
313 eoff_lo = end & (priv->asize - 1);
314
315 pmc551_point(mtd, to, len, retlen, (void **)&ptr, NULL);
316
317 if (soff_hi == eoff_hi) {
318
319
320 memcpy(ptr, copyfrom, len);
321 copyfrom += len;
322 } else {
323
324
325 while (soff_hi != eoff_hi) {
326#ifdef CONFIG_MTD_PMC551_DEBUG
327 printk(KERN_DEBUG "pmc551_write() soff_hi: %ld, "
328 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi);
329#endif
330 memcpy(ptr, copyfrom, priv->asize);
331 copyfrom += priv->asize;
332 if (soff_hi >= mtd->size) {
333 goto out;
334 }
335 soff_hi += priv->asize;
336 pmc551_point(mtd, soff_hi, priv->asize, retlen,
337 (void **)&ptr, NULL);
338 }
339 memcpy(ptr, copyfrom, eoff_lo);
340 copyfrom += eoff_lo;
341 }
342
343 out:
344#ifdef CONFIG_MTD_PMC551_DEBUG
345 printk(KERN_DEBUG "pmc551_write() done\n");
346#endif
347 *retlen = copyfrom - buf;
348 return 0;
349}
350
351
352
353
354
355
356
357
358
359
360
361
362
363static u32 fixup_pmc551(struct pci_dev *dev)
364{
365#ifdef CONFIG_MTD_PMC551_BUGFIX
366 u32 dram_data;
367#endif
368 u32 size, dcmd, cfg, dtmp;
369 u16 cmd, tmp, i;
370 u8 bcmd, counter;
371
372
373 if (!dev) {
374 return -ENODEV;
375 }
376
377
378
379
380
381 counter = 0;
382
383 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, 0xA5);
384
385 pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd);
386
387 for (i = 0; i < 10; i++) {
388 counter = 0;
389 bcmd &= ~0x80;
390 while (counter++ < 100) {
391 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
392 }
393 counter = 0;
394 bcmd |= 0x80;
395 while (counter++ < 100) {
396 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
397 }
398 }
399 bcmd |= (0x40 | 0x20);
400 pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
401
402
403
404
405
406 pci_read_config_word(dev, PCI_COMMAND, &cmd);
407 tmp = cmd & ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
408 pci_write_config_word(dev, PCI_COMMAND, tmp);
409
410
411
412
413 pci_read_config_dword(dev, PMC551_PCI_MEM_MAP0, &dcmd);
414 dtmp = (dcmd | PMC551_PCI_MEM_MAP_ENABLE | PMC551_PCI_MEM_MAP_REG_EN);
415 pci_write_config_dword(dev, PMC551_PCI_MEM_MAP0, dtmp);
416
417
418
419
420
421
422
423
424
425 pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &cfg);
426#ifndef CONFIG_MTD_PMC551_BUGFIX
427 pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, ~0);
428 pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &size);
429 size = (size & PCI_BASE_ADDRESS_MEM_MASK);
430 size &= ~(size - 1);
431 pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, cfg);
432#else
433
434
435
436
437
438
439
440
441 pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dram_data);
442 size = PMC551_DRAM_BLK_GET_SIZE(dram_data);
443 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
444 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
445 pci_write_config_dword(dev, PMC551_DRAM_BLK0, dram_data);
446
447 pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dram_data);
448 size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
449 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
450 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
451 pci_write_config_dword(dev, PMC551_DRAM_BLK1, dram_data);
452
453 pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dram_data);
454 size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
455 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
456 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
457 pci_write_config_dword(dev, PMC551_DRAM_BLK2, dram_data);
458
459 pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dram_data);
460 size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
461 dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
462 dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
463 pci_write_config_dword(dev, PMC551_DRAM_BLK3, dram_data);
464
465
466
467
468 if ((size &= PCI_BASE_ADDRESS_MEM_MASK) == 0) {
469 return -ENODEV;
470 }
471#endif
472
473 if ((cfg & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) {
474 return -ENODEV;
475 }
476
477
478
479
480 pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0400);
481 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x00bf);
482
483
484
485
486
487 do {
488 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
489 if (counter++ > 100)
490 break;
491 } while ((PCI_COMMAND_IO) & cmd);
492
493
494
495
496
497
498
499 for (i = 1; i <= 8; i++) {
500 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0df);
501
502
503
504
505
506 counter = 0;
507 do {
508 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
509 if (counter++ > 100)
510 break;
511 } while ((PCI_COMMAND_IO) & cmd);
512 }
513
514 pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0020);
515 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0ff);
516
517
518
519
520
521 counter = 0;
522 do {
523 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
524 if (counter++ > 100)
525 break;
526 } while ((PCI_COMMAND_IO) & cmd);
527
528 pci_read_config_dword(dev, PMC551_DRAM_CFG, &dcmd);
529 dcmd |= 0x02000000;
530 pci_write_config_dword(dev, PMC551_DRAM_CFG, dcmd);
531
532
533
534
535
536 pci_read_config_word(dev, PCI_STATUS, &cmd);
537 if ((cmd & PCI_COMMAND_FAST_BACK) == 0) {
538 cmd |= PCI_COMMAND_FAST_BACK;
539 pci_write_config_word(dev, PCI_STATUS, cmd);
540 }
541
542
543
544
545
546
547 if ((cmd & PCI_STATUS_DEVSEL_MASK) != 0x0) {
548 cmd &= ~PCI_STATUS_DEVSEL_MASK;
549 pci_write_config_word(dev, PCI_STATUS, cmd);
550 }
551
552
553
554
555
556
557
558
559
560
561
562
563
564 pci_write_config_word(dev, PCI_COMMAND,
565 PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
566#ifdef CONFIG_MTD_PMC551_DEBUG
567
568
569
570 printk(KERN_DEBUG "pmc551: %d%sB (0x%x) of %sprefetchable memory at "
571 "0x%llx\n", (size < 1024) ? size : (size < 1048576) ?
572 size >> 10 : size >> 20,
573 (size < 1024) ? "" : (size < 1048576) ? "Ki" : "Mi", size,
574 ((dcmd & (0x1 << 3)) == 0) ? "non-" : "",
575 (unsigned long long)pci_resource_start(dev, 0));
576
577
578
579
580 pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dcmd);
581 printk(KERN_DEBUG "pmc551: DRAM_BLK0 Flags: %s,%s\n"
582 "pmc551: DRAM_BLK0 Size: %d at %d\n"
583 "pmc551: DRAM_BLK0 Row MUX: %d, Col MUX: %d\n",
584 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
585 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
586 PMC551_DRAM_BLK_GET_SIZE(dcmd),
587 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
588 ((dcmd >> 9) & 0xF));
589
590 pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dcmd);
591 printk(KERN_DEBUG "pmc551: DRAM_BLK1 Flags: %s,%s\n"
592 "pmc551: DRAM_BLK1 Size: %d at %d\n"
593 "pmc551: DRAM_BLK1 Row MUX: %d, Col MUX: %d\n",
594 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
595 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
596 PMC551_DRAM_BLK_GET_SIZE(dcmd),
597 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
598 ((dcmd >> 9) & 0xF));
599
600 pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dcmd);
601 printk(KERN_DEBUG "pmc551: DRAM_BLK2 Flags: %s,%s\n"
602 "pmc551: DRAM_BLK2 Size: %d at %d\n"
603 "pmc551: DRAM_BLK2 Row MUX: %d, Col MUX: %d\n",
604 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
605 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
606 PMC551_DRAM_BLK_GET_SIZE(dcmd),
607 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
608 ((dcmd >> 9) & 0xF));
609
610 pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dcmd);
611 printk(KERN_DEBUG "pmc551: DRAM_BLK3 Flags: %s,%s\n"
612 "pmc551: DRAM_BLK3 Size: %d at %d\n"
613 "pmc551: DRAM_BLK3 Row MUX: %d, Col MUX: %d\n",
614 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
615 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
616 PMC551_DRAM_BLK_GET_SIZE(dcmd),
617 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
618 ((dcmd >> 9) & 0xF));
619
620 pci_read_config_word(dev, PCI_COMMAND, &cmd);
621 printk(KERN_DEBUG "pmc551: Memory Access %s\n",
622 (((0x1 << 1) & cmd) == 0) ? "off" : "on");
623 printk(KERN_DEBUG "pmc551: I/O Access %s\n",
624 (((0x1 << 0) & cmd) == 0) ? "off" : "on");
625
626 pci_read_config_word(dev, PCI_STATUS, &cmd);
627 printk(KERN_DEBUG "pmc551: Devsel %s\n",
628 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x000) ? "Fast" :
629 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x200) ? "Medium" :
630 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x400) ? "Slow" : "Invalid");
631
632 printk(KERN_DEBUG "pmc551: %sFast Back-to-Back\n",
633 ((PCI_COMMAND_FAST_BACK & cmd) == 0) ? "Not " : "");
634
635 pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd);
636 printk(KERN_DEBUG "pmc551: EEPROM is under %s control\n"
637 "pmc551: System Control Register is %slocked to PCI access\n"
638 "pmc551: System Control Register is %slocked to EEPROM access\n",
639 (bcmd & 0x1) ? "software" : "hardware",
640 (bcmd & 0x20) ? "" : "un", (bcmd & 0x40) ? "" : "un");
641#endif
642 return size;
643}
644
645
646
647
648
649MODULE_LICENSE("GPL");
650MODULE_AUTHOR("Mark Ferrell <mferrell@mvista.com>");
651MODULE_DESCRIPTION(PMC551_VERSION);
652
653
654
655
656static int msize = 0;
657static int asize = 0;
658
659module_param(msize, int, 0);
660MODULE_PARM_DESC(msize, "memory size in MiB [1 - 1024]");
661module_param(asize, int, 0);
662MODULE_PARM_DESC(asize, "aperture size, must be <= memsize [1-1024]");
663
664
665
666
667static int __init init_pmc551(void)
668{
669 struct pci_dev *PCI_Device = NULL;
670 struct mypriv *priv;
671 int count, found = 0;
672 struct mtd_info *mtd;
673 u32 length = 0;
674
675 if (msize) {
676 msize = (1 << (ffs(msize) - 1)) << 20;
677 if (msize > (1 << 30)) {
678 printk(KERN_NOTICE "pmc551: Invalid memory size [%d]\n",
679 msize);
680 return -EINVAL;
681 }
682 }
683
684 if (asize) {
685 asize = (1 << (ffs(asize) - 1)) << 20;
686 if (asize > (1 << 30)) {
687 printk(KERN_NOTICE "pmc551: Invalid aperture size "
688 "[%d]\n", asize);
689 return -EINVAL;
690 }
691 }
692
693 printk(KERN_INFO PMC551_VERSION);
694
695
696
697
698 for (count = 0; count < MAX_MTD_DEVICES; count++) {
699
700 if ((PCI_Device = pci_get_device(PCI_VENDOR_ID_V3_SEMI,
701 PCI_DEVICE_ID_V3_SEMI_V370PDC,
702 PCI_Device)) == NULL) {
703 break;
704 }
705
706 printk(KERN_NOTICE "pmc551: Found PCI V370PDC at 0x%llx\n",
707 (unsigned long long)pci_resource_start(PCI_Device, 0));
708
709
710
711
712
713
714
715
716
717 if ((length = fixup_pmc551(PCI_Device)) <= 0) {
718 printk(KERN_NOTICE "pmc551: Cannot init SDRAM\n");
719 break;
720 }
721
722
723
724
725
726 if (msize) {
727 length = msize;
728 printk(KERN_NOTICE "pmc551: Using specified memory "
729 "size 0x%x\n", length);
730 } else {
731 msize = length;
732 }
733
734 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
735 if (!mtd) {
736 printk(KERN_NOTICE "pmc551: Cannot allocate new MTD "
737 "device.\n");
738 break;
739 }
740
741 priv = kzalloc(sizeof(struct mypriv), GFP_KERNEL);
742 if (!priv) {
743 printk(KERN_NOTICE "pmc551: Cannot allocate new MTD "
744 "device.\n");
745 kfree(mtd);
746 break;
747 }
748 mtd->priv = priv;
749 priv->dev = PCI_Device;
750
751 if (asize > length) {
752 printk(KERN_NOTICE "pmc551: reducing aperture size to "
753 "fit %dM\n", length >> 20);
754 priv->asize = asize = length;
755 } else if (asize == 0 || asize == length) {
756 printk(KERN_NOTICE "pmc551: Using existing aperture "
757 "size %dM\n", length >> 20);
758 priv->asize = asize = length;
759 } else {
760 printk(KERN_NOTICE "pmc551: Using specified aperture "
761 "size %dM\n", asize >> 20);
762 priv->asize = asize;
763 }
764 priv->start = pci_iomap(PCI_Device, 0, priv->asize);
765
766 if (!priv->start) {
767 printk(KERN_NOTICE "pmc551: Unable to map IO space\n");
768 kfree(mtd->priv);
769 kfree(mtd);
770 break;
771 }
772#ifdef CONFIG_MTD_PMC551_DEBUG
773 printk(KERN_DEBUG "pmc551: setting aperture to %d\n",
774 ffs(priv->asize >> 20) - 1);
775#endif
776
777 priv->base_map0 = (PMC551_PCI_MEM_MAP_REG_EN
778 | PMC551_PCI_MEM_MAP_ENABLE
779 | (ffs(priv->asize >> 20) - 1) << 4);
780 priv->curr_map0 = priv->base_map0;
781 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0,
782 priv->curr_map0);
783
784#ifdef CONFIG_MTD_PMC551_DEBUG
785 printk(KERN_DEBUG "pmc551: aperture set to %d\n",
786 (priv->base_map0 & 0xF0) >> 4);
787#endif
788
789 mtd->size = msize;
790 mtd->flags = MTD_CAP_RAM;
791 mtd->erase = pmc551_erase;
792 mtd->read = pmc551_read;
793 mtd->write = pmc551_write;
794 mtd->point = pmc551_point;
795 mtd->unpoint = pmc551_unpoint;
796 mtd->type = MTD_RAM;
797 mtd->name = "PMC551 RAM board";
798 mtd->erasesize = 0x10000;
799 mtd->writesize = 1;
800 mtd->owner = THIS_MODULE;
801
802 if (add_mtd_device(mtd)) {
803 printk(KERN_NOTICE "pmc551: Failed to register new device\n");
804 pci_iounmap(PCI_Device, priv->start);
805 kfree(mtd->priv);
806 kfree(mtd);
807 break;
808 }
809
810
811 pci_dev_get(PCI_Device);
812
813 printk(KERN_NOTICE "Registered pmc551 memory device.\n");
814 printk(KERN_NOTICE "Mapped %dMiB of memory from 0x%p to 0x%p\n",
815 priv->asize >> 20,
816 priv->start, priv->start + priv->asize);
817 printk(KERN_NOTICE "Total memory is %d%sB\n",
818 (length < 1024) ? length :
819 (length < 1048576) ? length >> 10 : length >> 20,
820 (length < 1024) ? "" : (length < 1048576) ? "Ki" : "Mi");
821 priv->nextpmc551 = pmc551list;
822 pmc551list = mtd;
823 found++;
824 }
825
826
827 if (PCI_Device)
828 pci_dev_put(PCI_Device);
829
830 if (!pmc551list) {
831 printk(KERN_NOTICE "pmc551: not detected\n");
832 return -ENODEV;
833 } else {
834 printk(KERN_NOTICE "pmc551: %d pmc551 devices loaded\n", found);
835 return 0;
836 }
837}
838
839
840
841
842static void __exit cleanup_pmc551(void)
843{
844 int found = 0;
845 struct mtd_info *mtd;
846 struct mypriv *priv;
847
848 while ((mtd = pmc551list)) {
849 priv = mtd->priv;
850 pmc551list = priv->nextpmc551;
851
852 if (priv->start) {
853 printk(KERN_DEBUG "pmc551: unmapping %dMiB starting at "
854 "0x%p\n", priv->asize >> 20, priv->start);
855 pci_iounmap(priv->dev, priv->start);
856 }
857 pci_dev_put(priv->dev);
858
859 kfree(mtd->priv);
860 del_mtd_device(mtd);
861 kfree(mtd);
862 found++;
863 }
864
865 printk(KERN_NOTICE "pmc551: %d pmc551 devices unloaded\n", found);
866}
867
868module_init(init_pmc551);
869module_exit(cleanup_pmc551);
870