Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/*
2 * MTD chip driver for pre-CFI Sharp flash chips
3 *
4 * Copyright 2000,2001 David A. Schleef <ds@schleef.org>
5 * 2000,2001 Lineo, Inc.
6 *
7 * $Id: sharp.c,v 1.17 2005/11/29 14:28:28 gleixner Exp $
8 *
9 * Devices supported:
10 * LH28F016SCT Symmetrical block flash memory, 2Mx8
11 * LH28F008SCT Symmetrical block flash memory, 1Mx8
12 *
13 * Documentation:
14 * http://www.sharpmeg.com/datasheets/memic/flashcmp/
15 * http://www.sharpmeg.com/datasheets/memic/flashcmp/01symf/16m/016sctl9.pdf
16 * 016sctl9.pdf
17 *
18 * Limitations:
19 * This driver only supports 4x1 arrangement of chips.
20 * Not tested on anything but PowerPC.
21 */
22
23#include <linux/kernel.h>
24#include <linux/module.h>
25#include <linux/types.h>
26#include <linux/sched.h>
27#include <linux/errno.h>
28#include <linux/interrupt.h>
29#include <linux/mtd/map.h>
30#include <linux/mtd/mtd.h>
31#include <linux/mtd/cfi.h>
32#include <linux/delay.h>
33#include <linux/init.h>
34#include <linux/slab.h>
35
36#define CMD_RESET 0xffffffff
37#define CMD_READ_ID 0x90909090
38#define CMD_READ_STATUS 0x70707070
39#define CMD_CLEAR_STATUS 0x50505050
40#define CMD_BLOCK_ERASE_1 0x20202020
41#define CMD_BLOCK_ERASE_2 0xd0d0d0d0
42#define CMD_BYTE_WRITE 0x40404040
43#define CMD_SUSPEND 0xb0b0b0b0
44#define CMD_RESUME 0xd0d0d0d0
45#define CMD_SET_BLOCK_LOCK_1 0x60606060
46#define CMD_SET_BLOCK_LOCK_2 0x01010101
47#define CMD_SET_MASTER_LOCK_1 0x60606060
48#define CMD_SET_MASTER_LOCK_2 0xf1f1f1f1
49#define CMD_CLEAR_BLOCK_LOCKS_1 0x60606060
50#define CMD_CLEAR_BLOCK_LOCKS_2 0xd0d0d0d0
51
52#define SR_READY 0x80808080 // 1 = ready
53#define SR_ERASE_SUSPEND 0x40404040 // 1 = block erase suspended
54#define SR_ERROR_ERASE 0x20202020 // 1 = error in block erase or clear lock bits
55#define SR_ERROR_WRITE 0x10101010 // 1 = error in byte write or set lock bit
56#define SR_VPP 0x08080808 // 1 = Vpp is low
57#define SR_WRITE_SUSPEND 0x04040404 // 1 = byte write suspended
58#define SR_PROTECT 0x02020202 // 1 = lock bit set
59#define SR_RESERVED 0x01010101
60
61#define SR_ERRORS (SR_ERROR_ERASE|SR_ERROR_WRITE|SR_VPP|SR_PROTECT)
62
63/* Configuration options */
64
65#undef AUTOUNLOCK /* automatically unlocks blocks before erasing */
66
67struct mtd_info *sharp_probe(struct map_info *);
68
69static int sharp_probe_map(struct map_info *map,struct mtd_info *mtd);
70
71static int sharp_read(struct mtd_info *mtd, loff_t from, size_t len,
72 size_t *retlen, u_char *buf);
73static int sharp_write(struct mtd_info *mtd, loff_t from, size_t len,
74 size_t *retlen, const u_char *buf);
75static int sharp_erase(struct mtd_info *mtd, struct erase_info *instr);
76static void sharp_sync(struct mtd_info *mtd);
77static int sharp_suspend(struct mtd_info *mtd);
78static void sharp_resume(struct mtd_info *mtd);
79static void sharp_destroy(struct mtd_info *mtd);
80
81static int sharp_write_oneword(struct map_info *map, struct flchip *chip,
82 unsigned long adr, __u32 datum);
83static int sharp_erase_oneblock(struct map_info *map, struct flchip *chip,
84 unsigned long adr);
85#ifdef AUTOUNLOCK
86static void sharp_unlock_oneblock(struct map_info *map, struct flchip *chip,
87 unsigned long adr);
88#endif
89
90
91struct sharp_info{
92 struct flchip *chip;
93 int bogus;
94 int chipshift;
95 int numchips;
96 struct flchip chips[1];
97};
98
99struct mtd_info *sharp_probe(struct map_info *map);
100static void sharp_destroy(struct mtd_info *mtd);
101
102static struct mtd_chip_driver sharp_chipdrv = {
103 .probe = sharp_probe,
104 .destroy = sharp_destroy,
105 .name = "sharp",
106 .module = THIS_MODULE
107};
108
109
110struct mtd_info *sharp_probe(struct map_info *map)
111{
112 struct mtd_info *mtd = NULL;
113 struct sharp_info *sharp = NULL;
114 int width;
115
116 mtd = kmalloc(sizeof(*mtd), GFP_KERNEL);
117 if(!mtd)
118 return NULL;
119
120 sharp = kmalloc(sizeof(*sharp), GFP_KERNEL);
121 if(!sharp) {
122 kfree(mtd);
123 return NULL;
124 }
125
126 memset(mtd, 0, sizeof(*mtd));
127
128 width = sharp_probe_map(map,mtd);
129 if(!width){
130 kfree(mtd);
131 kfree(sharp);
132 return NULL;
133 }
134
135 mtd->priv = map;
136 mtd->type = MTD_NORFLASH;
137 mtd->erase = sharp_erase;
138 mtd->read = sharp_read;
139 mtd->write = sharp_write;
140 mtd->sync = sharp_sync;
141 mtd->suspend = sharp_suspend;
142 mtd->resume = sharp_resume;
143 mtd->flags = MTD_CAP_NORFLASH;
144 mtd->name = map->name;
145
146 memset(sharp, 0, sizeof(*sharp));
147 sharp->chipshift = 23;
148 sharp->numchips = 1;
149 sharp->chips[0].start = 0;
150 sharp->chips[0].state = FL_READY;
151 sharp->chips[0].mutex = &sharp->chips[0]._spinlock;
152 sharp->chips[0].word_write_time = 0;
153 init_waitqueue_head(&sharp->chips[0].wq);
154 spin_lock_init(&sharp->chips[0]._spinlock);
155
156 map->fldrv = &sharp_chipdrv;
157 map->fldrv_priv = sharp;
158
159 __module_get(THIS_MODULE);
160 return mtd;
161}
162
163static inline void sharp_send_cmd(struct map_info *map, unsigned long cmd, unsigned long adr)
164{
165 map_word map_cmd;
166 map_cmd.x[0] = cmd;
167 map_write(map, map_cmd, adr);
168}
169
170static int sharp_probe_map(struct map_info *map,struct mtd_info *mtd)
171{
172 map_word tmp, read0, read4;
173 unsigned long base = 0;
174 int width = 4;
175
176 tmp = map_read(map, base+0);
177
178 sharp_send_cmd(map, CMD_READ_ID, base+0);
179
180 read0 = map_read(map, base+0);
181 read4 = map_read(map, base+4);
182 if(read0.x[0] == 0x89898989){
183 printk("Looks like sharp flash\n");
184 switch(read4.x[0]){
185 case 0xaaaaaaaa:
186 case 0xa0a0a0a0:
187 /* aa - LH28F016SCT-L95 2Mx8, 32 64k blocks*/
188 /* a0 - LH28F016SCT-Z4 2Mx8, 32 64k blocks*/
189 mtd->erasesize = 0x10000 * width;
190 mtd->size = 0x200000 * width;
191 return width;
192 case 0xa6a6a6a6:
193 /* a6 - LH28F008SCT-L12 1Mx8, 16 64k blocks*/
194 /* a6 - LH28F008SCR-L85 1Mx8, 16 64k blocks*/
195 mtd->erasesize = 0x10000 * width;
196 mtd->size = 0x100000 * width;
197 return width;
198#if 0
199 case 0x00000000: /* unknown */
200 /* XX - LH28F004SCT 512kx8, 8 64k blocks*/
201 mtd->erasesize = 0x10000 * width;
202 mtd->size = 0x80000 * width;
203 return width;
204#endif
205 default:
206 printk("Sort-of looks like sharp flash, 0x%08lx 0x%08lx\n",
207 read0.x[0], read4.x[0]);
208 }
209 }else if((map_read(map, base+0).x[0] == CMD_READ_ID)){
210 /* RAM, probably */
211 printk("Looks like RAM\n");
212 map_write(map, tmp, base+0);
213 }else{
214 printk("Doesn't look like sharp flash, 0x%08lx 0x%08lx\n",
215 read0.x[0], read4.x[0]);
216 }
217
218 return 0;
219}
220
221/* This function returns with the chip->mutex lock held. */
222static int sharp_wait(struct map_info *map, struct flchip *chip)
223{
224 int i;
225 map_word status;
226 unsigned long timeo = jiffies + HZ;
227 DECLARE_WAITQUEUE(wait, current);
228 int adr = 0;
229
230retry:
231 spin_lock_bh(chip->mutex);
232
233 switch(chip->state){
234 case FL_READY:
235 sharp_send_cmd(map, CMD_READ_STATUS, adr);
236 chip->state = FL_STATUS;
237 case FL_STATUS:
238 for(i=0;i<100;i++){
239 status = map_read(map, adr);
240 if((status.x[0] & SR_READY)==SR_READY)
241 break;
242 udelay(1);
243 }
244 break;
245 default:
246 printk("Waiting for chip\n");
247
248 set_current_state(TASK_INTERRUPTIBLE);
249 add_wait_queue(&chip->wq, &wait);
250
251 spin_unlock_bh(chip->mutex);
252
253 schedule();
254 remove_wait_queue(&chip->wq, &wait);
255
256 if(signal_pending(current))
257 return -EINTR;
258
259 timeo = jiffies + HZ;
260
261 goto retry;
262 }
263
264 sharp_send_cmd(map, CMD_RESET, adr);
265
266 chip->state = FL_READY;
267
268 return 0;
269}
270
271static void sharp_release(struct flchip *chip)
272{
273 wake_up(&chip->wq);
274 spin_unlock_bh(chip->mutex);
275}
276
277static int sharp_read(struct mtd_info *mtd, loff_t from, size_t len,
278 size_t *retlen, u_char *buf)
279{
280 struct map_info *map = mtd->priv;
281 struct sharp_info *sharp = map->fldrv_priv;
282 int chipnum;
283 int ret = 0;
284 int ofs = 0;
285
286 chipnum = (from >> sharp->chipshift);
287 ofs = from & ((1 << sharp->chipshift)-1);
288
289 *retlen = 0;
290
291 while(len){
292 unsigned long thislen;
293
294 if(chipnum>=sharp->numchips)
295 break;
296
297 thislen = len;
298 if(ofs+thislen >= (1<<sharp->chipshift))
299 thislen = (1<<sharp->chipshift) - ofs;
300
301 ret = sharp_wait(map,&sharp->chips[chipnum]);
302 if(ret<0)
303 break;
304
305 map_copy_from(map,buf,ofs,thislen);
306
307 sharp_release(&sharp->chips[chipnum]);
308
309 *retlen += thislen;
310 len -= thislen;
311 buf += thislen;
312
313 ofs = 0;
314 chipnum++;
315 }
316 return ret;
317}
318
319static int sharp_write(struct mtd_info *mtd, loff_t to, size_t len,
320 size_t *retlen, const u_char *buf)
321{
322 struct map_info *map = mtd->priv;
323 struct sharp_info *sharp = map->fldrv_priv;
324 int ret = 0;
325 int i,j;
326 int chipnum;
327 unsigned long ofs;
328 union { u32 l; unsigned char uc[4]; } tbuf;
329
330 *retlen = 0;
331
332 while(len){
333 tbuf.l = 0xffffffff;
334 chipnum = to >> sharp->chipshift;
335 ofs = to & ((1<<sharp->chipshift)-1);
336
337 j=0;
338 for(i=ofs&3;i<4 && len;i++){
339 tbuf.uc[i] = *buf;
340 buf++;
341 to++;
342 len--;
343 j++;
344 }
345 sharp_write_oneword(map, &sharp->chips[chipnum], ofs&~3, tbuf.l);
346 if(ret<0)
347 return ret;
348 (*retlen)+=j;
349 }
350
351 return 0;
352}
353
354static int sharp_write_oneword(struct map_info *map, struct flchip *chip,
355 unsigned long adr, __u32 datum)
356{
357 int ret;
358 int timeo;
359 int try;
360 int i;
361 map_word data, status;
362
363 status.x[0] = 0;
364 ret = sharp_wait(map,chip);
365
366 for(try=0;try<10;try++){
367 sharp_send_cmd(map, CMD_BYTE_WRITE, adr);
368 /* cpu_to_le32 -> hack to fix the writel be->le conversion */
369 data.x[0] = cpu_to_le32(datum);
370 map_write(map, data, adr);
371
372 chip->state = FL_WRITING;
373
374 timeo = jiffies + (HZ/2);
375
376 sharp_send_cmd(map, CMD_READ_STATUS, adr);
377 for(i=0;i<100;i++){
378 status = map_read(map, adr);
379 if((status.x[0] & SR_READY) == SR_READY)
380 break;
381 }
382 if(i==100){
383 printk("sharp: timed out writing\n");
384 }
385
386 if(!(status.x[0] & SR_ERRORS))
387 break;
388
389 printk("sharp: error writing byte at addr=%08lx status=%08lx\n", adr, status.x[0]);
390
391 sharp_send_cmd(map, CMD_CLEAR_STATUS, adr);
392 }
393 sharp_send_cmd(map, CMD_RESET, adr);
394 chip->state = FL_READY;
395
396 wake_up(&chip->wq);
397 spin_unlock_bh(chip->mutex);
398
399 return 0;
400}
401
402static int sharp_erase(struct mtd_info *mtd, struct erase_info *instr)
403{
404 struct map_info *map = mtd->priv;
405 struct sharp_info *sharp = map->fldrv_priv;
406 unsigned long adr,len;
407 int chipnum, ret=0;
408
409//printk("sharp_erase()\n");
410 if(instr->addr & (mtd->erasesize - 1))
411 return -EINVAL;
412 if(instr->len & (mtd->erasesize - 1))
413 return -EINVAL;
414 if(instr->len + instr->addr > mtd->size)
415 return -EINVAL;
416
417 chipnum = instr->addr >> sharp->chipshift;
418 adr = instr->addr & ((1<<sharp->chipshift)-1);
419 len = instr->len;
420
421 while(len){
422 ret = sharp_erase_oneblock(map, &sharp->chips[chipnum], adr);
423 if(ret)return ret;
424
425 adr += mtd->erasesize;
426 len -= mtd->erasesize;
427 if(adr >> sharp->chipshift){
428 adr = 0;
429 chipnum++;
430 if(chipnum>=sharp->numchips)
431 break;
432 }
433 }
434
435 instr->state = MTD_ERASE_DONE;
436 mtd_erase_callback(instr);
437
438 return 0;
439}
440
441static int sharp_do_wait_for_ready(struct map_info *map, struct flchip *chip,
442 unsigned long adr)
443{
444 int ret;
445 unsigned long timeo;
446 map_word status;
447 DECLARE_WAITQUEUE(wait, current);
448
449 sharp_send_cmd(map, CMD_READ_STATUS, adr);
450 status = map_read(map, adr);
451
452 timeo = jiffies + HZ;
453
454 while(time_before(jiffies, timeo)){
455 sharp_send_cmd(map, CMD_READ_STATUS, adr);
456 status = map_read(map, adr);
457 if((status.x[0] & SR_READY)==SR_READY){
458 ret = 0;
459 goto out;
460 }
461 set_current_state(TASK_INTERRUPTIBLE);
462 add_wait_queue(&chip->wq, &wait);
463
464 //spin_unlock_bh(chip->mutex);
465
466 schedule_timeout(1);
467 schedule();
468 remove_wait_queue(&chip->wq, &wait);
469
470 //spin_lock_bh(chip->mutex);
471
472 if (signal_pending(current)){
473 ret = -EINTR;
474 goto out;
475 }
476
477 }
478 ret = -ETIME;
479out:
480 return ret;
481}
482
483static int sharp_erase_oneblock(struct map_info *map, struct flchip *chip,
484 unsigned long adr)
485{
486 int ret;
487 //int timeo;
488 map_word status;
489 //int i;
490
491//printk("sharp_erase_oneblock()\n");
492
493#ifdef AUTOUNLOCK
494 /* This seems like a good place to do an unlock */
495 sharp_unlock_oneblock(map,chip,adr);
496#endif
497
498 sharp_send_cmd(map, CMD_BLOCK_ERASE_1, adr);
499 sharp_send_cmd(map, CMD_BLOCK_ERASE_2, adr);
500
501 chip->state = FL_ERASING;
502
503 ret = sharp_do_wait_for_ready(map,chip,adr);
504 if(ret<0)return ret;
505
506 sharp_send_cmd(map, CMD_READ_STATUS, adr);
507 status = map_read(map, adr);
508
509 if(!(status.x[0] & SR_ERRORS)){
510 sharp_send_cmd(map, CMD_RESET, adr);
511 chip->state = FL_READY;
512 //spin_unlock_bh(chip->mutex);
513 return 0;
514 }
515
516 printk("sharp: error erasing block at addr=%08lx status=%08lx\n", adr, status.x[0]);
517 sharp_send_cmd(map, CMD_CLEAR_STATUS, adr);
518
519 //spin_unlock_bh(chip->mutex);
520
521 return -EIO;
522}
523
524#ifdef AUTOUNLOCK
525static void sharp_unlock_oneblock(struct map_info *map, struct flchip *chip,
526 unsigned long adr)
527{
528 int i;
529 map_word status;
530
531 sharp_send_cmd(map, CMD_CLEAR_BLOCK_LOCKS_1, adr);
532 sharp_send_cmd(map, CMD_CLEAR_BLOCK_LOCKS_2, adr);
533
534 udelay(100);
535
536 status = map_read(map, adr);
537 printk("status=%08lx\n", status.x[0]);
538
539 for(i=0;i<1000;i++){
540 //sharp_send_cmd(map, CMD_READ_STATUS, adr);
541 status = map_read(map, adr);
542 if((status.x[0] & SR_READY) == SR_READY)
543 break;
544 udelay(100);
545 }
546 if(i==1000){
547 printk("sharp: timed out unlocking block\n");
548 }
549
550 if(!(status.x[0] & SR_ERRORS)){
551 sharp_send_cmd(map, CMD_RESET, adr);
552 chip->state = FL_READY;
553 return;
554 }
555
556 printk("sharp: error unlocking block at addr=%08lx status=%08lx\n", adr, status.x[0]);
557 sharp_send_cmd(map, CMD_CLEAR_STATUS, adr);
558}
559#endif
560
561static void sharp_sync(struct mtd_info *mtd)
562{
563 //printk("sharp_sync()\n");
564}
565
566static int sharp_suspend(struct mtd_info *mtd)
567{
568 printk("sharp_suspend()\n");
569 return -EINVAL;
570}
571
572static void sharp_resume(struct mtd_info *mtd)
573{
574 printk("sharp_resume()\n");
575
576}
577
578static void sharp_destroy(struct mtd_info *mtd)
579{
580 printk("sharp_destroy()\n");
581
582}
583
584int __init sharp_probe_init(void)
585{
586 printk("MTD Sharp chip driver <ds@lineo.com>\n");
587
588 register_mtd_chip_driver(&sharp_chipdrv);
589
590 return 0;
591}
592
593static void __exit sharp_probe_exit(void)
594{
595 unregister_mtd_chip_driver(&sharp_chipdrv);
596}
597
598module_init(sharp_probe_init);
599module_exit(sharp_probe_exit);
600
601
602MODULE_LICENSE("GPL");
603MODULE_AUTHOR("David Schleef <ds@schleef.org>");
604MODULE_DESCRIPTION("Old MTD chip driver for pre-CFI Sharp flash chips");