2 * MTD chip driver for pre-CFI Sharp flash chips
4 * Copyright 2000,2001 David A. Schleef <ds@schleef.org>
5 * 2000,2001 Lineo, Inc.
7 * $Id: sharp.c,v 1.14 2004/08/09 13:19:43 dwmw2 Exp $
10 * LH28F016SCT Symmetrical block flash memory, 2Mx8
11 * LH28F008SCT Symmetrical block flash memory, 1Mx8
14 * http://www.sharpmeg.com/datasheets/memic/flashcmp/
15 * http://www.sharpmeg.com/datasheets/memic/flashcmp/01symf/16m/016sctl9.pdf
19 * This driver only supports 4x1 arrangement of chips.
20 * Not tested on anything but PowerPC.
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>
35 #define CMD_RESET 0xffffffff
36 #define CMD_READ_ID 0x90909090
37 #define CMD_READ_STATUS 0x70707070
38 #define CMD_CLEAR_STATUS 0x50505050
39 #define CMD_BLOCK_ERASE_1 0x20202020
40 #define CMD_BLOCK_ERASE_2 0xd0d0d0d0
41 #define CMD_BYTE_WRITE 0x40404040
42 #define CMD_SUSPEND 0xb0b0b0b0
43 #define CMD_RESUME 0xd0d0d0d0
44 #define CMD_SET_BLOCK_LOCK_1 0x60606060
45 #define CMD_SET_BLOCK_LOCK_2 0x01010101
46 #define CMD_SET_MASTER_LOCK_1 0x60606060
47 #define CMD_SET_MASTER_LOCK_2 0xf1f1f1f1
48 #define CMD_CLEAR_BLOCK_LOCKS_1 0x60606060
49 #define CMD_CLEAR_BLOCK_LOCKS_2 0xd0d0d0d0
51 #define SR_READY 0x80808080 // 1 = ready
52 #define SR_ERASE_SUSPEND 0x40404040 // 1 = block erase suspended
53 #define SR_ERROR_ERASE 0x20202020 // 1 = error in block erase or clear lock bits
54 #define SR_ERROR_WRITE 0x10101010 // 1 = error in byte write or set lock bit
55 #define SR_VPP 0x08080808 // 1 = Vpp is low
56 #define SR_WRITE_SUSPEND 0x04040404 // 1 = byte write suspended
57 #define SR_PROTECT 0x02020202 // 1 = lock bit set
58 #define SR_RESERVED 0x01010101
60 #define SR_ERRORS (SR_ERROR_ERASE|SR_ERROR_WRITE|SR_VPP|SR_PROTECT)
62 /* Configuration options */
64 #undef AUTOUNLOCK /* automatically unlocks blocks before erasing */
66 struct mtd_info *sharp_probe(struct map_info *);
68 static int sharp_probe_map(struct map_info *map,struct mtd_info *mtd);
70 static int sharp_read(struct mtd_info *mtd, loff_t from, size_t len,
71 size_t *retlen, u_char *buf);
72 static int sharp_write(struct mtd_info *mtd, loff_t from, size_t len,
73 size_t *retlen, const u_char *buf);
74 static int sharp_erase(struct mtd_info *mtd, struct erase_info *instr);
75 static void sharp_sync(struct mtd_info *mtd);
76 static int sharp_suspend(struct mtd_info *mtd);
77 static void sharp_resume(struct mtd_info *mtd);
78 static void sharp_destroy(struct mtd_info *mtd);
80 static int sharp_write_oneword(struct map_info *map, struct flchip *chip,
81 unsigned long adr, __u32 datum);
82 static int sharp_erase_oneblock(struct map_info *map, struct flchip *chip,
85 static void sharp_unlock_oneblock(struct map_info *map, struct flchip *chip,
95 struct flchip chips[1];
98 struct mtd_info *sharp_probe(struct map_info *map);
99 static void sharp_destroy(struct mtd_info *mtd);
101 static struct mtd_chip_driver sharp_chipdrv = {
102 .probe = sharp_probe,
103 .destroy = sharp_destroy,
105 .module = THIS_MODULE
109 struct mtd_info *sharp_probe(struct map_info *map)
111 struct mtd_info *mtd = NULL;
112 struct sharp_info *sharp = NULL;
115 mtd = kmalloc(sizeof(*mtd), GFP_KERNEL);
119 sharp = kmalloc(sizeof(*sharp), GFP_KERNEL);
125 memset(mtd, 0, sizeof(*mtd));
127 width = sharp_probe_map(map,mtd);
135 mtd->type = MTD_NORFLASH;
136 mtd->erase = sharp_erase;
137 mtd->read = sharp_read;
138 mtd->write = sharp_write;
139 mtd->sync = sharp_sync;
140 mtd->suspend = sharp_suspend;
141 mtd->resume = sharp_resume;
142 mtd->flags = MTD_CAP_NORFLASH;
143 mtd->name = map->name;
145 memset(sharp, 0, sizeof(*sharp));
146 sharp->chipshift = 23;
148 sharp->chips[0].start = 0;
149 sharp->chips[0].state = FL_READY;
150 sharp->chips[0].mutex = &sharp->chips[0]._spinlock;
151 sharp->chips[0].word_write_time = 0;
152 init_waitqueue_head(&sharp->chips[0].wq);
153 spin_lock_init(&sharp->chips[0]._spinlock);
155 map->fldrv = &sharp_chipdrv;
156 map->fldrv_priv = sharp;
158 __module_get(THIS_MODULE);
162 static int sharp_probe_map(struct map_info *map,struct mtd_info *mtd)
165 unsigned long base = 0;
169 tmp = map_read32(map, base+0);
171 map_write32(map, CMD_READ_ID, base+0);
173 read0=map_read32(map, base+0);
174 read4=map_read32(map, base+4);
175 if(read0 == 0x89898989){
176 printk("Looks like sharp flash\n");
180 /* aa - LH28F016SCT-L95 2Mx8, 32 64k blocks*/
181 /* a0 - LH28F016SCT-Z4 2Mx8, 32 64k blocks*/
182 mtd->erasesize = 0x10000 * width;
183 mtd->size = 0x200000 * width;
186 /* a6 - LH28F008SCT-L12 1Mx8, 16 64k blocks*/
187 /* a6 - LH28F008SCR-L85 1Mx8, 16 64k blocks*/
188 mtd->erasesize = 0x10000 * width;
189 mtd->size = 0x100000 * width;
192 case 0x00000000: /* unknown */
193 /* XX - LH28F004SCT 512kx8, 8 64k blocks*/
194 mtd->erasesize = 0x10000 * width;
195 mtd->size = 0x80000 * width;
199 printk("Sort-of looks like sharp flash, 0x%08x 0x%08x\n",
202 }else if((map_read32(map, base+0) == CMD_READ_ID)){
204 printk("Looks like RAM\n");
205 map_write32(map, tmp, base+0);
207 printk("Doesn't look like sharp flash, 0x%08x 0x%08x\n",
214 /* This function returns with the chip->mutex lock held. */
215 static int sharp_wait(struct map_info *map, struct flchip *chip)
218 unsigned long timeo = jiffies + HZ;
219 DECLARE_WAITQUEUE(wait, current);
223 spin_lock_bh(chip->mutex);
227 map_write32(map,CMD_READ_STATUS,adr);
228 chip->state = FL_STATUS;
230 status = map_read32(map,adr);
231 //printk("status=%08x\n",status);
234 if((status & SR_READY)!=SR_READY){
235 //printk(".status=%08x\n",status);
240 printk("Waiting for chip\n");
242 set_current_state(TASK_INTERRUPTIBLE);
243 add_wait_queue(&chip->wq, &wait);
245 spin_unlock_bh(chip->mutex);
248 remove_wait_queue(&chip->wq, &wait);
250 if(signal_pending(current))
253 timeo = jiffies + HZ;
258 map_write32(map,CMD_RESET, adr);
260 chip->state = FL_READY;
265 static void sharp_release(struct flchip *chip)
268 spin_unlock_bh(chip->mutex);
271 static int sharp_read(struct mtd_info *mtd, loff_t from, size_t len,
272 size_t *retlen, u_char *buf)
274 struct map_info *map = mtd->priv;
275 struct sharp_info *sharp = map->fldrv_priv;
280 chipnum = (from >> sharp->chipshift);
281 ofs = from & ((1 << sharp->chipshift)-1);
286 unsigned long thislen;
288 if(chipnum>=sharp->numchips)
292 if(ofs+thislen >= (1<<sharp->chipshift))
293 thislen = (1<<sharp->chipshift) - ofs;
295 ret = sharp_wait(map,&sharp->chips[chipnum]);
299 map_copy_from(map,buf,ofs,thislen);
301 sharp_release(&sharp->chips[chipnum]);
313 static int sharp_write(struct mtd_info *mtd, loff_t to, size_t len,
314 size_t *retlen, const u_char *buf)
316 struct map_info *map = mtd->priv;
317 struct sharp_info *sharp = map->fldrv_priv;
322 union { u32 l; unsigned char uc[4]; } tbuf;
328 chipnum = to >> sharp->chipshift;
329 ofs = to & ((1<<sharp->chipshift)-1);
332 for(i=ofs&3;i<4 && len;i++){
339 sharp_write_oneword(map, &sharp->chips[chipnum], ofs&~3, tbuf.l);
348 static int sharp_write_oneword(struct map_info *map, struct flchip *chip,
349 unsigned long adr, __u32 datum)
357 ret = sharp_wait(map,chip);
359 for(try=0;try<10;try++){
360 map_write32(map,CMD_BYTE_WRITE,adr);
361 /* cpu_to_le32 -> hack to fix the writel be->le conversion */
362 map_write32(map,cpu_to_le32(datum),adr);
364 chip->state = FL_WRITING;
366 timeo = jiffies + (HZ/2);
368 map_write32(map,CMD_READ_STATUS,adr);
370 status = map_read32(map,adr);
371 if((status & SR_READY)==SR_READY)
375 printk("sharp: timed out writing\n");
378 if(!(status&SR_ERRORS))
381 printk("sharp: error writing byte at addr=%08lx status=%08x\n",adr,status);
383 map_write32(map,CMD_CLEAR_STATUS,adr);
385 map_write32(map,CMD_RESET,adr);
386 chip->state = FL_READY;
389 spin_unlock_bh(chip->mutex);
394 static int sharp_erase(struct mtd_info *mtd, struct erase_info *instr)
396 struct map_info *map = mtd->priv;
397 struct sharp_info *sharp = map->fldrv_priv;
398 unsigned long adr,len;
401 //printk("sharp_erase()\n");
402 if(instr->addr & (mtd->erasesize - 1))
404 if(instr->len & (mtd->erasesize - 1))
406 if(instr->len + instr->addr > mtd->size)
409 chipnum = instr->addr >> sharp->chipshift;
410 adr = instr->addr & ((1<<sharp->chipshift)-1);
414 ret = sharp_erase_oneblock(map, &sharp->chips[chipnum], adr);
417 adr += mtd->erasesize;
418 len -= mtd->erasesize;
419 if(adr >> sharp->chipshift){
422 if(chipnum>=sharp->numchips)
427 instr->state = MTD_ERASE_DONE;
428 mtd_erase_callback(instr);
433 static int sharp_do_wait_for_ready(struct map_info *map, struct flchip *chip,
439 DECLARE_WAITQUEUE(wait, current);
441 map_write32(map,CMD_READ_STATUS,adr);
442 status = map_read32(map,adr);
444 timeo = jiffies + HZ;
446 while(time_before(jiffies, timeo)){
447 map_write32(map,CMD_READ_STATUS,adr);
448 status = map_read32(map,adr);
449 if((status & SR_READY)==SR_READY){
453 set_current_state(TASK_INTERRUPTIBLE);
454 add_wait_queue(&chip->wq, &wait);
456 //spin_unlock_bh(chip->mutex);
460 remove_wait_queue(&chip->wq, &wait);
462 //spin_lock_bh(chip->mutex);
464 if (signal_pending(current)){
475 static int sharp_erase_oneblock(struct map_info *map, struct flchip *chip,
483 //printk("sharp_erase_oneblock()\n");
486 /* This seems like a good place to do an unlock */
487 sharp_unlock_oneblock(map,chip,adr);
490 map_write32(map,CMD_BLOCK_ERASE_1,adr);
491 map_write32(map,CMD_BLOCK_ERASE_2,adr);
493 chip->state = FL_ERASING;
495 ret = sharp_do_wait_for_ready(map,chip,adr);
498 map_write32(map,CMD_READ_STATUS,adr);
499 status = map_read32(map,adr);
501 if(!(status&SR_ERRORS)){
502 map_write32(map,CMD_RESET,adr);
503 chip->state = FL_READY;
504 //spin_unlock_bh(chip->mutex);
508 printk("sharp: error erasing block at addr=%08lx status=%08x\n",adr,status);
509 map_write32(map,CMD_CLEAR_STATUS,adr);
511 //spin_unlock_bh(chip->mutex);
517 static void sharp_unlock_oneblock(struct map_info *map, struct flchip *chip,
523 map_write32(map,CMD_CLEAR_BLOCK_LOCKS_1,adr);
524 map_write32(map,CMD_CLEAR_BLOCK_LOCKS_2,adr);
528 status = map_read32(map,adr);
529 printk("status=%08x\n",status);
532 //map_write32(map,CMD_READ_STATUS,adr);
533 status = map_read32(map,adr);
534 if((status & SR_READY)==SR_READY)
539 printk("sharp: timed out unlocking block\n");
542 if(!(status&SR_ERRORS)){
543 map_write32(map,CMD_RESET,adr);
544 chip->state = FL_READY;
548 printk("sharp: error unlocking block at addr=%08lx status=%08x\n",adr,status);
549 map_write32(map,CMD_CLEAR_STATUS,adr);
553 static void sharp_sync(struct mtd_info *mtd)
555 //printk("sharp_sync()\n");
558 static int sharp_suspend(struct mtd_info *mtd)
560 printk("sharp_suspend()\n");
564 static void sharp_resume(struct mtd_info *mtd)
566 printk("sharp_resume()\n");
570 static void sharp_destroy(struct mtd_info *mtd)
572 printk("sharp_destroy()\n");
576 int __init sharp_probe_init(void)
578 printk("MTD Sharp chip driver <ds@lineo.com>\n");
580 register_mtd_chip_driver(&sharp_chipdrv);
585 static void __exit sharp_probe_exit(void)
587 unregister_mtd_chip_driver(&sharp_chipdrv);
590 module_init(sharp_probe_init);
591 module_exit(sharp_probe_exit);
594 MODULE_LICENSE("GPL");
595 MODULE_AUTHOR("David Schleef <ds@schleef.org>");
596 MODULE_DESCRIPTION("Old MTD chip driver for pre-CFI Sharp flash chips");