Merge branch 'master'
[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 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 struct mtd_info *sharp_probe(struct map_info *map);
100 static void sharp_destroy(struct mtd_info *mtd);
101
102 static struct mtd_chip_driver sharp_chipdrv = {
103         .probe          = sharp_probe,
104         .destroy        = sharp_destroy,
105         .name           = "sharp",
106         .module         = THIS_MODULE
107 };
108
109
110 struct 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
163 static 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
170 static 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. */
222 static 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
230 retry:
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
271 static void sharp_release(struct flchip *chip)
272 {
273         wake_up(&chip->wq);
274         spin_unlock_bh(chip->mutex);
275 }
276
277 static 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
319 static 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
354 static 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
402 static 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
441 static 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;
479 out:
480         return ret;
481 }
482
483 static 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
525 static 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
561 static void sharp_sync(struct mtd_info *mtd)
562 {
563         //printk("sharp_sync()\n");
564 }
565
566 static int sharp_suspend(struct mtd_info *mtd)
567 {
568         printk("sharp_suspend()\n");
569         return -EINVAL;
570 }
571
572 static void sharp_resume(struct mtd_info *mtd)
573 {
574         printk("sharp_resume()\n");
575
576 }
577
578 static void sharp_destroy(struct mtd_info *mtd)
579 {
580         printk("sharp_destroy()\n");
581
582 }
583
584 int __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
593 static void __exit sharp_probe_exit(void)
594 {
595         unregister_mtd_chip_driver(&sharp_chipdrv);
596 }
597
598 module_init(sharp_probe_init);
599 module_exit(sharp_probe_exit);
600
601
602 MODULE_LICENSE("GPL");
603 MODULE_AUTHOR("David Schleef <ds@schleef.org>");
604 MODULE_DESCRIPTION("Old MTD chip driver for pre-CFI Sharp flash chips");