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