Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux...
[linux-2.6] / drivers / mtd / devices / pmc551.c
1 /*
2  * $Id: pmc551.c,v 1.32 2005/11/07 11:14:25 gleixner Exp $
3  *
4  * PMC551 PCI Mezzanine Ram Device
5  *
6  * Author:
7  *      Mark Ferrell <mferrell@mvista.com>
8  *      Copyright 1999,2000 Nortel Networks
9  *
10  * License:
11  *      As part of this driver was derived from the slram.c driver it
12  *      falls under the same license, which is GNU General Public
13  *      License v2
14  *
15  * Description:
16  *      This driver is intended to support the PMC551 PCI Ram device
17  *      from Ramix Inc.  The PMC551 is a PMC Mezzanine module for
18  *      cPCI embedded systems.  The device contains a single SROM
19  *      that initially programs the V370PDC chipset onboard the
20  *      device, and various banks of DRAM/SDRAM onboard.  This driver
21  *      implements this PCI Ram device as an MTD (Memory Technology
22  *      Device) so that it can be used to hold a file system, or for
23  *      added swap space in embedded systems.  Since the memory on
24  *      this board isn't as fast as main memory we do not try to hook
25  *      it into main memory as that would simply reduce performance
26  *      on the system.  Using it as a block device allows us to use
27  *      it as high speed swap or for a high speed disk device of some
28  *      sort.  Which becomes very useful on diskless systems in the
29  *      embedded market I might add.
30  *
31  * Notes:
32  *      Due to what I assume is more buggy SROM, the 64M PMC551 I
33  *      have available claims that all 4 of its DRAM banks have 64MiB
34  *      of ram configured (making a grand total of 256MiB onboard).
35  *      This is slightly annoying since the BAR0 size reflects the
36  *      aperture size, not the dram size, and the V370PDC supplies no
37  *      other method for memory size discovery.  This problem is
38  *      mostly only relevant when compiled as a module, as the
39  *      unloading of the module with an aperture size smaller then
40  *      the ram will cause the driver to detect the onboard memory
41  *      size to be equal to the aperture size when the module is
42  *      reloaded.  Soooo, to help, the module supports an msize
43  *      option to allow the specification of the onboard memory, and
44  *      an asize option, to allow the specification of the aperture
45  *      size.  The aperture must be equal to or less then the memory
46  *      size, the driver will correct this if you screw it up.  This
47  *      problem is not relevant for compiled in drivers as compiled
48  *      in drivers only init once.
49  *
50  * Credits:
51  *      Saeed Karamooz <saeed@ramix.com> of Ramix INC. for the
52  *      initial example code of how to initialize this device and for
53  *      help with questions I had concerning operation of the device.
54  *
55  *      Most of the MTD code for this driver was originally written
56  *      for the slram.o module in the MTD drivers package which
57  *      allows the mapping of system memory into an MTD device.
58  *      Since the PMC551 memory module is accessed in the same
59  *      fashion as system memory, the slram.c code became a very nice
60  *      fit to the needs of this driver.  All we added was PCI
61  *      detection/initialization to the driver and automatically figure
62  *      out the size via the PCI detection.o, later changes by Corey
63  *      Minyard set up the card to utilize a 1M sliding apature.
64  *
65  *      Corey Minyard <minyard@nortelnetworks.com>
66  *      * Modified driver to utilize a sliding aperture instead of
67  *       mapping all memory into kernel space which turned out to
68  *       be very wasteful.
69  *      * Located a bug in the SROM's initialization sequence that
70  *       made the memory unusable, added a fix to code to touch up
71  *       the DRAM some.
72  *
73  * Bugs/FIXMEs:
74  *      * MUST fix the init function to not spin on a register
75  *      waiting for it to set .. this does not safely handle busted
76  *      devices that never reset the register correctly which will
77  *      cause the system to hang w/ a reboot being the only chance at
78  *      recover. [sort of fixed, could be better]
79  *      * Add I2C handling of the SROM so we can read the SROM's information
80  *      about the aperture size.  This should always accurately reflect the
81  *      onboard memory size.
82  *      * Comb the init routine.  It's still a bit cludgy on a few things.
83  */
84
85 #include <linux/kernel.h>
86 #include <linux/module.h>
87 #include <asm/uaccess.h>
88 #include <linux/types.h>
89 #include <linux/init.h>
90 #include <linux/ptrace.h>
91 #include <linux/slab.h>
92 #include <linux/string.h>
93 #include <linux/timer.h>
94 #include <linux/major.h>
95 #include <linux/fs.h>
96 #include <linux/ioctl.h>
97 #include <asm/io.h>
98 #include <asm/system.h>
99 #include <linux/pci.h>
100
101 #include <linux/mtd/mtd.h>
102 #include <linux/mtd/pmc551.h>
103 #include <linux/mtd/compatmac.h>
104
105 static struct mtd_info *pmc551list;
106
107 static int pmc551_erase(struct mtd_info *mtd, struct erase_info *instr)
108 {
109         struct mypriv *priv = mtd->priv;
110         u32 soff_hi, soff_lo;   /* start address offset hi/lo */
111         u32 eoff_hi, eoff_lo;   /* end address offset hi/lo */
112         unsigned long end;
113         u_char *ptr;
114         size_t retlen;
115
116 #ifdef CONFIG_MTD_PMC551_DEBUG
117         printk(KERN_DEBUG "pmc551_erase(pos:%ld, len:%ld)\n", (long)instr->addr,
118                 (long)instr->len);
119 #endif
120
121         end = instr->addr + instr->len - 1;
122
123         /* Is it past the end? */
124         if (end > mtd->size) {
125 #ifdef CONFIG_MTD_PMC551_DEBUG
126                 printk(KERN_DEBUG "pmc551_erase() out of bounds (%ld > %ld)\n",
127                         (long)end, (long)mtd->size);
128 #endif
129                 return -EINVAL;
130         }
131
132         eoff_hi = end & ~(priv->asize - 1);
133         soff_hi = instr->addr & ~(priv->asize - 1);
134         eoff_lo = end & (priv->asize - 1);
135         soff_lo = instr->addr & (priv->asize - 1);
136
137         pmc551_point(mtd, instr->addr, instr->len, &retlen,
138                      (void **)&ptr, NULL);
139
140         if (soff_hi == eoff_hi || mtd->size == priv->asize) {
141                 /* The whole thing fits within one access, so just one shot
142                    will do it. */
143                 memset(ptr, 0xff, instr->len);
144         } else {
145                 /* We have to do multiple writes to get all the data
146                    written. */
147                 while (soff_hi != eoff_hi) {
148 #ifdef CONFIG_MTD_PMC551_DEBUG
149                         printk(KERN_DEBUG "pmc551_erase() soff_hi: %ld, "
150                                 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi);
151 #endif
152                         memset(ptr, 0xff, priv->asize);
153                         if (soff_hi + priv->asize >= mtd->size) {
154                                 goto out;
155                         }
156                         soff_hi += priv->asize;
157                         pmc551_point(mtd, (priv->base_map0 | soff_hi),
158                                      priv->asize, &retlen,
159                                      (void **)&ptr, NULL);
160                 }
161                 memset(ptr, 0xff, eoff_lo);
162         }
163
164       out:
165         instr->state = MTD_ERASE_DONE;
166 #ifdef CONFIG_MTD_PMC551_DEBUG
167         printk(KERN_DEBUG "pmc551_erase() done\n");
168 #endif
169
170         mtd_erase_callback(instr);
171         return 0;
172 }
173
174 static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len,
175                         size_t *retlen, void **virt, resource_size_t *phys)
176 {
177         struct mypriv *priv = mtd->priv;
178         u32 soff_hi;
179         u32 soff_lo;
180
181 #ifdef CONFIG_MTD_PMC551_DEBUG
182         printk(KERN_DEBUG "pmc551_point(%ld, %ld)\n", (long)from, (long)len);
183 #endif
184
185         if (from + len > mtd->size) {
186 #ifdef CONFIG_MTD_PMC551_DEBUG
187                 printk(KERN_DEBUG "pmc551_point() out of bounds (%ld > %ld)\n",
188                         (long)from + len, (long)mtd->size);
189 #endif
190                 return -EINVAL;
191         }
192
193         /* can we return a physical address with this driver? */
194         if (phys)
195                 return -EINVAL;
196
197         soff_hi = from & ~(priv->asize - 1);
198         soff_lo = from & (priv->asize - 1);
199
200         /* Cheap hack optimization */
201         if (priv->curr_map0 != from) {
202                 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0,
203                                         (priv->base_map0 | soff_hi));
204                 priv->curr_map0 = soff_hi;
205         }
206
207         *virt = priv->start + soff_lo;
208         *retlen = len;
209         return 0;
210 }
211
212 static void pmc551_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
213 {
214 #ifdef CONFIG_MTD_PMC551_DEBUG
215         printk(KERN_DEBUG "pmc551_unpoint()\n");
216 #endif
217 }
218
219 static int pmc551_read(struct mtd_info *mtd, loff_t from, size_t len,
220                         size_t * retlen, u_char * buf)
221 {
222         struct mypriv *priv = mtd->priv;
223         u32 soff_hi, soff_lo;   /* start address offset hi/lo */
224         u32 eoff_hi, eoff_lo;   /* end address offset hi/lo */
225         unsigned long end;
226         u_char *ptr;
227         u_char *copyto = buf;
228
229 #ifdef CONFIG_MTD_PMC551_DEBUG
230         printk(KERN_DEBUG "pmc551_read(pos:%ld, len:%ld) asize: %ld\n",
231                 (long)from, (long)len, (long)priv->asize);
232 #endif
233
234         end = from + len - 1;
235
236         /* Is it past the end? */
237         if (end > mtd->size) {
238 #ifdef CONFIG_MTD_PMC551_DEBUG
239                 printk(KERN_DEBUG "pmc551_read() out of bounds (%ld > %ld)\n",
240                         (long)end, (long)mtd->size);
241 #endif
242                 return -EINVAL;
243         }
244
245         soff_hi = from & ~(priv->asize - 1);
246         eoff_hi = end & ~(priv->asize - 1);
247         soff_lo = from & (priv->asize - 1);
248         eoff_lo = end & (priv->asize - 1);
249
250         pmc551_point(mtd, from, len, retlen, (void **)&ptr, NULL);
251
252         if (soff_hi == eoff_hi) {
253                 /* The whole thing fits within one access, so just one shot
254                    will do it. */
255                 memcpy(copyto, ptr, len);
256                 copyto += len;
257         } else {
258                 /* We have to do multiple writes to get all the data
259                    written. */
260                 while (soff_hi != eoff_hi) {
261 #ifdef CONFIG_MTD_PMC551_DEBUG
262                         printk(KERN_DEBUG "pmc551_read() soff_hi: %ld, "
263                                 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi);
264 #endif
265                         memcpy(copyto, ptr, priv->asize);
266                         copyto += priv->asize;
267                         if (soff_hi + priv->asize >= mtd->size) {
268                                 goto out;
269                         }
270                         soff_hi += priv->asize;
271                         pmc551_point(mtd, soff_hi, priv->asize, retlen,
272                                      (void **)&ptr, NULL);
273                 }
274                 memcpy(copyto, ptr, eoff_lo);
275                 copyto += eoff_lo;
276         }
277
278       out:
279 #ifdef CONFIG_MTD_PMC551_DEBUG
280         printk(KERN_DEBUG "pmc551_read() done\n");
281 #endif
282         *retlen = copyto - buf;
283         return 0;
284 }
285
286 static int pmc551_write(struct mtd_info *mtd, loff_t to, size_t len,
287                         size_t * retlen, const u_char * buf)
288 {
289         struct mypriv *priv = mtd->priv;
290         u32 soff_hi, soff_lo;   /* start address offset hi/lo */
291         u32 eoff_hi, eoff_lo;   /* end address offset hi/lo */
292         unsigned long end;
293         u_char *ptr;
294         const u_char *copyfrom = buf;
295
296 #ifdef CONFIG_MTD_PMC551_DEBUG
297         printk(KERN_DEBUG "pmc551_write(pos:%ld, len:%ld) asize:%ld\n",
298                 (long)to, (long)len, (long)priv->asize);
299 #endif
300
301         end = to + len - 1;
302         /* Is it past the end?  or did the u32 wrap? */
303         if (end > mtd->size) {
304 #ifdef CONFIG_MTD_PMC551_DEBUG
305                 printk(KERN_DEBUG "pmc551_write() out of bounds (end: %ld, "
306                         "size: %ld, to: %ld)\n", (long)end, (long)mtd->size,
307                         (long)to);
308 #endif
309                 return -EINVAL;
310         }
311
312         soff_hi = to & ~(priv->asize - 1);
313         eoff_hi = end & ~(priv->asize - 1);
314         soff_lo = to & (priv->asize - 1);
315         eoff_lo = end & (priv->asize - 1);
316
317         pmc551_point(mtd, to, len, retlen, (void **)&ptr, NULL);
318
319         if (soff_hi == eoff_hi) {
320                 /* The whole thing fits within one access, so just one shot
321                    will do it. */
322                 memcpy(ptr, copyfrom, len);
323                 copyfrom += len;
324         } else {
325                 /* We have to do multiple writes to get all the data
326                    written. */
327                 while (soff_hi != eoff_hi) {
328 #ifdef CONFIG_MTD_PMC551_DEBUG
329                         printk(KERN_DEBUG "pmc551_write() soff_hi: %ld, "
330                                 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi);
331 #endif
332                         memcpy(ptr, copyfrom, priv->asize);
333                         copyfrom += priv->asize;
334                         if (soff_hi >= mtd->size) {
335                                 goto out;
336                         }
337                         soff_hi += priv->asize;
338                         pmc551_point(mtd, soff_hi, priv->asize, retlen,
339                                      (void **)&ptr, NULL);
340                 }
341                 memcpy(ptr, copyfrom, eoff_lo);
342                 copyfrom += eoff_lo;
343         }
344
345       out:
346 #ifdef CONFIG_MTD_PMC551_DEBUG
347         printk(KERN_DEBUG "pmc551_write() done\n");
348 #endif
349         *retlen = copyfrom - buf;
350         return 0;
351 }
352
353 /*
354  * Fixup routines for the V370PDC
355  * PCI device ID 0x020011b0
356  *
357  * This function basicly kick starts the DRAM oboard the card and gets it
358  * ready to be used.  Before this is done the device reads VERY erratic, so
359  * much that it can crash the Linux 2.2.x series kernels when a user cat's
360  * /proc/pci .. though that is mainly a kernel bug in handling the PCI DEVSEL
361  * register.  FIXME: stop spinning on registers .. must implement a timeout
362  * mechanism
363  * returns the size of the memory region found.
364  */
365 static u32 fixup_pmc551(struct pci_dev *dev)
366 {
367 #ifdef CONFIG_MTD_PMC551_BUGFIX
368         u32 dram_data;
369 #endif
370         u32 size, dcmd, cfg, dtmp;
371         u16 cmd, tmp, i;
372         u8 bcmd, counter;
373
374         /* Sanity Check */
375         if (!dev) {
376                 return -ENODEV;
377         }
378
379         /*
380          * Attempt to reset the card
381          * FIXME: Stop Spinning registers
382          */
383         counter = 0;
384         /* unlock registers */
385         pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, 0xA5);
386         /* read in old data */
387         pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd);
388         /* bang the reset line up and down for a few */
389         for (i = 0; i < 10; i++) {
390                 counter = 0;
391                 bcmd &= ~0x80;
392                 while (counter++ < 100) {
393                         pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
394                 }
395                 counter = 0;
396                 bcmd |= 0x80;
397                 while (counter++ < 100) {
398                         pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
399                 }
400         }
401         bcmd |= (0x40 | 0x20);
402         pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
403
404         /*
405          * Take care and turn off the memory on the device while we
406          * tweak the configurations
407          */
408         pci_read_config_word(dev, PCI_COMMAND, &cmd);
409         tmp = cmd & ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
410         pci_write_config_word(dev, PCI_COMMAND, tmp);
411
412         /*
413          * Disable existing aperture before probing memory size
414          */
415         pci_read_config_dword(dev, PMC551_PCI_MEM_MAP0, &dcmd);
416         dtmp = (dcmd | PMC551_PCI_MEM_MAP_ENABLE | PMC551_PCI_MEM_MAP_REG_EN);
417         pci_write_config_dword(dev, PMC551_PCI_MEM_MAP0, dtmp);
418         /*
419          * Grab old BAR0 config so that we can figure out memory size
420          * This is another bit of kludge going on.  The reason for the
421          * redundancy is I am hoping to retain the original configuration
422          * previously assigned to the card by the BIOS or some previous
423          * fixup routine in the kernel.  So we read the old config into cfg,
424          * then write all 1's to the memory space, read back the result into
425          * "size", and then write back all the old config.
426          */
427         pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &cfg);
428 #ifndef CONFIG_MTD_PMC551_BUGFIX
429         pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, ~0);
430         pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &size);
431         size = (size & PCI_BASE_ADDRESS_MEM_MASK);
432         size &= ~(size - 1);
433         pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, cfg);
434 #else
435         /*
436          * Get the size of the memory by reading all the DRAM size values
437          * and adding them up.
438          *
439          * KLUDGE ALERT: the boards we are using have invalid column and
440          * row mux values.  We fix them here, but this will break other
441          * memory configurations.
442          */
443         pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dram_data);
444         size = PMC551_DRAM_BLK_GET_SIZE(dram_data);
445         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
446         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
447         pci_write_config_dword(dev, PMC551_DRAM_BLK0, dram_data);
448
449         pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dram_data);
450         size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
451         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
452         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
453         pci_write_config_dword(dev, PMC551_DRAM_BLK1, dram_data);
454
455         pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dram_data);
456         size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
457         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
458         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
459         pci_write_config_dword(dev, PMC551_DRAM_BLK2, dram_data);
460
461         pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dram_data);
462         size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
463         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
464         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
465         pci_write_config_dword(dev, PMC551_DRAM_BLK3, dram_data);
466
467         /*
468          * Oops .. something went wrong
469          */
470         if ((size &= PCI_BASE_ADDRESS_MEM_MASK) == 0) {
471                 return -ENODEV;
472         }
473 #endif                          /* CONFIG_MTD_PMC551_BUGFIX */
474
475         if ((cfg & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) {
476                 return -ENODEV;
477         }
478
479         /*
480          * Precharge Dram
481          */
482         pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0400);
483         pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x00bf);
484
485         /*
486          * Wait until command has gone through
487          * FIXME: register spinning issue
488          */
489         do {
490                 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
491                 if (counter++ > 100)
492                         break;
493         } while ((PCI_COMMAND_IO) & cmd);
494
495         /*
496          * Turn on auto refresh
497          * The loop is taken directly from Ramix's example code.  I assume that
498          * this must be held high for some duration of time, but I can find no
499          * documentation refrencing the reasons why.
500          */
501         for (i = 1; i <= 8; i++) {
502                 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0df);
503
504                 /*
505                  * Make certain command has gone through
506                  * FIXME: register spinning issue
507                  */
508                 counter = 0;
509                 do {
510                         pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
511                         if (counter++ > 100)
512                                 break;
513                 } while ((PCI_COMMAND_IO) & cmd);
514         }
515
516         pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0020);
517         pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0ff);
518
519         /*
520          * Wait until command completes
521          * FIXME: register spinning issue
522          */
523         counter = 0;
524         do {
525                 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
526                 if (counter++ > 100)
527                         break;
528         } while ((PCI_COMMAND_IO) & cmd);
529
530         pci_read_config_dword(dev, PMC551_DRAM_CFG, &dcmd);
531         dcmd |= 0x02000000;
532         pci_write_config_dword(dev, PMC551_DRAM_CFG, dcmd);
533
534         /*
535          * Check to make certain fast back-to-back, if not
536          * then set it so
537          */
538         pci_read_config_word(dev, PCI_STATUS, &cmd);
539         if ((cmd & PCI_COMMAND_FAST_BACK) == 0) {
540                 cmd |= PCI_COMMAND_FAST_BACK;
541                 pci_write_config_word(dev, PCI_STATUS, cmd);
542         }
543
544         /*
545          * Check to make certain the DEVSEL is set correctly, this device
546          * has a tendancy to assert DEVSEL and TRDY when a write is performed
547          * to the memory when memory is read-only
548          */
549         if ((cmd & PCI_STATUS_DEVSEL_MASK) != 0x0) {
550                 cmd &= ~PCI_STATUS_DEVSEL_MASK;
551                 pci_write_config_word(dev, PCI_STATUS, cmd);
552         }
553         /*
554          * Set to be prefetchable and put everything back based on old cfg.
555          * it's possible that the reset of the V370PDC nuked the original
556          * setup
557          */
558         /*
559            cfg |= PCI_BASE_ADDRESS_MEM_PREFETCH;
560            pci_write_config_dword( dev, PCI_BASE_ADDRESS_0, cfg );
561          */
562
563         /*
564          * Turn PCI memory and I/O bus access back on
565          */
566         pci_write_config_word(dev, PCI_COMMAND,
567                               PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
568 #ifdef CONFIG_MTD_PMC551_DEBUG
569         /*
570          * Some screen fun
571          */
572         printk(KERN_DEBUG "pmc551: %d%sB (0x%x) of %sprefetchable memory at "
573                 "0x%llx\n", (size < 1024) ? size : (size < 1048576) ?
574                 size >> 10 : size >> 20,
575                 (size < 1024) ? "" : (size < 1048576) ? "Ki" : "Mi", size,
576                 ((dcmd & (0x1 << 3)) == 0) ? "non-" : "",
577                 (unsigned long long)pci_resource_start(dev, 0));
578
579         /*
580          * Check to see the state of the memory
581          */
582         pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dcmd);
583         printk(KERN_DEBUG "pmc551: DRAM_BLK0 Flags: %s,%s\n"
584                 "pmc551: DRAM_BLK0 Size: %d at %d\n"
585                 "pmc551: DRAM_BLK0 Row MUX: %d, Col MUX: %d\n",
586                 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
587                 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
588                 PMC551_DRAM_BLK_GET_SIZE(dcmd),
589                 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
590                 ((dcmd >> 9) & 0xF));
591
592         pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dcmd);
593         printk(KERN_DEBUG "pmc551: DRAM_BLK1 Flags: %s,%s\n"
594                 "pmc551: DRAM_BLK1 Size: %d at %d\n"
595                 "pmc551: DRAM_BLK1 Row MUX: %d, Col MUX: %d\n",
596                 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
597                 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
598                 PMC551_DRAM_BLK_GET_SIZE(dcmd),
599                 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
600                 ((dcmd >> 9) & 0xF));
601
602         pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dcmd);
603         printk(KERN_DEBUG "pmc551: DRAM_BLK2 Flags: %s,%s\n"
604                 "pmc551: DRAM_BLK2 Size: %d at %d\n"
605                 "pmc551: DRAM_BLK2 Row MUX: %d, Col MUX: %d\n",
606                 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
607                 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
608                 PMC551_DRAM_BLK_GET_SIZE(dcmd),
609                 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
610                 ((dcmd >> 9) & 0xF));
611
612         pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dcmd);
613         printk(KERN_DEBUG "pmc551: DRAM_BLK3 Flags: %s,%s\n"
614                 "pmc551: DRAM_BLK3 Size: %d at %d\n"
615                 "pmc551: DRAM_BLK3 Row MUX: %d, Col MUX: %d\n",
616                 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
617                 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
618                 PMC551_DRAM_BLK_GET_SIZE(dcmd),
619                 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
620                 ((dcmd >> 9) & 0xF));
621
622         pci_read_config_word(dev, PCI_COMMAND, &cmd);
623         printk(KERN_DEBUG "pmc551: Memory Access %s\n",
624                 (((0x1 << 1) & cmd) == 0) ? "off" : "on");
625         printk(KERN_DEBUG "pmc551: I/O Access %s\n",
626                 (((0x1 << 0) & cmd) == 0) ? "off" : "on");
627
628         pci_read_config_word(dev, PCI_STATUS, &cmd);
629         printk(KERN_DEBUG "pmc551: Devsel %s\n",
630                 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x000) ? "Fast" :
631                 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x200) ? "Medium" :
632                 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x400) ? "Slow" : "Invalid");
633
634         printk(KERN_DEBUG "pmc551: %sFast Back-to-Back\n",
635                 ((PCI_COMMAND_FAST_BACK & cmd) == 0) ? "Not " : "");
636
637         pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd);
638         printk(KERN_DEBUG "pmc551: EEPROM is under %s control\n"
639                 "pmc551: System Control Register is %slocked to PCI access\n"
640                 "pmc551: System Control Register is %slocked to EEPROM access\n",
641                 (bcmd & 0x1) ? "software" : "hardware",
642                 (bcmd & 0x20) ? "" : "un", (bcmd & 0x40) ? "" : "un");
643 #endif
644         return size;
645 }
646
647 /*
648  * Kernel version specific module stuffages
649  */
650
651 MODULE_LICENSE("GPL");
652 MODULE_AUTHOR("Mark Ferrell <mferrell@mvista.com>");
653 MODULE_DESCRIPTION(PMC551_VERSION);
654
655 /*
656  * Stuff these outside the ifdef so as to not bust compiled in driver support
657  */
658 static int msize = 0;
659 static int asize = 0;
660
661 module_param(msize, int, 0);
662 MODULE_PARM_DESC(msize, "memory size in MiB [1 - 1024]");
663 module_param(asize, int, 0);
664 MODULE_PARM_DESC(asize, "aperture size, must be <= memsize [1-1024]");
665
666 /*
667  * PMC551 Card Initialization
668  */
669 static int __init init_pmc551(void)
670 {
671         struct pci_dev *PCI_Device = NULL;
672         struct mypriv *priv;
673         int count, found = 0;
674         struct mtd_info *mtd;
675         u32 length = 0;
676
677         if (msize) {
678                 msize = (1 << (ffs(msize) - 1)) << 20;
679                 if (msize > (1 << 30)) {
680                         printk(KERN_NOTICE "pmc551: Invalid memory size [%d]\n",
681                                 msize);
682                         return -EINVAL;
683                 }
684         }
685
686         if (asize) {
687                 asize = (1 << (ffs(asize) - 1)) << 20;
688                 if (asize > (1 << 30)) {
689                         printk(KERN_NOTICE "pmc551: Invalid aperture size "
690                                 "[%d]\n", asize);
691                         return -EINVAL;
692                 }
693         }
694
695         printk(KERN_INFO PMC551_VERSION);
696
697         /*
698          * PCU-bus chipset probe.
699          */
700         for (count = 0; count < MAX_MTD_DEVICES; count++) {
701
702                 if ((PCI_Device = pci_get_device(PCI_VENDOR_ID_V3_SEMI,
703                                                   PCI_DEVICE_ID_V3_SEMI_V370PDC,
704                                                   PCI_Device)) == NULL) {
705                         break;
706                 }
707
708                 printk(KERN_NOTICE "pmc551: Found PCI V370PDC at 0x%llx\n",
709                         (unsigned long long)pci_resource_start(PCI_Device, 0));
710
711                 /*
712                  * The PMC551 device acts VERY weird if you don't init it
713                  * first.  i.e. it will not correctly report devsel.  If for
714                  * some reason the sdram is in a wrote-protected state the
715                  * device will DEVSEL when it is written to causing problems
716                  * with the oldproc.c driver in
717                  * some kernels (2.2.*)
718                  */
719                 if ((length = fixup_pmc551(PCI_Device)) <= 0) {
720                         printk(KERN_NOTICE "pmc551: Cannot init SDRAM\n");
721                         break;
722                 }
723
724                 /*
725                  * This is needed until the driver is capable of reading the
726                  * onboard I2C SROM to discover the "real" memory size.
727                  */
728                 if (msize) {
729                         length = msize;
730                         printk(KERN_NOTICE "pmc551: Using specified memory "
731                                 "size 0x%x\n", length);
732                 } else {
733                         msize = length;
734                 }
735
736                 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
737                 if (!mtd) {
738                         printk(KERN_NOTICE "pmc551: Cannot allocate new MTD "
739                                 "device.\n");
740                         break;
741                 }
742
743                 priv = kzalloc(sizeof(struct mypriv), GFP_KERNEL);
744                 if (!priv) {
745                         printk(KERN_NOTICE "pmc551: Cannot allocate new MTD "
746                                 "device.\n");
747                         kfree(mtd);
748                         break;
749                 }
750                 mtd->priv = priv;
751                 priv->dev = PCI_Device;
752
753                 if (asize > length) {
754                         printk(KERN_NOTICE "pmc551: reducing aperture size to "
755                                 "fit %dM\n", length >> 20);
756                         priv->asize = asize = length;
757                 } else if (asize == 0 || asize == length) {
758                         printk(KERN_NOTICE "pmc551: Using existing aperture "
759                                 "size %dM\n", length >> 20);
760                         priv->asize = asize = length;
761                 } else {
762                         printk(KERN_NOTICE "pmc551: Using specified aperture "
763                                 "size %dM\n", asize >> 20);
764                         priv->asize = asize;
765                 }
766                 priv->start = pci_iomap(PCI_Device, 0, priv->asize);
767
768                 if (!priv->start) {
769                         printk(KERN_NOTICE "pmc551: Unable to map IO space\n");
770                         kfree(mtd->priv);
771                         kfree(mtd);
772                         break;
773                 }
774 #ifdef CONFIG_MTD_PMC551_DEBUG
775                 printk(KERN_DEBUG "pmc551: setting aperture to %d\n",
776                         ffs(priv->asize >> 20) - 1);
777 #endif
778
779                 priv->base_map0 = (PMC551_PCI_MEM_MAP_REG_EN
780                                    | PMC551_PCI_MEM_MAP_ENABLE
781                                    | (ffs(priv->asize >> 20) - 1) << 4);
782                 priv->curr_map0 = priv->base_map0;
783                 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0,
784                                         priv->curr_map0);
785
786 #ifdef CONFIG_MTD_PMC551_DEBUG
787                 printk(KERN_DEBUG "pmc551: aperture set to %d\n",
788                         (priv->base_map0 & 0xF0) >> 4);
789 #endif
790
791                 mtd->size = msize;
792                 mtd->flags = MTD_CAP_RAM;
793                 mtd->erase = pmc551_erase;
794                 mtd->read = pmc551_read;
795                 mtd->write = pmc551_write;
796                 mtd->point = pmc551_point;
797                 mtd->unpoint = pmc551_unpoint;
798                 mtd->type = MTD_RAM;
799                 mtd->name = "PMC551 RAM board";
800                 mtd->erasesize = 0x10000;
801                 mtd->writesize = 1;
802                 mtd->owner = THIS_MODULE;
803
804                 if (add_mtd_device(mtd)) {
805                         printk(KERN_NOTICE "pmc551: Failed to register new device\n");
806                         pci_iounmap(PCI_Device, priv->start);
807                         kfree(mtd->priv);
808                         kfree(mtd);
809                         break;
810                 }
811
812                 /* Keep a reference as the add_mtd_device worked */
813                 pci_dev_get(PCI_Device);
814
815                 printk(KERN_NOTICE "Registered pmc551 memory device.\n");
816                 printk(KERN_NOTICE "Mapped %dMiB of memory from 0x%p to 0x%p\n",
817                         priv->asize >> 20,
818                         priv->start, priv->start + priv->asize);
819                 printk(KERN_NOTICE "Total memory is %d%sB\n",
820                         (length < 1024) ? length :
821                         (length < 1048576) ? length >> 10 : length >> 20,
822                         (length < 1024) ? "" : (length < 1048576) ? "Ki" : "Mi");
823                 priv->nextpmc551 = pmc551list;
824                 pmc551list = mtd;
825                 found++;
826         }
827
828         /* Exited early, reference left over */
829         if (PCI_Device)
830                 pci_dev_put(PCI_Device);
831
832         if (!pmc551list) {
833                 printk(KERN_NOTICE "pmc551: not detected\n");
834                 return -ENODEV;
835         } else {
836                 printk(KERN_NOTICE "pmc551: %d pmc551 devices loaded\n", found);
837                 return 0;
838         }
839 }
840
841 /*
842  * PMC551 Card Cleanup
843  */
844 static void __exit cleanup_pmc551(void)
845 {
846         int found = 0;
847         struct mtd_info *mtd;
848         struct mypriv *priv;
849
850         while ((mtd = pmc551list)) {
851                 priv = mtd->priv;
852                 pmc551list = priv->nextpmc551;
853
854                 if (priv->start) {
855                         printk(KERN_DEBUG "pmc551: unmapping %dMiB starting at "
856                                 "0x%p\n", priv->asize >> 20, priv->start);
857                         pci_iounmap(priv->dev, priv->start);
858                 }
859                 pci_dev_put(priv->dev);
860
861                 kfree(mtd->priv);
862                 del_mtd_device(mtd);
863                 kfree(mtd);
864                 found++;
865         }
866
867         printk(KERN_NOTICE "pmc551: %d pmc551 devices unloaded\n", found);
868 }
869
870 module_init(init_pmc551);
871 module_exit(cleanup_pmc551);