]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | |
2 | /* JEDEC Flash Interface. | |
3 | * This is an older type of interface for self programming flash. It is | |
4 | * commonly use in older AMD chips and is obsolete compared with CFI. | |
5 | * It is called JEDEC because the JEDEC association distributes the ID codes | |
6 | * for the chips. | |
7 | * | |
8 | * See the AMD flash databook for information on how to operate the interface. | |
9 | * | |
10 | * This code does not support anything wider than 8 bit flash chips, I am | |
11 | * not going to guess how to send commands to them, plus I expect they will | |
12 | * all speak CFI.. | |
13 | * | |
14 | * $Id: jedec.c,v 1.22 2005/01/05 18:05:11 dwmw2 Exp $ | |
15 | */ | |
16 | ||
17 | #include <linux/init.h> | |
18 | #include <linux/module.h> | |
19 | #include <linux/kernel.h> | |
4e57b681 | 20 | #include <linux/slab.h> |
1da177e4 LT |
21 | #include <linux/mtd/jedec.h> |
22 | #include <linux/mtd/map.h> | |
23 | #include <linux/mtd/mtd.h> | |
24 | #include <linux/mtd/compatmac.h> | |
25 | ||
26 | static struct mtd_info *jedec_probe(struct map_info *); | |
27 | static int jedec_probe8(struct map_info *map,unsigned long base, | |
28 | struct jedec_private *priv); | |
29 | static int jedec_probe16(struct map_info *map,unsigned long base, | |
30 | struct jedec_private *priv); | |
31 | static int jedec_probe32(struct map_info *map,unsigned long base, | |
32 | struct jedec_private *priv); | |
33 | static void jedec_flash_chip_scan(struct jedec_private *priv,unsigned long start, | |
34 | unsigned long len); | |
35 | static int flash_erase(struct mtd_info *mtd, struct erase_info *instr); | |
36 | static int flash_write(struct mtd_info *mtd, loff_t start, size_t len, | |
37 | size_t *retlen, const u_char *buf); | |
38 | ||
39 | static unsigned long my_bank_size; | |
40 | ||
41 | /* Listing of parts and sizes. We need this table to learn the sector | |
42 | size of the chip and the total length */ | |
43 | static const struct JEDECTable JEDEC_table[] = { | |
44 | { | |
45 | .jedec = 0x013D, | |
46 | .name = "AMD Am29F017D", | |
47 | .size = 2*1024*1024, | |
48 | .sectorsize = 64*1024, | |
49 | .capabilities = MTD_CAP_NORFLASH | |
50 | }, | |
51 | { | |
52 | .jedec = 0x01AD, | |
53 | .name = "AMD Am29F016", | |
54 | .size = 2*1024*1024, | |
55 | .sectorsize = 64*1024, | |
56 | .capabilities = MTD_CAP_NORFLASH | |
57 | }, | |
58 | { | |
59 | .jedec = 0x01D5, | |
60 | .name = "AMD Am29F080", | |
61 | .size = 1*1024*1024, | |
62 | .sectorsize = 64*1024, | |
63 | .capabilities = MTD_CAP_NORFLASH | |
64 | }, | |
65 | { | |
66 | .jedec = 0x01A4, | |
67 | .name = "AMD Am29F040", | |
68 | .size = 512*1024, | |
69 | .sectorsize = 64*1024, | |
70 | .capabilities = MTD_CAP_NORFLASH | |
71 | }, | |
72 | { | |
73 | .jedec = 0x20E3, | |
74 | .name = "AMD Am29W040B", | |
75 | .size = 512*1024, | |
76 | .sectorsize = 64*1024, | |
77 | .capabilities = MTD_CAP_NORFLASH | |
78 | }, | |
79 | { | |
80 | .jedec = 0xC2AD, | |
81 | .name = "Macronix MX29F016", | |
82 | .size = 2*1024*1024, | |
83 | .sectorsize = 64*1024, | |
84 | .capabilities = MTD_CAP_NORFLASH | |
85 | }, | |
86 | { .jedec = 0x0 } | |
87 | }; | |
88 | ||
89 | static const struct JEDECTable *jedec_idtoinf(__u8 mfr,__u8 id); | |
90 | static void jedec_sync(struct mtd_info *mtd) {}; | |
91 | static int jedec_read(struct mtd_info *mtd, loff_t from, size_t len, | |
92 | size_t *retlen, u_char *buf); | |
93 | static int jedec_read_banked(struct mtd_info *mtd, loff_t from, size_t len, | |
94 | size_t *retlen, u_char *buf); | |
95 | ||
96 | static struct mtd_info *jedec_probe(struct map_info *map); | |
97 | ||
98 | ||
99 | ||
100 | static struct mtd_chip_driver jedec_chipdrv = { | |
101 | .probe = jedec_probe, | |
102 | .name = "jedec", | |
103 | .module = THIS_MODULE | |
104 | }; | |
105 | ||
106 | /* Probe entry point */ | |
107 | ||
108 | static struct mtd_info *jedec_probe(struct map_info *map) | |
109 | { | |
110 | struct mtd_info *MTD; | |
111 | struct jedec_private *priv; | |
112 | unsigned long Base; | |
113 | unsigned long SectorSize; | |
114 | unsigned count; | |
115 | unsigned I,Uniq; | |
116 | char Part[200]; | |
117 | memset(&priv,0,sizeof(priv)); | |
118 | ||
119 | MTD = kmalloc(sizeof(struct mtd_info) + sizeof(struct jedec_private), GFP_KERNEL); | |
120 | if (!MTD) | |
121 | return NULL; | |
122 | ||
123 | memset(MTD, 0, sizeof(struct mtd_info) + sizeof(struct jedec_private)); | |
124 | priv = (struct jedec_private *)&MTD[1]; | |
125 | ||
126 | my_bank_size = map->size; | |
127 | ||
128 | if (map->size/my_bank_size > MAX_JEDEC_CHIPS) | |
129 | { | |
130 | printk("mtd: Increase MAX_JEDEC_CHIPS, too many banks.\n"); | |
131 | kfree(MTD); | |
132 | return NULL; | |
133 | } | |
134 | ||
135 | for (Base = 0; Base < map->size; Base += my_bank_size) | |
136 | { | |
137 | // Perhaps zero could designate all tests? | |
138 | if (map->buswidth == 0) | |
139 | map->buswidth = 1; | |
140 | ||
141 | if (map->buswidth == 1){ | |
142 | if (jedec_probe8(map,Base,priv) == 0) { | |
143 | printk("did recognize jedec chip\n"); | |
144 | kfree(MTD); | |
145 | return NULL; | |
146 | } | |
147 | } | |
148 | if (map->buswidth == 2) | |
149 | jedec_probe16(map,Base,priv); | |
150 | if (map->buswidth == 4) | |
151 | jedec_probe32(map,Base,priv); | |
152 | } | |
153 | ||
154 | // Get the biggest sector size | |
155 | SectorSize = 0; | |
156 | for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++) | |
157 | { | |
158 | // printk("priv->chips[%d].jedec is %x\n",I,priv->chips[I].jedec); | |
159 | // printk("priv->chips[%d].sectorsize is %lx\n",I,priv->chips[I].sectorsize); | |
160 | if (priv->chips[I].sectorsize > SectorSize) | |
161 | SectorSize = priv->chips[I].sectorsize; | |
162 | } | |
163 | ||
164 | // Quickly ensure that the other sector sizes are factors of the largest | |
165 | for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++) | |
166 | { | |
167 | if ((SectorSize/priv->chips[I].sectorsize)*priv->chips[I].sectorsize != SectorSize) | |
168 | { | |
169 | printk("mtd: Failed. Device has incompatible mixed sector sizes\n"); | |
170 | kfree(MTD); | |
171 | return NULL; | |
172 | } | |
173 | } | |
174 | ||
175 | /* Generate a part name that includes the number of different chips and | |
176 | other configuration information */ | |
177 | count = 1; | |
178 | strlcpy(Part,map->name,sizeof(Part)-10); | |
179 | strcat(Part," "); | |
180 | Uniq = 0; | |
181 | for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++) | |
182 | { | |
183 | const struct JEDECTable *JEDEC; | |
184 | ||
185 | if (priv->chips[I+1].jedec == priv->chips[I].jedec) | |
186 | { | |
187 | count++; | |
188 | continue; | |
189 | } | |
190 | ||
191 | // Locate the chip in the jedec table | |
192 | JEDEC = jedec_idtoinf(priv->chips[I].jedec >> 8,priv->chips[I].jedec); | |
193 | if (JEDEC == 0) | |
194 | { | |
195 | printk("mtd: Internal Error, JEDEC not set\n"); | |
196 | kfree(MTD); | |
197 | return NULL; | |
198 | } | |
199 | ||
200 | if (Uniq != 0) | |
201 | strcat(Part,","); | |
202 | Uniq++; | |
203 | ||
204 | if (count != 1) | |
205 | sprintf(Part+strlen(Part),"%x*[%s]",count,JEDEC->name); | |
206 | else | |
207 | sprintf(Part+strlen(Part),"%s",JEDEC->name); | |
208 | if (strlen(Part) > sizeof(Part)*2/3) | |
209 | break; | |
210 | count = 1; | |
211 | } | |
212 | ||
213 | /* Determine if the chips are organized in a linear fashion, or if there | |
214 | are empty banks. Note, the last bank does not count here, only the | |
215 | first banks are important. Holes on non-bank boundaries can not exist | |
216 | due to the way the detection algorithm works. */ | |
217 | if (priv->size < my_bank_size) | |
218 | my_bank_size = priv->size; | |
219 | priv->is_banked = 0; | |
220 | //printk("priv->size is %x, my_bank_size is %x\n",priv->size,my_bank_size); | |
221 | //printk("priv->bank_fill[0] is %x\n",priv->bank_fill[0]); | |
222 | if (!priv->size) { | |
223 | printk("priv->size is zero\n"); | |
224 | kfree(MTD); | |
225 | return NULL; | |
226 | } | |
227 | if (priv->size/my_bank_size) { | |
228 | if (priv->size/my_bank_size == 1) { | |
229 | priv->size = my_bank_size; | |
230 | } | |
231 | else { | |
232 | for (I = 0; I != priv->size/my_bank_size - 1; I++) | |
233 | { | |
234 | if (priv->bank_fill[I] != my_bank_size) | |
235 | priv->is_banked = 1; | |
236 | ||
237 | /* This even could be eliminated, but new de-optimized read/write | |
238 | functions have to be written */ | |
239 | printk("priv->bank_fill[%d] is %lx, priv->bank_fill[0] is %lx\n",I,priv->bank_fill[I],priv->bank_fill[0]); | |
240 | if (priv->bank_fill[I] != priv->bank_fill[0]) | |
241 | { | |
242 | printk("mtd: Failed. Cannot handle unsymmetric banking\n"); | |
243 | kfree(MTD); | |
244 | return NULL; | |
245 | } | |
246 | } | |
247 | } | |
248 | } | |
249 | if (priv->is_banked == 1) | |
250 | strcat(Part,", banked"); | |
251 | ||
252 | // printk("Part: '%s'\n",Part); | |
253 | ||
254 | memset(MTD,0,sizeof(*MTD)); | |
255 | // strlcpy(MTD->name,Part,sizeof(MTD->name)); | |
256 | MTD->name = map->name; | |
257 | MTD->type = MTD_NORFLASH; | |
258 | MTD->flags = MTD_CAP_NORFLASH; | |
259 | MTD->erasesize = SectorSize*(map->buswidth); | |
260 | // printk("MTD->erasesize is %x\n",(unsigned int)MTD->erasesize); | |
261 | MTD->size = priv->size; | |
262 | // printk("MTD->size is %x\n",(unsigned int)MTD->size); | |
263 | //MTD->module = THIS_MODULE; // ? Maybe this should be the low level module? | |
264 | MTD->erase = flash_erase; | |
265 | if (priv->is_banked == 1) | |
266 | MTD->read = jedec_read_banked; | |
267 | else | |
268 | MTD->read = jedec_read; | |
269 | MTD->write = flash_write; | |
270 | MTD->sync = jedec_sync; | |
271 | MTD->priv = map; | |
272 | map->fldrv_priv = priv; | |
273 | map->fldrv = &jedec_chipdrv; | |
274 | __module_get(THIS_MODULE); | |
275 | return MTD; | |
276 | } | |
277 | ||
278 | /* Helper for the JEDEC function, JEDEC numbers all have odd parity */ | |
279 | static int checkparity(u_char C) | |
280 | { | |
281 | u_char parity = 0; | |
282 | while (C != 0) | |
283 | { | |
284 | parity ^= C & 1; | |
285 | C >>= 1; | |
286 | } | |
287 | ||
288 | return parity == 1; | |
289 | } | |
290 | ||
291 | ||
292 | /* Take an array of JEDEC numbers that represent interleved flash chips | |
293 | and process them. Check to make sure they are good JEDEC numbers, look | |
294 | them up and then add them to the chip list */ | |
295 | static int handle_jedecs(struct map_info *map,__u8 *Mfg,__u8 *Id,unsigned Count, | |
296 | unsigned long base,struct jedec_private *priv) | |
297 | { | |
298 | unsigned I,J; | |
299 | unsigned long Size; | |
300 | unsigned long SectorSize; | |
301 | const struct JEDECTable *JEDEC; | |
302 | ||
303 | // Test #2 JEDEC numbers exhibit odd parity | |
304 | for (I = 0; I != Count; I++) | |
305 | { | |
306 | if (checkparity(Mfg[I]) == 0 || checkparity(Id[I]) == 0) | |
307 | return 0; | |
308 | } | |
309 | ||
310 | // Finally, just make sure all the chip sizes are the same | |
311 | JEDEC = jedec_idtoinf(Mfg[0],Id[0]); | |
312 | ||
313 | if (JEDEC == 0) | |
314 | { | |
315 | printk("mtd: Found JEDEC flash chip, but do not have a table entry for %x:%x\n",Mfg[0],Mfg[1]); | |
316 | return 0; | |
317 | } | |
318 | ||
319 | Size = JEDEC->size; | |
320 | SectorSize = JEDEC->sectorsize; | |
321 | for (I = 0; I != Count; I++) | |
322 | { | |
323 | JEDEC = jedec_idtoinf(Mfg[0],Id[0]); | |
324 | if (JEDEC == 0) | |
325 | { | |
326 | printk("mtd: Found JEDEC flash chip, but do not have a table entry for %x:%x\n",Mfg[0],Mfg[1]); | |
327 | return 0; | |
328 | } | |
329 | ||
330 | if (Size != JEDEC->size || SectorSize != JEDEC->sectorsize) | |
331 | { | |
332 | printk("mtd: Failed. Interleved flash does not have matching characteristics\n"); | |
333 | return 0; | |
334 | } | |
335 | } | |
336 | ||
337 | // Load the Chips | |
338 | for (I = 0; I != MAX_JEDEC_CHIPS; I++) | |
339 | { | |
340 | if (priv->chips[I].jedec == 0) | |
341 | break; | |
342 | } | |
343 | ||
344 | if (I + Count > MAX_JEDEC_CHIPS) | |
345 | { | |
346 | printk("mtd: Device has too many chips. Increase MAX_JEDEC_CHIPS\n"); | |
347 | return 0; | |
348 | } | |
349 | ||
350 | // Add them to the table | |
351 | for (J = 0; J != Count; J++) | |
352 | { | |
353 | unsigned long Bank; | |
354 | ||
355 | JEDEC = jedec_idtoinf(Mfg[J],Id[J]); | |
356 | priv->chips[I].jedec = (Mfg[J] << 8) | Id[J]; | |
357 | priv->chips[I].size = JEDEC->size; | |
358 | priv->chips[I].sectorsize = JEDEC->sectorsize; | |
359 | priv->chips[I].base = base + J; | |
360 | priv->chips[I].datashift = J*8; | |
361 | priv->chips[I].capabilities = JEDEC->capabilities; | |
362 | priv->chips[I].offset = priv->size + J; | |
363 | ||
364 | // log2 n :| | |
365 | priv->chips[I].addrshift = 0; | |
366 | for (Bank = Count; Bank != 1; Bank >>= 1, priv->chips[I].addrshift++); | |
367 | ||
368 | // Determine how filled this bank is. | |
369 | Bank = base & (~(my_bank_size-1)); | |
370 | if (priv->bank_fill[Bank/my_bank_size] < base + | |
371 | (JEDEC->size << priv->chips[I].addrshift) - Bank) | |
372 | priv->bank_fill[Bank/my_bank_size] = base + (JEDEC->size << priv->chips[I].addrshift) - Bank; | |
373 | I++; | |
374 | } | |
375 | ||
376 | priv->size += priv->chips[I-1].size*Count; | |
377 | ||
378 | return priv->chips[I-1].size; | |
379 | } | |
380 | ||
381 | /* Lookup the chip information from the JEDEC ID table. */ | |
382 | static const struct JEDECTable *jedec_idtoinf(__u8 mfr,__u8 id) | |
383 | { | |
384 | __u16 Id = (mfr << 8) | id; | |
385 | unsigned long I = 0; | |
386 | for (I = 0; JEDEC_table[I].jedec != 0; I++) | |
387 | if (JEDEC_table[I].jedec == Id) | |
388 | return JEDEC_table + I; | |
389 | return NULL; | |
390 | } | |
391 | ||
392 | // Look for flash using an 8 bit bus interface | |
393 | static int jedec_probe8(struct map_info *map,unsigned long base, | |
394 | struct jedec_private *priv) | |
395 | { | |
396 | #define flread(x) map_read8(map,base+x) | |
397 | #define flwrite(v,x) map_write8(map,v,base+x) | |
398 | ||
399 | const unsigned long AutoSel1 = 0xAA; | |
400 | const unsigned long AutoSel2 = 0x55; | |
401 | const unsigned long AutoSel3 = 0x90; | |
402 | const unsigned long Reset = 0xF0; | |
403 | __u32 OldVal; | |
404 | __u8 Mfg[1]; | |
405 | __u8 Id[1]; | |
406 | unsigned I; | |
407 | unsigned long Size; | |
408 | ||
409 | // Wait for any write/erase operation to settle | |
410 | OldVal = flread(base); | |
411 | for (I = 0; OldVal != flread(base) && I < 10000; I++) | |
412 | OldVal = flread(base); | |
413 | ||
414 | // Reset the chip | |
415 | flwrite(Reset,0x555); | |
416 | ||
417 | // Send the sequence | |
418 | flwrite(AutoSel1,0x555); | |
419 | flwrite(AutoSel2,0x2AA); | |
420 | flwrite(AutoSel3,0x555); | |
421 | ||
422 | // Get the JEDEC numbers | |
423 | Mfg[0] = flread(0); | |
424 | Id[0] = flread(1); | |
425 | // printk("Mfg is %x, Id is %x\n",Mfg[0],Id[0]); | |
426 | ||
427 | Size = handle_jedecs(map,Mfg,Id,1,base,priv); | |
428 | // printk("handle_jedecs Size is %x\n",(unsigned int)Size); | |
429 | if (Size == 0) | |
430 | { | |
431 | flwrite(Reset,0x555); | |
432 | return 0; | |
433 | } | |
434 | ||
435 | ||
436 | // Reset. | |
437 | flwrite(Reset,0x555); | |
438 | ||
439 | return 1; | |
440 | ||
441 | #undef flread | |
442 | #undef flwrite | |
443 | } | |
444 | ||
445 | // Look for flash using a 16 bit bus interface (ie 2 8-bit chips) | |
446 | static int jedec_probe16(struct map_info *map,unsigned long base, | |
447 | struct jedec_private *priv) | |
448 | { | |
449 | return 0; | |
450 | } | |
451 | ||
452 | // Look for flash using a 32 bit bus interface (ie 4 8-bit chips) | |
453 | static int jedec_probe32(struct map_info *map,unsigned long base, | |
454 | struct jedec_private *priv) | |
455 | { | |
456 | #define flread(x) map_read32(map,base+((x)<<2)) | |
457 | #define flwrite(v,x) map_write32(map,v,base+((x)<<2)) | |
458 | ||
459 | const unsigned long AutoSel1 = 0xAAAAAAAA; | |
460 | const unsigned long AutoSel2 = 0x55555555; | |
461 | const unsigned long AutoSel3 = 0x90909090; | |
462 | const unsigned long Reset = 0xF0F0F0F0; | |
463 | __u32 OldVal; | |
464 | __u8 Mfg[4]; | |
465 | __u8 Id[4]; | |
466 | unsigned I; | |
467 | unsigned long Size; | |
468 | ||
469 | // Wait for any write/erase operation to settle | |
470 | OldVal = flread(base); | |
471 | for (I = 0; OldVal != flread(base) && I < 10000; I++) | |
472 | OldVal = flread(base); | |
473 | ||
474 | // Reset the chip | |
475 | flwrite(Reset,0x555); | |
476 | ||
477 | // Send the sequence | |
478 | flwrite(AutoSel1,0x555); | |
479 | flwrite(AutoSel2,0x2AA); | |
480 | flwrite(AutoSel3,0x555); | |
481 | ||
482 | // Test #1, JEDEC numbers are readable from 0x??00/0x??01 | |
483 | if (flread(0) != flread(0x100) || | |
484 | flread(1) != flread(0x101)) | |
485 | { | |
486 | flwrite(Reset,0x555); | |
487 | return 0; | |
488 | } | |
489 | ||
490 | // Split up the JEDEC numbers | |
491 | OldVal = flread(0); | |
492 | for (I = 0; I != 4; I++) | |
493 | Mfg[I] = (OldVal >> (I*8)); | |
494 | OldVal = flread(1); | |
495 | for (I = 0; I != 4; I++) | |
496 | Id[I] = (OldVal >> (I*8)); | |
497 | ||
498 | Size = handle_jedecs(map,Mfg,Id,4,base,priv); | |
499 | if (Size == 0) | |
500 | { | |
501 | flwrite(Reset,0x555); | |
502 | return 0; | |
503 | } | |
504 | ||
505 | /* Check if there is address wrap around within a single bank, if this | |
506 | returns JEDEC numbers then we assume that it is wrap around. Notice | |
507 | we call this routine with the JEDEC return still enabled, if two or | |
508 | more flashes have a truncated address space the probe test will still | |
509 | work */ | |
510 | if (base + (Size<<2)+0x555 < map->size && | |
511 | base + (Size<<2)+0x555 < (base & (~(my_bank_size-1))) + my_bank_size) | |
512 | { | |
513 | if (flread(base+Size) != flread(base+Size + 0x100) || | |
514 | flread(base+Size + 1) != flread(base+Size + 0x101)) | |
515 | { | |
516 | jedec_probe32(map,base+Size,priv); | |
517 | } | |
518 | } | |
519 | ||
520 | // Reset. | |
521 | flwrite(0xF0F0F0F0,0x555); | |
522 | ||
523 | return 1; | |
524 | ||
525 | #undef flread | |
526 | #undef flwrite | |
527 | } | |
528 | ||
529 | /* Linear read. */ | |
530 | static int jedec_read(struct mtd_info *mtd, loff_t from, size_t len, | |
531 | size_t *retlen, u_char *buf) | |
532 | { | |
533 | struct map_info *map = mtd->priv; | |
534 | ||
535 | map_copy_from(map, buf, from, len); | |
536 | *retlen = len; | |
537 | return 0; | |
538 | } | |
539 | ||
540 | /* Banked read. Take special care to jump past the holes in the bank | |
541 | mapping. This version assumes symetry in the holes.. */ | |
542 | static int jedec_read_banked(struct mtd_info *mtd, loff_t from, size_t len, | |
543 | size_t *retlen, u_char *buf) | |
544 | { | |
545 | struct map_info *map = mtd->priv; | |
546 | struct jedec_private *priv = map->fldrv_priv; | |
547 | ||
548 | *retlen = 0; | |
549 | while (len > 0) | |
550 | { | |
551 | // Determine what bank and offset into that bank the first byte is | |
552 | unsigned long bank = from & (~(priv->bank_fill[0]-1)); | |
553 | unsigned long offset = from & (priv->bank_fill[0]-1); | |
554 | unsigned long get = len; | |
555 | if (priv->bank_fill[0] - offset < len) | |
556 | get = priv->bank_fill[0] - offset; | |
557 | ||
558 | bank /= priv->bank_fill[0]; | |
559 | map_copy_from(map,buf + *retlen,bank*my_bank_size + offset,get); | |
560 | ||
561 | len -= get; | |
562 | *retlen += get; | |
563 | from += get; | |
564 | } | |
565 | return 0; | |
566 | } | |
567 | ||
568 | /* Pass the flags value that the flash return before it re-entered read | |
569 | mode. */ | |
570 | static void jedec_flash_failed(unsigned char code) | |
571 | { | |
572 | /* Bit 5 being high indicates that there was an internal device | |
573 | failure, erasure time limits exceeded or something */ | |
574 | if ((code & (1 << 5)) != 0) | |
575 | { | |
576 | printk("mtd: Internal Flash failure\n"); | |
577 | return; | |
578 | } | |
579 | printk("mtd: Programming didn't take\n"); | |
580 | } | |
581 | ||
582 | /* This uses the erasure function described in the AMD Flash Handbook, | |
583 | it will work for flashes with a fixed sector size only. Flashes with | |
584 | a selection of sector sizes (ie the AMD Am29F800B) will need a different | |
585 | routine. This routine tries to parallize erasing multiple chips/sectors | |
586 | where possible */ | |
587 | static int flash_erase(struct mtd_info *mtd, struct erase_info *instr) | |
588 | { | |
589 | // Does IO to the currently selected chip | |
590 | #define flread(x) map_read8(map,chip->base+((x)<<chip->addrshift)) | |
591 | #define flwrite(v,x) map_write8(map,v,chip->base+((x)<<chip->addrshift)) | |
592 | ||
593 | unsigned long Time = 0; | |
594 | unsigned long NoTime = 0; | |
595 | unsigned long start = instr->addr, len = instr->len; | |
596 | unsigned int I; | |
597 | struct map_info *map = mtd->priv; | |
598 | struct jedec_private *priv = map->fldrv_priv; | |
599 | ||
600 | // Verify the arguments.. | |
601 | if (start + len > mtd->size || | |
602 | (start % mtd->erasesize) != 0 || | |
603 | (len % mtd->erasesize) != 0 || | |
604 | (len/mtd->erasesize) == 0) | |
605 | return -EINVAL; | |
606 | ||
607 | jedec_flash_chip_scan(priv,start,len); | |
608 | ||
609 | // Start the erase sequence on each chip | |
610 | for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++) | |
611 | { | |
612 | unsigned long off; | |
613 | struct jedec_flash_chip *chip = priv->chips + I; | |
614 | ||
615 | if (chip->length == 0) | |
616 | continue; | |
617 | ||
618 | if (chip->start + chip->length > chip->size) | |
619 | { | |
620 | printk("DIE\n"); | |
621 | return -EIO; | |
622 | } | |
623 | ||
624 | flwrite(0xF0,chip->start + 0x555); | |
625 | flwrite(0xAA,chip->start + 0x555); | |
626 | flwrite(0x55,chip->start + 0x2AA); | |
627 | flwrite(0x80,chip->start + 0x555); | |
628 | flwrite(0xAA,chip->start + 0x555); | |
629 | flwrite(0x55,chip->start + 0x2AA); | |
630 | ||
631 | /* Once we start selecting the erase sectors the delay between each | |
632 | command must not exceed 50us or it will immediately start erasing | |
633 | and ignore the other sectors */ | |
634 | for (off = 0; off < len; off += chip->sectorsize) | |
635 | { | |
636 | // Check to make sure we didn't timeout | |
637 | flwrite(0x30,chip->start + off); | |
638 | if (off == 0) | |
639 | continue; | |
640 | if ((flread(chip->start + off) & (1 << 3)) != 0) | |
641 | { | |
642 | printk("mtd: Ack! We timed out the erase timer!\n"); | |
643 | return -EIO; | |
644 | } | |
645 | } | |
646 | } | |
647 | ||
648 | /* We could split this into a timer routine and return early, performing | |
649 | background erasure.. Maybe later if the need warrents */ | |
650 | ||
651 | /* Poll the flash for erasure completion, specs say this can take as long | |
652 | as 480 seconds to do all the sectors (for a 2 meg flash). | |
653 | Erasure time is dependent on chip age, temp and wear.. */ | |
654 | ||
655 | /* This being a generic routine assumes a 32 bit bus. It does read32s | |
656 | and bundles interleved chips into the same grouping. This will work | |
657 | for all bus widths */ | |
658 | Time = 0; | |
659 | NoTime = 0; | |
660 | for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++) | |
661 | { | |
662 | struct jedec_flash_chip *chip = priv->chips + I; | |
663 | unsigned long off = 0; | |
664 | unsigned todo[4] = {0,0,0,0}; | |
665 | unsigned todo_left = 0; | |
666 | unsigned J; | |
667 | ||
668 | if (chip->length == 0) | |
669 | continue; | |
670 | ||
671 | /* Find all chips in this data line, realistically this is all | |
672 | or nothing up to the interleve count */ | |
673 | for (J = 0; priv->chips[J].jedec != 0 && J < MAX_JEDEC_CHIPS; J++) | |
674 | { | |
675 | if ((priv->chips[J].base & (~((1<<chip->addrshift)-1))) == | |
676 | (chip->base & (~((1<<chip->addrshift)-1)))) | |
677 | { | |
678 | todo_left++; | |
679 | todo[priv->chips[J].base & ((1<<chip->addrshift)-1)] = 1; | |
680 | } | |
681 | } | |
682 | ||
683 | /* printk("todo: %x %x %x %x\n",(short)todo[0],(short)todo[1], | |
684 | (short)todo[2],(short)todo[3]); | |
685 | */ | |
686 | while (1) | |
687 | { | |
688 | __u32 Last[4]; | |
689 | unsigned long Count = 0; | |
690 | ||
691 | /* During erase bit 7 is held low and bit 6 toggles, we watch this, | |
692 | should it stop toggling or go high then the erase is completed, | |
693 | or this is not really flash ;> */ | |
694 | switch (map->buswidth) { | |
695 | case 1: | |
696 | Last[0] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off); | |
697 | Last[1] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off); | |
698 | Last[2] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off); | |
699 | break; | |
700 | case 2: | |
701 | Last[0] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off); | |
702 | Last[1] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off); | |
703 | Last[2] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off); | |
704 | break; | |
705 | case 3: | |
706 | Last[0] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off); | |
707 | Last[1] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off); | |
708 | Last[2] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off); | |
709 | break; | |
710 | } | |
711 | Count = 3; | |
712 | while (todo_left != 0) | |
713 | { | |
714 | for (J = 0; J != 4; J++) | |
715 | { | |
716 | __u8 Byte1 = (Last[(Count-1)%4] >> (J*8)) & 0xFF; | |
717 | __u8 Byte2 = (Last[(Count-2)%4] >> (J*8)) & 0xFF; | |
718 | __u8 Byte3 = (Last[(Count-3)%4] >> (J*8)) & 0xFF; | |
719 | if (todo[J] == 0) | |
720 | continue; | |
721 | ||
722 | if ((Byte1 & (1 << 7)) == 0 && Byte1 != Byte2) | |
723 | { | |
724 | // printk("Check %x %x %x\n",(short)J,(short)Byte1,(short)Byte2); | |
725 | continue; | |
726 | } | |
727 | ||
728 | if (Byte1 == Byte2) | |
729 | { | |
730 | jedec_flash_failed(Byte3); | |
731 | return -EIO; | |
732 | } | |
733 | ||
734 | todo[J] = 0; | |
735 | todo_left--; | |
736 | } | |
737 | ||
738 | /* if (NoTime == 0) | |
739 | Time += HZ/10 - schedule_timeout(HZ/10);*/ | |
740 | NoTime = 0; | |
741 | ||
742 | switch (map->buswidth) { | |
743 | case 1: | |
744 | Last[Count % 4] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off); | |
745 | break; | |
746 | case 2: | |
747 | Last[Count % 4] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off); | |
748 | break; | |
749 | case 4: | |
750 | Last[Count % 4] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off); | |
751 | break; | |
752 | } | |
753 | Count++; | |
754 | ||
755 | /* // Count time, max of 15s per sector (according to AMD) | |
756 | if (Time > 15*len/mtd->erasesize*HZ) | |
757 | { | |
758 | printk("mtd: Flash Erase Timed out\n"); | |
759 | return -EIO; | |
760 | } */ | |
761 | } | |
762 | ||
763 | // Skip to the next chip if we used chip erase | |
764 | if (chip->length == chip->size) | |
765 | off = chip->size; | |
766 | else | |
767 | off += chip->sectorsize; | |
768 | ||
769 | if (off >= chip->length) | |
770 | break; | |
771 | NoTime = 1; | |
772 | } | |
773 | ||
774 | for (J = 0; priv->chips[J].jedec != 0 && J < MAX_JEDEC_CHIPS; J++) | |
775 | { | |
776 | if ((priv->chips[J].base & (~((1<<chip->addrshift)-1))) == | |
777 | (chip->base & (~((1<<chip->addrshift)-1)))) | |
778 | priv->chips[J].length = 0; | |
779 | } | |
780 | } | |
781 | ||
782 | //printk("done\n"); | |
783 | instr->state = MTD_ERASE_DONE; | |
784 | mtd_erase_callback(instr); | |
785 | return 0; | |
786 | ||
787 | #undef flread | |
788 | #undef flwrite | |
789 | } | |
790 | ||
791 | /* This is the simple flash writing function. It writes to every byte, in | |
792 | sequence. It takes care of how to properly address the flash if | |
793 | the flash is interleved. It can only be used if all the chips in the | |
794 | array are identical!*/ | |
795 | static int flash_write(struct mtd_info *mtd, loff_t start, size_t len, | |
796 | size_t *retlen, const u_char *buf) | |
797 | { | |
798 | /* Does IO to the currently selected chip. It takes the bank addressing | |
799 | base (which is divisible by the chip size) adds the necessary lower bits | |
800 | of addrshift (interleave index) and then adds the control register index. */ | |
801 | #define flread(x) map_read8(map,base+(off&((1<<chip->addrshift)-1))+((x)<<chip->addrshift)) | |
802 | #define flwrite(v,x) map_write8(map,v,base+(off&((1<<chip->addrshift)-1))+((x)<<chip->addrshift)) | |
803 | ||
804 | struct map_info *map = mtd->priv; | |
805 | struct jedec_private *priv = map->fldrv_priv; | |
806 | unsigned long base; | |
807 | unsigned long off; | |
808 | size_t save_len = len; | |
809 | ||
810 | if (start + len > mtd->size) | |
811 | return -EIO; | |
812 | ||
813 | //printk("Here"); | |
814 | ||
815 | //printk("flash_write: start is %x, len is %x\n",start,(unsigned long)len); | |
816 | while (len != 0) | |
817 | { | |
818 | struct jedec_flash_chip *chip = priv->chips; | |
819 | unsigned long bank; | |
820 | unsigned long boffset; | |
821 | ||
822 | // Compute the base of the flash. | |
823 | off = ((unsigned long)start) % (chip->size << chip->addrshift); | |
824 | base = start - off; | |
825 | ||
826 | // Perform banked addressing translation. | |
827 | bank = base & (~(priv->bank_fill[0]-1)); | |
828 | boffset = base & (priv->bank_fill[0]-1); | |
829 | bank = (bank/priv->bank_fill[0])*my_bank_size; | |
830 | base = bank + boffset; | |
831 | ||
832 | // printk("Flasing %X %X %X\n",base,chip->size,len); | |
833 | // printk("off is %x, compare with %x\n",off,chip->size << chip->addrshift); | |
834 | ||
835 | // Loop over this page | |
836 | for (; off != (chip->size << chip->addrshift) && len != 0; start++, len--, off++,buf++) | |
837 | { | |
838 | unsigned char oldbyte = map_read8(map,base+off); | |
839 | unsigned char Last[4]; | |
840 | unsigned long Count = 0; | |
841 | ||
842 | if (oldbyte == *buf) { | |
843 | // printk("oldbyte and *buf is %x,len is %x\n",oldbyte,len); | |
844 | continue; | |
845 | } | |
846 | if (((~oldbyte) & *buf) != 0) | |
847 | printk("mtd: warn: Trying to set a 0 to a 1\n"); | |
848 | ||
849 | // Write | |
850 | flwrite(0xAA,0x555); | |
851 | flwrite(0x55,0x2AA); | |
852 | flwrite(0xA0,0x555); | |
853 | map_write8(map,*buf,base + off); | |
854 | Last[0] = map_read8(map,base + off); | |
855 | Last[1] = map_read8(map,base + off); | |
856 | Last[2] = map_read8(map,base + off); | |
857 | ||
858 | /* Wait for the flash to finish the operation. We store the last 4 | |
859 | status bytes that have been retrieved so we can determine why | |
860 | it failed. The toggle bits keep toggling when there is a | |
861 | failure */ | |
862 | for (Count = 3; Last[(Count - 1) % 4] != Last[(Count - 2) % 4] && | |
863 | Count < 10000; Count++) | |
864 | Last[Count % 4] = map_read8(map,base + off); | |
865 | if (Last[(Count - 1) % 4] != *buf) | |
866 | { | |
867 | jedec_flash_failed(Last[(Count - 3) % 4]); | |
868 | return -EIO; | |
869 | } | |
870 | } | |
871 | } | |
872 | *retlen = save_len; | |
873 | return 0; | |
874 | } | |
875 | ||
876 | /* This is used to enhance the speed of the erase routine, | |
877 | when things are being done to multiple chips it is possible to | |
878 | parallize the operations, particularly full memory erases of multi | |
879 | chip memories benifit */ | |
880 | static void jedec_flash_chip_scan(struct jedec_private *priv,unsigned long start, | |
881 | unsigned long len) | |
882 | { | |
883 | unsigned int I; | |
884 | ||
885 | // Zero the records | |
886 | for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++) | |
887 | priv->chips[I].start = priv->chips[I].length = 0; | |
888 | ||
889 | // Intersect the region with each chip | |
890 | for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++) | |
891 | { | |
892 | struct jedec_flash_chip *chip = priv->chips + I; | |
893 | unsigned long ByteStart; | |
894 | unsigned long ChipEndByte = chip->offset + (chip->size << chip->addrshift); | |
895 | ||
896 | // End is before this chip or the start is after it | |
897 | if (start+len < chip->offset || | |
898 | ChipEndByte - (1 << chip->addrshift) < start) | |
899 | continue; | |
900 | ||
901 | if (start < chip->offset) | |
902 | { | |
903 | ByteStart = chip->offset; | |
904 | chip->start = 0; | |
905 | } | |
906 | else | |
907 | { | |
908 | chip->start = (start - chip->offset + (1 << chip->addrshift)-1) >> chip->addrshift; | |
909 | ByteStart = start; | |
910 | } | |
911 | ||
912 | if (start + len >= ChipEndByte) | |
913 | chip->length = (ChipEndByte - ByteStart) >> chip->addrshift; | |
914 | else | |
915 | chip->length = (start + len - ByteStart + (1 << chip->addrshift)-1) >> chip->addrshift; | |
916 | } | |
917 | } | |
918 | ||
919 | int __init jedec_init(void) | |
920 | { | |
921 | register_mtd_chip_driver(&jedec_chipdrv); | |
922 | return 0; | |
923 | } | |
924 | ||
925 | static void __exit jedec_exit(void) | |
926 | { | |
927 | unregister_mtd_chip_driver(&jedec_chipdrv); | |
928 | } | |
929 | ||
930 | module_init(jedec_init); | |
931 | module_exit(jedec_exit); | |
932 | ||
933 | MODULE_LICENSE("GPL"); | |
934 | MODULE_AUTHOR("Jason Gunthorpe <jgg@deltatee.com> et al."); | |
935 | MODULE_DESCRIPTION("Old MTD chip driver for JEDEC-compliant flash chips"); |