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