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