e8f686f7a357bd0e06a408dfb1b668d9a71c0317
[linux-2.6.git] / 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 it's DRAM banks have 64M
34  *      of ram configured (making a grand total of 256M 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/FIXME's:
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, &ptr);
138
139         if (soff_hi == eoff_hi || mtd->size == priv->asize) {
140                 /* The whole thing fits within one access, so just one shot
141                    will do it. */
142                 memset(ptr, 0xff, instr->len);
143         } else {
144                 /* We have to do multiple writes to get all the data
145                    written. */
146                 while (soff_hi != eoff_hi) {
147 #ifdef CONFIG_MTD_PMC551_DEBUG
148                         printk(KERN_DEBUG "pmc551_erase() soff_hi: %ld, "
149                                 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi);
150 #endif
151                         memset(ptr, 0xff, priv->asize);
152                         if (soff_hi + priv->asize >= mtd->size) {
153                                 goto out;
154                         }
155                         soff_hi += priv->asize;
156                         pmc551_point(mtd, (priv->base_map0 | soff_hi),
157                                      priv->asize, &retlen, &ptr);
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
172 static int pmc551_point(struct mtd_info *mtd, loff_t from, size_t len,
173                         size_t * retlen, u_char ** mtdbuf)
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         soff_hi = from & ~(priv->asize - 1);
192         soff_lo = from & (priv->asize - 1);
193
194         /* Cheap hack optimization */
195         if (priv->curr_map0 != from) {
196                 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0,
197                                         (priv->base_map0 | soff_hi));
198                 priv->curr_map0 = soff_hi;
199         }
200
201         *mtdbuf = priv->start + soff_lo;
202         *retlen = len;
203         return 0;
204 }
205
206 static void pmc551_unpoint(struct mtd_info *mtd, u_char * addr, loff_t from,
207                            size_t len)
208 {
209 #ifdef CONFIG_MTD_PMC551_DEBUG
210         printk(KERN_DEBUG "pmc551_unpoint()\n");
211 #endif
212 }
213
214 static int pmc551_read(struct mtd_info *mtd, loff_t from, size_t len,
215                         size_t * retlen, u_char * buf)
216 {
217         struct mypriv *priv = mtd->priv;
218         u32 soff_hi, soff_lo;   /* start address offset hi/lo */
219         u32 eoff_hi, eoff_lo;   /* end address offset hi/lo */
220         unsigned long end;
221         u_char *ptr;
222         u_char *copyto = buf;
223
224 #ifdef CONFIG_MTD_PMC551_DEBUG
225         printk(KERN_DEBUG "pmc551_read(pos:%ld, len:%ld) asize: %ld\n",
226                 (long)from, (long)len, (long)priv->asize);
227 #endif
228
229         end = from + len - 1;
230
231         /* Is it past the end? */
232         if (end > mtd->size) {
233 #ifdef CONFIG_MTD_PMC551_DEBUG
234                 printk(KERN_DEBUG "pmc551_read() out of bounds (%ld > %ld)\n",
235                         (long)end, (long)mtd->size);
236 #endif
237                 return -EINVAL;
238         }
239
240         soff_hi = from & ~(priv->asize - 1);
241         eoff_hi = end & ~(priv->asize - 1);
242         soff_lo = from & (priv->asize - 1);
243         eoff_lo = end & (priv->asize - 1);
244
245         pmc551_point(mtd, from, len, retlen, &ptr);
246
247         if (soff_hi == eoff_hi) {
248                 /* The whole thing fits within one access, so just one shot
249                    will do it. */
250                 memcpy(copyto, ptr, len);
251                 copyto += len;
252         } else {
253                 /* We have to do multiple writes to get all the data
254                    written. */
255                 while (soff_hi != eoff_hi) {
256 #ifdef CONFIG_MTD_PMC551_DEBUG
257                         printk(KERN_DEBUG "pmc551_read() soff_hi: %ld, "
258                                 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi);
259 #endif
260                         memcpy(copyto, ptr, priv->asize);
261                         copyto += priv->asize;
262                         if (soff_hi + priv->asize >= mtd->size) {
263                                 goto out;
264                         }
265                         soff_hi += priv->asize;
266                         pmc551_point(mtd, soff_hi, priv->asize, retlen, &ptr);
267                 }
268                 memcpy(copyto, ptr, eoff_lo);
269                 copyto += eoff_lo;
270         }
271
272       out:
273 #ifdef CONFIG_MTD_PMC551_DEBUG
274         printk(KERN_DEBUG "pmc551_read() done\n");
275 #endif
276         *retlen = copyto - buf;
277         return 0;
278 }
279
280 static int pmc551_write(struct mtd_info *mtd, loff_t to, size_t len,
281                         size_t * retlen, const u_char * buf)
282 {
283         struct mypriv *priv = mtd->priv;
284         u32 soff_hi, soff_lo;   /* start address offset hi/lo */
285         u32 eoff_hi, eoff_lo;   /* end address offset hi/lo */
286         unsigned long end;
287         u_char *ptr;
288         const u_char *copyfrom = buf;
289
290 #ifdef CONFIG_MTD_PMC551_DEBUG
291         printk(KERN_DEBUG "pmc551_write(pos:%ld, len:%ld) asize:%ld\n",
292                 (long)to, (long)len, (long)priv->asize);
293 #endif
294
295         end = to + len - 1;
296         /* Is it past the end?  or did the u32 wrap? */
297         if (end > mtd->size) {
298 #ifdef CONFIG_MTD_PMC551_DEBUG
299                 printk(KERN_DEBUG "pmc551_write() out of bounds (end: %ld, "
300                         "size: %ld, to: %ld)\n", (long)end, (long)mtd->size,
301                         (long)to);
302 #endif
303                 return -EINVAL;
304         }
305
306         soff_hi = to & ~(priv->asize - 1);
307         eoff_hi = end & ~(priv->asize - 1);
308         soff_lo = to & (priv->asize - 1);
309         eoff_lo = end & (priv->asize - 1);
310
311         pmc551_point(mtd, to, len, retlen, &ptr);
312
313         if (soff_hi == eoff_hi) {
314                 /* The whole thing fits within one access, so just one shot
315                    will do it. */
316                 memcpy(ptr, copyfrom, len);
317                 copyfrom += len;
318         } else {
319                 /* We have to do multiple writes to get all the data
320                    written. */
321                 while (soff_hi != eoff_hi) {
322 #ifdef CONFIG_MTD_PMC551_DEBUG
323                         printk(KERN_DEBUG "pmc551_write() soff_hi: %ld, "
324                                 "eoff_hi: %ld\n", (long)soff_hi, (long)eoff_hi);
325 #endif
326                         memcpy(ptr, copyfrom, priv->asize);
327                         copyfrom += priv->asize;
328                         if (soff_hi >= mtd->size) {
329                                 goto out;
330                         }
331                         soff_hi += priv->asize;
332                         pmc551_point(mtd, soff_hi, priv->asize, retlen, &ptr);
333                 }
334                 memcpy(ptr, copyfrom, eoff_lo);
335                 copyfrom += eoff_lo;
336         }
337
338       out:
339 #ifdef CONFIG_MTD_PMC551_DEBUG
340         printk(KERN_DEBUG "pmc551_write() done\n");
341 #endif
342         *retlen = copyfrom - buf;
343         return 0;
344 }
345
346 /*
347  * Fixup routines for the V370PDC
348  * PCI device ID 0x020011b0
349  *
350  * This function basicly kick starts the DRAM oboard the card and gets it
351  * ready to be used.  Before this is done the device reads VERY erratic, so
352  * much that it can crash the Linux 2.2.x series kernels when a user cat's
353  * /proc/pci .. though that is mainly a kernel bug in handling the PCI DEVSEL
354  * register.  FIXME: stop spinning on registers .. must implement a timeout
355  * mechanism
356  * returns the size of the memory region found.
357  */
358 static u32 fixup_pmc551(struct pci_dev *dev)
359 {
360 #ifdef CONFIG_MTD_PMC551_BUGFIX
361         u32 dram_data;
362 #endif
363         u32 size, dcmd, cfg, dtmp;
364         u16 cmd, tmp, i;
365         u8 bcmd, counter;
366
367         /* Sanity Check */
368         if (!dev) {
369                 return -ENODEV;
370         }
371
372         /*
373          * Attempt to reset the card
374          * FIXME: Stop Spinning registers
375          */
376         counter = 0;
377         /* unlock registers */
378         pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, 0xA5);
379         /* read in old data */
380         pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd);
381         /* bang the reset line up and down for a few */
382         for (i = 0; i < 10; i++) {
383                 counter = 0;
384                 bcmd &= ~0x80;
385                 while (counter++ < 100) {
386                         pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
387                 }
388                 counter = 0;
389                 bcmd |= 0x80;
390                 while (counter++ < 100) {
391                         pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
392                 }
393         }
394         bcmd |= (0x40 | 0x20);
395         pci_write_config_byte(dev, PMC551_SYS_CTRL_REG, bcmd);
396
397         /*
398          * Take care and turn off the memory on the device while we
399          * tweak the configurations
400          */
401         pci_read_config_word(dev, PCI_COMMAND, &cmd);
402         tmp = cmd & ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
403         pci_write_config_word(dev, PCI_COMMAND, tmp);
404
405         /*
406          * Disable existing aperture before probing memory size
407          */
408         pci_read_config_dword(dev, PMC551_PCI_MEM_MAP0, &dcmd);
409         dtmp = (dcmd | PMC551_PCI_MEM_MAP_ENABLE | PMC551_PCI_MEM_MAP_REG_EN);
410         pci_write_config_dword(dev, PMC551_PCI_MEM_MAP0, dtmp);
411         /*
412          * Grab old BAR0 config so that we can figure out memory size
413          * This is another bit of kludge going on.  The reason for the
414          * redundancy is I am hoping to retain the original configuration
415          * previously assigned to the card by the BIOS or some previous
416          * fixup routine in the kernel.  So we read the old config into cfg,
417          * then write all 1's to the memory space, read back the result into
418          * "size", and then write back all the old config.
419          */
420         pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &cfg);
421 #ifndef CONFIG_MTD_PMC551_BUGFIX
422         pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, ~0);
423         pci_read_config_dword(dev, PCI_BASE_ADDRESS_0, &size);
424         size = (size & PCI_BASE_ADDRESS_MEM_MASK);
425         size &= ~(size - 1);
426         pci_write_config_dword(dev, PCI_BASE_ADDRESS_0, cfg);
427 #else
428         /*
429          * Get the size of the memory by reading all the DRAM size values
430          * and adding them up.
431          *
432          * KLUDGE ALERT: the boards we are using have invalid column and
433          * row mux values.  We fix them here, but this will break other
434          * memory configurations.
435          */
436         pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dram_data);
437         size = PMC551_DRAM_BLK_GET_SIZE(dram_data);
438         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
439         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
440         pci_write_config_dword(dev, PMC551_DRAM_BLK0, dram_data);
441
442         pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dram_data);
443         size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
444         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
445         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
446         pci_write_config_dword(dev, PMC551_DRAM_BLK1, dram_data);
447
448         pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dram_data);
449         size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
450         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
451         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
452         pci_write_config_dword(dev, PMC551_DRAM_BLK2, dram_data);
453
454         pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dram_data);
455         size += PMC551_DRAM_BLK_GET_SIZE(dram_data);
456         dram_data = PMC551_DRAM_BLK_SET_COL_MUX(dram_data, 0x5);
457         dram_data = PMC551_DRAM_BLK_SET_ROW_MUX(dram_data, 0x9);
458         pci_write_config_dword(dev, PMC551_DRAM_BLK3, dram_data);
459
460         /*
461          * Oops .. something went wrong
462          */
463         if ((size &= PCI_BASE_ADDRESS_MEM_MASK) == 0) {
464                 return -ENODEV;
465         }
466 #endif                          /* CONFIG_MTD_PMC551_BUGFIX */
467
468         if ((cfg & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) {
469                 return -ENODEV;
470         }
471
472         /*
473          * Precharge Dram
474          */
475         pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0400);
476         pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x00bf);
477
478         /*
479          * Wait until command has gone through
480          * FIXME: register spinning issue
481          */
482         do {
483                 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
484                 if (counter++ > 100)
485                         break;
486         } while ((PCI_COMMAND_IO) & cmd);
487
488         /*
489          * Turn on auto refresh
490          * The loop is taken directly from Ramix's example code.  I assume that
491          * this must be held high for some duration of time, but I can find no
492          * documentation refrencing the reasons why.
493          */
494         for (i = 1; i <= 8; i++) {
495                 pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0df);
496
497                 /*
498                  * Make certain command has gone through
499                  * FIXME: register spinning issue
500                  */
501                 counter = 0;
502                 do {
503                         pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
504                         if (counter++ > 100)
505                                 break;
506                 } while ((PCI_COMMAND_IO) & cmd);
507         }
508
509         pci_write_config_word(dev, PMC551_SDRAM_MA, 0x0020);
510         pci_write_config_word(dev, PMC551_SDRAM_CMD, 0x0ff);
511
512         /*
513          * Wait until command completes
514          * FIXME: register spinning issue
515          */
516         counter = 0;
517         do {
518                 pci_read_config_word(dev, PMC551_SDRAM_CMD, &cmd);
519                 if (counter++ > 100)
520                         break;
521         } while ((PCI_COMMAND_IO) & cmd);
522
523         pci_read_config_dword(dev, PMC551_DRAM_CFG, &dcmd);
524         dcmd |= 0x02000000;
525         pci_write_config_dword(dev, PMC551_DRAM_CFG, dcmd);
526
527         /*
528          * Check to make certain fast back-to-back, if not
529          * then set it so
530          */
531         pci_read_config_word(dev, PCI_STATUS, &cmd);
532         if ((cmd & PCI_COMMAND_FAST_BACK) == 0) {
533                 cmd |= PCI_COMMAND_FAST_BACK;
534                 pci_write_config_word(dev, PCI_STATUS, cmd);
535         }
536
537         /*
538          * Check to make certain the DEVSEL is set correctly, this device
539          * has a tendancy to assert DEVSEL and TRDY when a write is performed
540          * to the memory when memory is read-only
541          */
542         if ((cmd & PCI_STATUS_DEVSEL_MASK) != 0x0) {
543                 cmd &= ~PCI_STATUS_DEVSEL_MASK;
544                 pci_write_config_word(dev, PCI_STATUS, cmd);
545         }
546         /*
547          * Set to be prefetchable and put everything back based on old cfg.
548          * it's possible that the reset of the V370PDC nuked the original
549          * setup
550          */
551         /*
552            cfg |= PCI_BASE_ADDRESS_MEM_PREFETCH;
553            pci_write_config_dword( dev, PCI_BASE_ADDRESS_0, cfg );
554          */
555
556         /*
557          * Turn PCI memory and I/O bus access back on
558          */
559         pci_write_config_word(dev, PCI_COMMAND,
560                               PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
561 #ifdef CONFIG_MTD_PMC551_DEBUG
562         /*
563          * Some screen fun
564          */
565         printk(KERN_DEBUG "pmc551: %d%c (0x%x) of %sprefetchable memory at "
566                 "0x%llx\n", (size < 1024) ? size : (size < 1048576) ?
567                 size >> 10 : size >> 20,
568                 (size < 1024) ? 'B' : (size < 1048576) ? 'K' : 'M', size,
569                 ((dcmd & (0x1 << 3)) == 0) ? "non-" : "",
570                 (unsigned long long)pci_resource_start(dev, 0));
571
572         /*
573          * Check to see the state of the memory
574          */
575         pci_read_config_dword(dev, PMC551_DRAM_BLK0, &dcmd);
576         printk(KERN_DEBUG "pmc551: DRAM_BLK0 Flags: %s,%s\n"
577                 "pmc551: DRAM_BLK0 Size: %d at %d\n"
578                 "pmc551: DRAM_BLK0 Row MUX: %d, Col MUX: %d\n",
579                 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
580                 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
581                 PMC551_DRAM_BLK_GET_SIZE(dcmd),
582                 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
583                 ((dcmd >> 9) & 0xF));
584
585         pci_read_config_dword(dev, PMC551_DRAM_BLK1, &dcmd);
586         printk(KERN_DEBUG "pmc551: DRAM_BLK1 Flags: %s,%s\n"
587                 "pmc551: DRAM_BLK1 Size: %d at %d\n"
588                 "pmc551: DRAM_BLK1 Row MUX: %d, Col MUX: %d\n",
589                 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
590                 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
591                 PMC551_DRAM_BLK_GET_SIZE(dcmd),
592                 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
593                 ((dcmd >> 9) & 0xF));
594
595         pci_read_config_dword(dev, PMC551_DRAM_BLK2, &dcmd);
596         printk(KERN_DEBUG "pmc551: DRAM_BLK2 Flags: %s,%s\n"
597                 "pmc551: DRAM_BLK2 Size: %d at %d\n"
598                 "pmc551: DRAM_BLK2 Row MUX: %d, Col MUX: %d\n",
599                 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
600                 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
601                 PMC551_DRAM_BLK_GET_SIZE(dcmd),
602                 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
603                 ((dcmd >> 9) & 0xF));
604
605         pci_read_config_dword(dev, PMC551_DRAM_BLK3, &dcmd);
606         printk(KERN_DEBUG "pmc551: DRAM_BLK3 Flags: %s,%s\n"
607                 "pmc551: DRAM_BLK3 Size: %d at %d\n"
608                 "pmc551: DRAM_BLK3 Row MUX: %d, Col MUX: %d\n",
609                 (((0x1 << 1) & dcmd) == 0) ? "RW" : "RO",
610                 (((0x1 << 0) & dcmd) == 0) ? "Off" : "On",
611                 PMC551_DRAM_BLK_GET_SIZE(dcmd),
612                 ((dcmd >> 20) & 0x7FF), ((dcmd >> 13) & 0x7),
613                 ((dcmd >> 9) & 0xF));
614
615         pci_read_config_word(dev, PCI_COMMAND, &cmd);
616         printk(KERN_DEBUG "pmc551: Memory Access %s\n",
617                 (((0x1 << 1) & cmd) == 0) ? "off" : "on");
618         printk(KERN_DEBUG "pmc551: I/O Access %s\n",
619                 (((0x1 << 0) & cmd) == 0) ? "off" : "on");
620
621         pci_read_config_word(dev, PCI_STATUS, &cmd);
622         printk(KERN_DEBUG "pmc551: Devsel %s\n",
623                 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x000) ? "Fast" :
624                 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x200) ? "Medium" :
625                 ((PCI_STATUS_DEVSEL_MASK & cmd) == 0x400) ? "Slow" : "Invalid");
626
627         printk(KERN_DEBUG "pmc551: %sFast Back-to-Back\n",
628                 ((PCI_COMMAND_FAST_BACK & cmd) == 0) ? "Not " : "");
629
630         pci_read_config_byte(dev, PMC551_SYS_CTRL_REG, &bcmd);
631         printk(KERN_DEBUG "pmc551: EEPROM is under %s control\n"
632                 "pmc551: System Control Register is %slocked to PCI access\n"
633                 "pmc551: System Control Register is %slocked to EEPROM access\n",
634                 (bcmd & 0x1) ? "software" : "hardware",
635                 (bcmd & 0x20) ? "" : "un", (bcmd & 0x40) ? "" : "un");
636 #endif
637         return size;
638 }
639
640 /*
641  * Kernel version specific module stuffages
642  */
643
644 MODULE_LICENSE("GPL");
645 MODULE_AUTHOR("Mark Ferrell <mferrell@mvista.com>");
646 MODULE_DESCRIPTION(PMC551_VERSION);
647
648 /*
649  * Stuff these outside the ifdef so as to not bust compiled in driver support
650  */
651 static int msize = 0;
652 #if defined(CONFIG_MTD_PMC551_APERTURE_SIZE)
653 static int asize = CONFIG_MTD_PMC551_APERTURE_SIZE;
654 #else
655 static int asize = 0;
656 #endif
657
658 module_param(msize, int, 0);
659 MODULE_PARM_DESC(msize, "memory size in Megabytes [1 - 1024]");
660 module_param(asize, int, 0);
661 MODULE_PARM_DESC(asize, "aperture size, must be <= memsize [1-1024]");
662
663 /*
664  * PMC551 Card Initialization
665  */
666 static int __init init_pmc551(void)
667 {
668         struct pci_dev *PCI_Device = NULL;
669         struct mypriv *priv;
670         int count, found = 0;
671         struct mtd_info *mtd;
672         u32 length = 0;
673
674         if (msize) {
675                 msize = (1 << (ffs(msize) - 1)) << 20;
676                 if (msize > (1 << 30)) {
677                         printk(KERN_NOTICE "pmc551: Invalid memory size [%d]\n",
678                                 msize);
679                         return -EINVAL;
680                 }
681         }
682
683         if (asize) {
684                 asize = (1 << (ffs(asize) - 1)) << 20;
685                 if (asize > (1 << 30)) {
686                         printk(KERN_NOTICE "pmc551: Invalid aperture size "
687                                 "[%d]\n", asize);
688                         return -EINVAL;
689                 }
690         }
691
692         printk(KERN_INFO PMC551_VERSION);
693
694         /*
695          * PCU-bus chipset probe.
696          */
697         for (count = 0; count < MAX_MTD_DEVICES; count++) {
698
699                 if ((PCI_Device = pci_get_device(PCI_VENDOR_ID_V3_SEMI,
700                                                   PCI_DEVICE_ID_V3_SEMI_V370PDC,
701                                                   PCI_Device)) == NULL) {
702                         break;
703                 }
704
705                 printk(KERN_NOTICE "pmc551: Found PCI V370PDC at 0x%llx\n",
706                         (unsigned long long)pci_resource_start(PCI_Device, 0));
707
708                 /*
709                  * The PMC551 device acts VERY weird if you don't init it
710                  * first.  i.e. it will not correctly report devsel.  If for
711                  * some reason the sdram is in a wrote-protected state the
712                  * device will DEVSEL when it is written to causing problems
713                  * with the oldproc.c driver in
714                  * some kernels (2.2.*)
715                  */
716                 if ((length = fixup_pmc551(PCI_Device)) <= 0) {
717                         printk(KERN_NOTICE "pmc551: Cannot init SDRAM\n");
718                         break;
719                 }
720
721                 /*
722                  * This is needed until the driver is capable of reading the
723                  * onboard I2C SROM to discover the "real" memory size.
724                  */
725                 if (msize) {
726                         length = msize;
727                         printk(KERN_NOTICE "pmc551: Using specified memory "
728                                 "size 0x%x\n", length);
729                 } else {
730                         msize = length;
731                 }
732
733                 mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
734                 if (!mtd) {
735                         printk(KERN_NOTICE "pmc551: Cannot allocate new MTD "
736                                 "device.\n");
737                         break;
738                 }
739
740                 priv = kzalloc(sizeof(struct mypriv), GFP_KERNEL);
741                 if (!priv) {
742                         printk(KERN_NOTICE "pmc551: Cannot allocate new MTD "
743                                 "device.\n");
744                         kfree(mtd);
745                         break;
746                 }
747                 mtd->priv = priv;
748                 priv->dev = PCI_Device;
749
750                 if (asize > length) {
751                         printk(KERN_NOTICE "pmc551: reducing aperture size to "
752                                 "fit %dM\n", length >> 20);
753                         priv->asize = asize = length;
754                 } else if (asize == 0 || asize == length) {
755                         printk(KERN_NOTICE "pmc551: Using existing aperture "
756                                 "size %dM\n", length >> 20);
757                         priv->asize = asize = length;
758                 } else {
759                         printk(KERN_NOTICE "pmc551: Using specified aperture "
760                                 "size %dM\n", asize >> 20);
761                         priv->asize = asize;
762                 }
763                 priv->start = pci_iomap(PCI_Device, 0, priv->asize);
764
765                 if (!priv->start) {
766                         printk(KERN_NOTICE "pmc551: Unable to map IO space\n");
767                         kfree(mtd->priv);
768                         kfree(mtd);
769                         break;
770                 }
771 #ifdef CONFIG_MTD_PMC551_DEBUG
772                 printk(KERN_DEBUG "pmc551: setting aperture to %d\n",
773                         ffs(priv->asize >> 20) - 1);
774 #endif
775
776                 priv->base_map0 = (PMC551_PCI_MEM_MAP_REG_EN
777                                    | PMC551_PCI_MEM_MAP_ENABLE
778                                    | (ffs(priv->asize >> 20) - 1) << 4);
779                 priv->curr_map0 = priv->base_map0;
780                 pci_write_config_dword(priv->dev, PMC551_PCI_MEM_MAP0,
781                                         priv->curr_map0);
782
783 #ifdef CONFIG_MTD_PMC551_DEBUG
784                 printk(KERN_DEBUG "pmc551: aperture set to %d\n",
785                         (priv->base_map0 & 0xF0) >> 4);
786 #endif
787
788                 mtd->size = msize;
789                 mtd->flags = MTD_CAP_RAM;
790                 mtd->erase = pmc551_erase;
791                 mtd->read = pmc551_read;
792                 mtd->write = pmc551_write;
793                 mtd->point = pmc551_point;
794                 mtd->unpoint = pmc551_unpoint;
795                 mtd->type = MTD_RAM;
796                 mtd->name = "PMC551 RAM board";
797                 mtd->erasesize = 0x10000;
798                 mtd->writesize = 1;
799                 mtd->owner = THIS_MODULE;
800
801                 if (add_mtd_device(mtd)) {
802                         printk(KERN_NOTICE "pmc551: Failed to register new "
803                                 "device\n");
804                         pci_iounmap(PCI_Device, priv->start);
805                         kfree(mtd->priv);
806                         kfree(mtd);
807                         break;
808                 }
809
810                 /* Keep a reference as the add_mtd_device worked */
811                 pci_dev_get(PCI_Device);
812
813                 printk(KERN_NOTICE "Registered pmc551 memory device.\n");
814                 printk(KERN_NOTICE "Mapped %dM 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%c\n",
818                         (length < 1024) ? length :
819                         (length < 1048576) ? length >> 10 : length >> 20,
820                         (length < 1024) ? 'B' : (length < 1048576) ? 'K' : 'M');
821                 priv->nextpmc551 = pmc551list;
822                 pmc551list = mtd;
823                 found++;
824         }
825
826         /* Exited early, reference left over */
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  * PMC551 Card Cleanup
841  */
842 static 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 %dM 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
868 module_init(init_pmc551);
869 module_exit(cleanup_pmc551);