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