1 /* 2 * Common Flash Interface support: 3 * ST Advanced Architecture Command Set (ID 0x0020) 4 * 5 * (C) 2000 Red Hat. GPL'd 6 * 7 * 10/10/2000 Nicolas Pitre <nico@fluxnic.net> 8 * - completely revamped method functions so they are aware and 9 * independent of the flash geometry (buswidth, interleave, etc.) 10 * - scalability vs code size is completely set at compile-time 11 * (see include/linux/mtd/cfi.h for selection) 12 * - optimized write buffer method 13 * 06/21/2002 Joern Engel <joern@wh.fh-wedel.de> and others 14 * - modified Intel Command Set 0x0001 to support ST Advanced Architecture 15 * (command set 0x0020) 16 * - added a writev function 17 * 07/13/2005 Joern Engel <joern@wh.fh-wedel.de> 18 * - Plugged memory leak in cfi_staa_writev(). 19 */ 20 21 #include <linux/module.h> 22 #include <linux/types.h> 23 #include <linux/kernel.h> 24 #include <linux/sched.h> 25 #include <asm/io.h> 26 #include <asm/byteorder.h> 27 28 #include <linux/errno.h> 29 #include <linux/slab.h> 30 #include <linux/delay.h> 31 #include <linux/interrupt.h> 32 #include <linux/mtd/map.h> 33 #include <linux/mtd/cfi.h> 34 #include <linux/mtd/mtd.h> 35 36 37 static int cfi_staa_read(struct mtd_info *, loff_t, size_t, size_t *, u_char *); 38 static int cfi_staa_write_buffers(struct mtd_info *, loff_t, size_t, size_t *, const u_char *); 39 static int cfi_staa_writev(struct mtd_info *mtd, const struct kvec *vecs, 40 unsigned long count, loff_t to, size_t *retlen); 41 static int cfi_staa_erase_varsize(struct mtd_info *, struct erase_info *); 42 static void cfi_staa_sync (struct mtd_info *); 43 static int cfi_staa_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len); 44 static int cfi_staa_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len); 45 static int cfi_staa_suspend (struct mtd_info *); 46 static void cfi_staa_resume (struct mtd_info *); 47 48 static void cfi_staa_destroy(struct mtd_info *); 49 50 struct mtd_info *cfi_cmdset_0020(struct map_info *, int); 51 52 static struct mtd_info *cfi_staa_setup (struct map_info *); 53 54 static struct mtd_chip_driver cfi_staa_chipdrv = { 55 .probe = NULL, /* Not usable directly */ 56 .destroy = cfi_staa_destroy, 57 .name = "cfi_cmdset_0020", 58 .module = THIS_MODULE 59 }; 60 61 /* #define DEBUG_LOCK_BITS */ 62 //#define DEBUG_CFI_FEATURES 63 64 #ifdef DEBUG_CFI_FEATURES 65 static void cfi_tell_features(struct cfi_pri_intelext *extp) 66 { 67 int i; 68 printk(" Feature/Command Support: %4.4X\n", extp->FeatureSupport); 69 printk(" - Chip Erase: %s\n", extp->FeatureSupport&1?"supported":"unsupported"); 70 printk(" - Suspend Erase: %s\n", extp->FeatureSupport&2?"supported":"unsupported"); 71 printk(" - Suspend Program: %s\n", extp->FeatureSupport&4?"supported":"unsupported"); 72 printk(" - Legacy Lock/Unlock: %s\n", extp->FeatureSupport&8?"supported":"unsupported"); 73 printk(" - Queued Erase: %s\n", extp->FeatureSupport&16?"supported":"unsupported"); 74 printk(" - Instant block lock: %s\n", extp->FeatureSupport&32?"supported":"unsupported"); 75 printk(" - Protection Bits: %s\n", extp->FeatureSupport&64?"supported":"unsupported"); 76 printk(" - Page-mode read: %s\n", extp->FeatureSupport&128?"supported":"unsupported"); 77 printk(" - Synchronous read: %s\n", extp->FeatureSupport&256?"supported":"unsupported"); 78 for (i=9; i<32; i++) { 79 if (extp->FeatureSupport & (1<<i)) 80 printk(" - Unknown Bit %X: supported\n", i); 81 } 82 83 printk(" Supported functions after Suspend: %2.2X\n", extp->SuspendCmdSupport); 84 printk(" - Program after Erase Suspend: %s\n", extp->SuspendCmdSupport&1?"supported":"unsupported"); 85 for (i=1; i<8; i++) { 86 if (extp->SuspendCmdSupport & (1<<i)) 87 printk(" - Unknown Bit %X: supported\n", i); 88 } 89 90 printk(" Block Status Register Mask: %4.4X\n", extp->BlkStatusRegMask); 91 printk(" - Lock Bit Active: %s\n", extp->BlkStatusRegMask&1?"yes":"no"); 92 printk(" - Valid Bit Active: %s\n", extp->BlkStatusRegMask&2?"yes":"no"); 93 for (i=2; i<16; i++) { 94 if (extp->BlkStatusRegMask & (1<<i)) 95 printk(" - Unknown Bit %X Active: yes\n",i); 96 } 97 98 printk(" Vcc Logic Supply Optimum Program/Erase Voltage: %d.%d V\n", 99 extp->VccOptimal >> 8, extp->VccOptimal & 0xf); 100 if (extp->VppOptimal) 101 printk(" Vpp Programming Supply Optimum Program/Erase Voltage: %d.%d V\n", 102 extp->VppOptimal >> 8, extp->VppOptimal & 0xf); 103 } 104 #endif 105 106 /* This routine is made available to other mtd code via 107 * inter_module_register. It must only be accessed through 108 * inter_module_get which will bump the use count of this module. The 109 * addresses passed back in cfi are valid as long as the use count of 110 * this module is non-zero, i.e. between inter_module_get and 111 * inter_module_put. Keith Owens <kaos@ocs.com.au> 29 Oct 2000. 112 */ 113 struct mtd_info *cfi_cmdset_0020(struct map_info *map, int primary) 114 { 115 struct cfi_private *cfi = map->fldrv_priv; 116 int i; 117 118 if (cfi->cfi_mode) { 119 /* 120 * It's a real CFI chip, not one for which the probe 121 * routine faked a CFI structure. So we read the feature 122 * table from it. 123 */ 124 __u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR; 125 struct cfi_pri_intelext *extp; 126 127 extp = (struct cfi_pri_intelext*)cfi_read_pri(map, adr, sizeof(*extp), "ST Microelectronics"); 128 if (!extp) 129 return NULL; 130 131 if (extp->MajorVersion != '1' || 132 (extp->MinorVersion < '0' || extp->MinorVersion > '3')) { 133 printk(KERN_ERR " Unknown ST Microelectronics" 134 " Extended Query version %c.%c.\n", 135 extp->MajorVersion, extp->MinorVersion); 136 kfree(extp); 137 return NULL; 138 } 139 140 /* Do some byteswapping if necessary */ 141 extp->FeatureSupport = cfi32_to_cpu(map, extp->FeatureSupport); 142 extp->BlkStatusRegMask = cfi32_to_cpu(map, 143 extp->BlkStatusRegMask); 144 145 #ifdef DEBUG_CFI_FEATURES 146 /* Tell the user about it in lots of lovely detail */ 147 cfi_tell_features(extp); 148 #endif 149 150 /* Install our own private info structure */ 151 cfi->cmdset_priv = extp; 152 } 153 154 for (i=0; i< cfi->numchips; i++) { 155 cfi->chips[i].word_write_time = 128; 156 cfi->chips[i].buffer_write_time = 128; 157 cfi->chips[i].erase_time = 1024; 158 cfi->chips[i].ref_point_counter = 0; 159 init_waitqueue_head(&(cfi->chips[i].wq)); 160 } 161 162 return cfi_staa_setup(map); 163 } 164 EXPORT_SYMBOL_GPL(cfi_cmdset_0020); 165 166 static struct mtd_info *cfi_staa_setup(struct map_info *map) 167 { 168 struct cfi_private *cfi = map->fldrv_priv; 169 struct mtd_info *mtd; 170 unsigned long offset = 0; 171 int i,j; 172 unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave; 173 174 mtd = kzalloc(sizeof(*mtd), GFP_KERNEL); 175 //printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips); 176 177 if (!mtd) { 178 kfree(cfi->cmdset_priv); 179 return NULL; 180 } 181 182 mtd->priv = map; 183 mtd->type = MTD_NORFLASH; 184 mtd->size = devsize * cfi->numchips; 185 186 mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips; 187 mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info) 188 * mtd->numeraseregions, GFP_KERNEL); 189 if (!mtd->eraseregions) { 190 kfree(cfi->cmdset_priv); 191 kfree(mtd); 192 return NULL; 193 } 194 195 for (i=0; i<cfi->cfiq->NumEraseRegions; i++) { 196 unsigned long ernum, ersize; 197 ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave; 198 ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1; 199 200 if (mtd->erasesize < ersize) { 201 mtd->erasesize = ersize; 202 } 203 for (j=0; j<cfi->numchips; j++) { 204 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset; 205 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize; 206 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum; 207 } 208 offset += (ersize * ernum); 209 } 210 211 if (offset != devsize) { 212 /* Argh */ 213 printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize); 214 kfree(mtd->eraseregions); 215 kfree(cfi->cmdset_priv); 216 kfree(mtd); 217 return NULL; 218 } 219 220 for (i=0; i<mtd->numeraseregions;i++){ 221 printk(KERN_DEBUG "%d: offset=0x%llx,size=0x%x,blocks=%d\n", 222 i, (unsigned long long)mtd->eraseregions[i].offset, 223 mtd->eraseregions[i].erasesize, 224 mtd->eraseregions[i].numblocks); 225 } 226 227 /* Also select the correct geometry setup too */ 228 mtd->_erase = cfi_staa_erase_varsize; 229 mtd->_read = cfi_staa_read; 230 mtd->_write = cfi_staa_write_buffers; 231 mtd->_writev = cfi_staa_writev; 232 mtd->_sync = cfi_staa_sync; 233 mtd->_lock = cfi_staa_lock; 234 mtd->_unlock = cfi_staa_unlock; 235 mtd->_suspend = cfi_staa_suspend; 236 mtd->_resume = cfi_staa_resume; 237 mtd->flags = MTD_CAP_NORFLASH & ~MTD_BIT_WRITEABLE; 238 mtd->writesize = 8; /* FIXME: Should be 0 for STMicro flashes w/out ECC */ 239 mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize; 240 map->fldrv = &cfi_staa_chipdrv; 241 __module_get(THIS_MODULE); 242 mtd->name = map->name; 243 return mtd; 244 } 245 246 247 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf) 248 { 249 map_word status, status_OK; 250 unsigned long timeo; 251 DECLARE_WAITQUEUE(wait, current); 252 int suspended = 0; 253 unsigned long cmd_addr; 254 struct cfi_private *cfi = map->fldrv_priv; 255 256 adr += chip->start; 257 258 /* Ensure cmd read/writes are aligned. */ 259 cmd_addr = adr & ~(map_bankwidth(map)-1); 260 261 /* Let's determine this according to the interleave only once */ 262 status_OK = CMD(0x80); 263 264 timeo = jiffies + HZ; 265 retry: 266 mutex_lock(&chip->mutex); 267 268 /* Check that the chip's ready to talk to us. 269 * If it's in FL_ERASING state, suspend it and make it talk now. 270 */ 271 switch (chip->state) { 272 case FL_ERASING: 273 if (!(((struct cfi_pri_intelext *)cfi->cmdset_priv)->FeatureSupport & 2)) 274 goto sleep; /* We don't support erase suspend */ 275 276 map_write (map, CMD(0xb0), cmd_addr); 277 /* If the flash has finished erasing, then 'erase suspend' 278 * appears to make some (28F320) flash devices switch to 279 * 'read' mode. Make sure that we switch to 'read status' 280 * mode so we get the right data. --rmk 281 */ 282 map_write(map, CMD(0x70), cmd_addr); 283 chip->oldstate = FL_ERASING; 284 chip->state = FL_ERASE_SUSPENDING; 285 // printk("Erase suspending at 0x%lx\n", cmd_addr); 286 for (;;) { 287 status = map_read(map, cmd_addr); 288 if (map_word_andequal(map, status, status_OK, status_OK)) 289 break; 290 291 if (time_after(jiffies, timeo)) { 292 /* Urgh */ 293 map_write(map, CMD(0xd0), cmd_addr); 294 /* make sure we're in 'read status' mode */ 295 map_write(map, CMD(0x70), cmd_addr); 296 chip->state = FL_ERASING; 297 wake_up(&chip->wq); 298 mutex_unlock(&chip->mutex); 299 printk(KERN_ERR "Chip not ready after erase " 300 "suspended: status = 0x%lx\n", status.x[0]); 301 return -EIO; 302 } 303 304 mutex_unlock(&chip->mutex); 305 cfi_udelay(1); 306 mutex_lock(&chip->mutex); 307 } 308 309 suspended = 1; 310 map_write(map, CMD(0xff), cmd_addr); 311 chip->state = FL_READY; 312 break; 313 314 #if 0 315 case FL_WRITING: 316 /* Not quite yet */ 317 #endif 318 319 case FL_READY: 320 break; 321 322 case FL_CFI_QUERY: 323 case FL_JEDEC_QUERY: 324 map_write(map, CMD(0x70), cmd_addr); 325 chip->state = FL_STATUS; 326 327 case FL_STATUS: 328 status = map_read(map, cmd_addr); 329 if (map_word_andequal(map, status, status_OK, status_OK)) { 330 map_write(map, CMD(0xff), cmd_addr); 331 chip->state = FL_READY; 332 break; 333 } 334 335 /* Urgh. Chip not yet ready to talk to us. */ 336 if (time_after(jiffies, timeo)) { 337 mutex_unlock(&chip->mutex); 338 printk(KERN_ERR "waiting for chip to be ready timed out in read. WSM status = %lx\n", status.x[0]); 339 return -EIO; 340 } 341 342 /* Latency issues. Drop the lock, wait a while and retry */ 343 mutex_unlock(&chip->mutex); 344 cfi_udelay(1); 345 goto retry; 346 347 default: 348 sleep: 349 /* Stick ourselves on a wait queue to be woken when 350 someone changes the status */ 351 set_current_state(TASK_UNINTERRUPTIBLE); 352 add_wait_queue(&chip->wq, &wait); 353 mutex_unlock(&chip->mutex); 354 schedule(); 355 remove_wait_queue(&chip->wq, &wait); 356 timeo = jiffies + HZ; 357 goto retry; 358 } 359 360 map_copy_from(map, buf, adr, len); 361 362 if (suspended) { 363 chip->state = chip->oldstate; 364 /* What if one interleaved chip has finished and the 365 other hasn't? The old code would leave the finished 366 one in READY mode. That's bad, and caused -EROFS 367 errors to be returned from do_erase_oneblock because 368 that's the only bit it checked for at the time. 369 As the state machine appears to explicitly allow 370 sending the 0x70 (Read Status) command to an erasing 371 chip and expecting it to be ignored, that's what we 372 do. */ 373 map_write(map, CMD(0xd0), cmd_addr); 374 map_write(map, CMD(0x70), cmd_addr); 375 } 376 377 wake_up(&chip->wq); 378 mutex_unlock(&chip->mutex); 379 return 0; 380 } 381 382 static int cfi_staa_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf) 383 { 384 struct map_info *map = mtd->priv; 385 struct cfi_private *cfi = map->fldrv_priv; 386 unsigned long ofs; 387 int chipnum; 388 int ret = 0; 389 390 /* ofs: offset within the first chip that the first read should start */ 391 chipnum = (from >> cfi->chipshift); 392 ofs = from - (chipnum << cfi->chipshift); 393 394 while (len) { 395 unsigned long thislen; 396 397 if (chipnum >= cfi->numchips) 398 break; 399 400 if ((len + ofs -1) >> cfi->chipshift) 401 thislen = (1<<cfi->chipshift) - ofs; 402 else 403 thislen = len; 404 405 ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf); 406 if (ret) 407 break; 408 409 *retlen += thislen; 410 len -= thislen; 411 buf += thislen; 412 413 ofs = 0; 414 chipnum++; 415 } 416 return ret; 417 } 418 419 static int do_write_buffer(struct map_info *map, struct flchip *chip, 420 unsigned long adr, const u_char *buf, int len) 421 { 422 struct cfi_private *cfi = map->fldrv_priv; 423 map_word status, status_OK; 424 unsigned long cmd_adr, timeo; 425 DECLARE_WAITQUEUE(wait, current); 426 int wbufsize, z; 427 428 /* M58LW064A requires bus alignment for buffer wriets -- saw */ 429 if (adr & (map_bankwidth(map)-1)) 430 return -EINVAL; 431 432 wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize; 433 adr += chip->start; 434 cmd_adr = adr & ~(wbufsize-1); 435 436 /* Let's determine this according to the interleave only once */ 437 status_OK = CMD(0x80); 438 439 timeo = jiffies + HZ; 440 retry: 441 442 #ifdef DEBUG_CFI_FEATURES 443 printk("%s: chip->state[%d]\n", __func__, chip->state); 444 #endif 445 mutex_lock(&chip->mutex); 446 447 /* Check that the chip's ready to talk to us. 448 * Later, we can actually think about interrupting it 449 * if it's in FL_ERASING state. 450 * Not just yet, though. 451 */ 452 switch (chip->state) { 453 case FL_READY: 454 break; 455 456 case FL_CFI_QUERY: 457 case FL_JEDEC_QUERY: 458 map_write(map, CMD(0x70), cmd_adr); 459 chip->state = FL_STATUS; 460 #ifdef DEBUG_CFI_FEATURES 461 printk("%s: 1 status[%x]\n", __func__, map_read(map, cmd_adr)); 462 #endif 463 464 case FL_STATUS: 465 status = map_read(map, cmd_adr); 466 if (map_word_andequal(map, status, status_OK, status_OK)) 467 break; 468 /* Urgh. Chip not yet ready to talk to us. */ 469 if (time_after(jiffies, timeo)) { 470 mutex_unlock(&chip->mutex); 471 printk(KERN_ERR "waiting for chip to be ready timed out in buffer write Xstatus = %lx, status = %lx\n", 472 status.x[0], map_read(map, cmd_adr).x[0]); 473 return -EIO; 474 } 475 476 /* Latency issues. Drop the lock, wait a while and retry */ 477 mutex_unlock(&chip->mutex); 478 cfi_udelay(1); 479 goto retry; 480 481 default: 482 /* Stick ourselves on a wait queue to be woken when 483 someone changes the status */ 484 set_current_state(TASK_UNINTERRUPTIBLE); 485 add_wait_queue(&chip->wq, &wait); 486 mutex_unlock(&chip->mutex); 487 schedule(); 488 remove_wait_queue(&chip->wq, &wait); 489 timeo = jiffies + HZ; 490 goto retry; 491 } 492 493 ENABLE_VPP(map); 494 map_write(map, CMD(0xe8), cmd_adr); 495 chip->state = FL_WRITING_TO_BUFFER; 496 497 z = 0; 498 for (;;) { 499 status = map_read(map, cmd_adr); 500 if (map_word_andequal(map, status, status_OK, status_OK)) 501 break; 502 503 mutex_unlock(&chip->mutex); 504 cfi_udelay(1); 505 mutex_lock(&chip->mutex); 506 507 if (++z > 100) { 508 /* Argh. Not ready for write to buffer */ 509 DISABLE_VPP(map); 510 map_write(map, CMD(0x70), cmd_adr); 511 chip->state = FL_STATUS; 512 mutex_unlock(&chip->mutex); 513 printk(KERN_ERR "Chip not ready for buffer write. Xstatus = %lx\n", status.x[0]); 514 return -EIO; 515 } 516 } 517 518 /* Write length of data to come */ 519 map_write(map, CMD(len/map_bankwidth(map)-1), cmd_adr ); 520 521 /* Write data */ 522 for (z = 0; z < len; 523 z += map_bankwidth(map), buf += map_bankwidth(map)) { 524 map_word d; 525 d = map_word_load(map, buf); 526 map_write(map, d, adr+z); 527 } 528 /* GO GO GO */ 529 map_write(map, CMD(0xd0), cmd_adr); 530 chip->state = FL_WRITING; 531 532 mutex_unlock(&chip->mutex); 533 cfi_udelay(chip->buffer_write_time); 534 mutex_lock(&chip->mutex); 535 536 timeo = jiffies + (HZ/2); 537 z = 0; 538 for (;;) { 539 if (chip->state != FL_WRITING) { 540 /* Someone's suspended the write. Sleep */ 541 set_current_state(TASK_UNINTERRUPTIBLE); 542 add_wait_queue(&chip->wq, &wait); 543 mutex_unlock(&chip->mutex); 544 schedule(); 545 remove_wait_queue(&chip->wq, &wait); 546 timeo = jiffies + (HZ / 2); /* FIXME */ 547 mutex_lock(&chip->mutex); 548 continue; 549 } 550 551 status = map_read(map, cmd_adr); 552 if (map_word_andequal(map, status, status_OK, status_OK)) 553 break; 554 555 /* OK Still waiting */ 556 if (time_after(jiffies, timeo)) { 557 /* clear status */ 558 map_write(map, CMD(0x50), cmd_adr); 559 /* put back into read status register mode */ 560 map_write(map, CMD(0x70), adr); 561 chip->state = FL_STATUS; 562 DISABLE_VPP(map); 563 mutex_unlock(&chip->mutex); 564 printk(KERN_ERR "waiting for chip to be ready timed out in bufwrite\n"); 565 return -EIO; 566 } 567 568 /* Latency issues. Drop the lock, wait a while and retry */ 569 mutex_unlock(&chip->mutex); 570 cfi_udelay(1); 571 z++; 572 mutex_lock(&chip->mutex); 573 } 574 if (!z) { 575 chip->buffer_write_time--; 576 if (!chip->buffer_write_time) 577 chip->buffer_write_time++; 578 } 579 if (z > 1) 580 chip->buffer_write_time++; 581 582 /* Done and happy. */ 583 DISABLE_VPP(map); 584 chip->state = FL_STATUS; 585 586 /* check for errors: 'lock bit', 'VPP', 'dead cell'/'unerased cell' or 'incorrect cmd' -- saw */ 587 if (map_word_bitsset(map, status, CMD(0x3a))) { 588 #ifdef DEBUG_CFI_FEATURES 589 printk("%s: 2 status[%lx]\n", __func__, status.x[0]); 590 #endif 591 /* clear status */ 592 map_write(map, CMD(0x50), cmd_adr); 593 /* put back into read status register mode */ 594 map_write(map, CMD(0x70), adr); 595 wake_up(&chip->wq); 596 mutex_unlock(&chip->mutex); 597 return map_word_bitsset(map, status, CMD(0x02)) ? -EROFS : -EIO; 598 } 599 wake_up(&chip->wq); 600 mutex_unlock(&chip->mutex); 601 602 return 0; 603 } 604 605 static int cfi_staa_write_buffers (struct mtd_info *mtd, loff_t to, 606 size_t len, size_t *retlen, const u_char *buf) 607 { 608 struct map_info *map = mtd->priv; 609 struct cfi_private *cfi = map->fldrv_priv; 610 int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize; 611 int ret = 0; 612 int chipnum; 613 unsigned long ofs; 614 615 chipnum = to >> cfi->chipshift; 616 ofs = to - (chipnum << cfi->chipshift); 617 618 #ifdef DEBUG_CFI_FEATURES 619 printk("%s: map_bankwidth(map)[%x]\n", __func__, map_bankwidth(map)); 620 printk("%s: chipnum[%x] wbufsize[%x]\n", __func__, chipnum, wbufsize); 621 printk("%s: ofs[%x] len[%x]\n", __func__, ofs, len); 622 #endif 623 624 /* Write buffer is worth it only if more than one word to write... */ 625 while (len > 0) { 626 /* We must not cross write block boundaries */ 627 int size = wbufsize - (ofs & (wbufsize-1)); 628 629 if (size > len) 630 size = len; 631 632 ret = do_write_buffer(map, &cfi->chips[chipnum], 633 ofs, buf, size); 634 if (ret) 635 return ret; 636 637 ofs += size; 638 buf += size; 639 (*retlen) += size; 640 len -= size; 641 642 if (ofs >> cfi->chipshift) { 643 chipnum ++; 644 ofs = 0; 645 if (chipnum == cfi->numchips) 646 return 0; 647 } 648 } 649 650 return 0; 651 } 652 653 /* 654 * Writev for ECC-Flashes is a little more complicated. We need to maintain 655 * a small buffer for this. 656 * XXX: If the buffer size is not a multiple of 2, this will break 657 */ 658 #define ECCBUF_SIZE (mtd->writesize) 659 #define ECCBUF_DIV(x) ((x) & ~(ECCBUF_SIZE - 1)) 660 #define ECCBUF_MOD(x) ((x) & (ECCBUF_SIZE - 1)) 661 static int 662 cfi_staa_writev(struct mtd_info *mtd, const struct kvec *vecs, 663 unsigned long count, loff_t to, size_t *retlen) 664 { 665 unsigned long i; 666 size_t totlen = 0, thislen; 667 int ret = 0; 668 size_t buflen = 0; 669 static char *buffer; 670 671 if (!ECCBUF_SIZE) { 672 /* We should fall back to a general writev implementation. 673 * Until that is written, just break. 674 */ 675 return -EIO; 676 } 677 buffer = kmalloc(ECCBUF_SIZE, GFP_KERNEL); 678 if (!buffer) 679 return -ENOMEM; 680 681 for (i=0; i<count; i++) { 682 size_t elem_len = vecs[i].iov_len; 683 void *elem_base = vecs[i].iov_base; 684 if (!elem_len) /* FIXME: Might be unnecessary. Check that */ 685 continue; 686 if (buflen) { /* cut off head */ 687 if (buflen + elem_len < ECCBUF_SIZE) { /* just accumulate */ 688 memcpy(buffer+buflen, elem_base, elem_len); 689 buflen += elem_len; 690 continue; 691 } 692 memcpy(buffer+buflen, elem_base, ECCBUF_SIZE-buflen); 693 ret = mtd_write(mtd, to, ECCBUF_SIZE, &thislen, 694 buffer); 695 totlen += thislen; 696 if (ret || thislen != ECCBUF_SIZE) 697 goto write_error; 698 elem_len -= thislen-buflen; 699 elem_base += thislen-buflen; 700 to += ECCBUF_SIZE; 701 } 702 if (ECCBUF_DIV(elem_len)) { /* write clean aligned data */ 703 ret = mtd_write(mtd, to, ECCBUF_DIV(elem_len), 704 &thislen, elem_base); 705 totlen += thislen; 706 if (ret || thislen != ECCBUF_DIV(elem_len)) 707 goto write_error; 708 to += thislen; 709 } 710 buflen = ECCBUF_MOD(elem_len); /* cut off tail */ 711 if (buflen) { 712 memset(buffer, 0xff, ECCBUF_SIZE); 713 memcpy(buffer, elem_base + thislen, buflen); 714 } 715 } 716 if (buflen) { /* flush last page, even if not full */ 717 /* This is sometimes intended behaviour, really */ 718 ret = mtd_write(mtd, to, buflen, &thislen, buffer); 719 totlen += thislen; 720 if (ret || thislen != ECCBUF_SIZE) 721 goto write_error; 722 } 723 write_error: 724 if (retlen) 725 *retlen = totlen; 726 kfree(buffer); 727 return ret; 728 } 729 730 731 static inline int do_erase_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr) 732 { 733 struct cfi_private *cfi = map->fldrv_priv; 734 map_word status, status_OK; 735 unsigned long timeo; 736 int retries = 3; 737 DECLARE_WAITQUEUE(wait, current); 738 int ret = 0; 739 740 adr += chip->start; 741 742 /* Let's determine this according to the interleave only once */ 743 status_OK = CMD(0x80); 744 745 timeo = jiffies + HZ; 746 retry: 747 mutex_lock(&chip->mutex); 748 749 /* Check that the chip's ready to talk to us. */ 750 switch (chip->state) { 751 case FL_CFI_QUERY: 752 case FL_JEDEC_QUERY: 753 case FL_READY: 754 map_write(map, CMD(0x70), adr); 755 chip->state = FL_STATUS; 756 757 case FL_STATUS: 758 status = map_read(map, adr); 759 if (map_word_andequal(map, status, status_OK, status_OK)) 760 break; 761 762 /* Urgh. Chip not yet ready to talk to us. */ 763 if (time_after(jiffies, timeo)) { 764 mutex_unlock(&chip->mutex); 765 printk(KERN_ERR "waiting for chip to be ready timed out in erase\n"); 766 return -EIO; 767 } 768 769 /* Latency issues. Drop the lock, wait a while and retry */ 770 mutex_unlock(&chip->mutex); 771 cfi_udelay(1); 772 goto retry; 773 774 default: 775 /* Stick ourselves on a wait queue to be woken when 776 someone changes the status */ 777 set_current_state(TASK_UNINTERRUPTIBLE); 778 add_wait_queue(&chip->wq, &wait); 779 mutex_unlock(&chip->mutex); 780 schedule(); 781 remove_wait_queue(&chip->wq, &wait); 782 timeo = jiffies + HZ; 783 goto retry; 784 } 785 786 ENABLE_VPP(map); 787 /* Clear the status register first */ 788 map_write(map, CMD(0x50), adr); 789 790 /* Now erase */ 791 map_write(map, CMD(0x20), adr); 792 map_write(map, CMD(0xD0), adr); 793 chip->state = FL_ERASING; 794 795 mutex_unlock(&chip->mutex); 796 msleep(1000); 797 mutex_lock(&chip->mutex); 798 799 /* FIXME. Use a timer to check this, and return immediately. */ 800 /* Once the state machine's known to be working I'll do that */ 801 802 timeo = jiffies + (HZ*20); 803 for (;;) { 804 if (chip->state != FL_ERASING) { 805 /* Someone's suspended the erase. Sleep */ 806 set_current_state(TASK_UNINTERRUPTIBLE); 807 add_wait_queue(&chip->wq, &wait); 808 mutex_unlock(&chip->mutex); 809 schedule(); 810 remove_wait_queue(&chip->wq, &wait); 811 timeo = jiffies + (HZ*20); /* FIXME */ 812 mutex_lock(&chip->mutex); 813 continue; 814 } 815 816 status = map_read(map, adr); 817 if (map_word_andequal(map, status, status_OK, status_OK)) 818 break; 819 820 /* OK Still waiting */ 821 if (time_after(jiffies, timeo)) { 822 map_write(map, CMD(0x70), adr); 823 chip->state = FL_STATUS; 824 printk(KERN_ERR "waiting for erase to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]); 825 DISABLE_VPP(map); 826 mutex_unlock(&chip->mutex); 827 return -EIO; 828 } 829 830 /* Latency issues. Drop the lock, wait a while and retry */ 831 mutex_unlock(&chip->mutex); 832 cfi_udelay(1); 833 mutex_lock(&chip->mutex); 834 } 835 836 DISABLE_VPP(map); 837 ret = 0; 838 839 /* We've broken this before. It doesn't hurt to be safe */ 840 map_write(map, CMD(0x70), adr); 841 chip->state = FL_STATUS; 842 status = map_read(map, adr); 843 844 /* check for lock bit */ 845 if (map_word_bitsset(map, status, CMD(0x3a))) { 846 unsigned char chipstatus = status.x[0]; 847 if (!map_word_equal(map, status, CMD(chipstatus))) { 848 int i, w; 849 for (w=0; w<map_words(map); w++) { 850 for (i = 0; i<cfi_interleave(cfi); i++) { 851 chipstatus |= status.x[w] >> (cfi->device_type * 8); 852 } 853 } 854 printk(KERN_WARNING "Status is not identical for all chips: 0x%lx. Merging to give 0x%02x\n", 855 status.x[0], chipstatus); 856 } 857 /* Reset the error bits */ 858 map_write(map, CMD(0x50), adr); 859 map_write(map, CMD(0x70), adr); 860 861 if ((chipstatus & 0x30) == 0x30) { 862 printk(KERN_NOTICE "Chip reports improper command sequence: status 0x%x\n", chipstatus); 863 ret = -EIO; 864 } else if (chipstatus & 0x02) { 865 /* Protection bit set */ 866 ret = -EROFS; 867 } else if (chipstatus & 0x8) { 868 /* Voltage */ 869 printk(KERN_WARNING "Chip reports voltage low on erase: status 0x%x\n", chipstatus); 870 ret = -EIO; 871 } else if (chipstatus & 0x20) { 872 if (retries--) { 873 printk(KERN_DEBUG "Chip erase failed at 0x%08lx: status 0x%x. Retrying...\n", adr, chipstatus); 874 timeo = jiffies + HZ; 875 chip->state = FL_STATUS; 876 mutex_unlock(&chip->mutex); 877 goto retry; 878 } 879 printk(KERN_DEBUG "Chip erase failed at 0x%08lx: status 0x%x\n", adr, chipstatus); 880 ret = -EIO; 881 } 882 } 883 884 wake_up(&chip->wq); 885 mutex_unlock(&chip->mutex); 886 return ret; 887 } 888 889 static int cfi_staa_erase_varsize(struct mtd_info *mtd, 890 struct erase_info *instr) 891 { struct map_info *map = mtd->priv; 892 struct cfi_private *cfi = map->fldrv_priv; 893 unsigned long adr, len; 894 int chipnum, ret = 0; 895 int i, first; 896 struct mtd_erase_region_info *regions = mtd->eraseregions; 897 898 /* Check that both start and end of the requested erase are 899 * aligned with the erasesize at the appropriate addresses. 900 */ 901 902 i = 0; 903 904 /* Skip all erase regions which are ended before the start of 905 the requested erase. Actually, to save on the calculations, 906 we skip to the first erase region which starts after the 907 start of the requested erase, and then go back one. 908 */ 909 910 while (i < mtd->numeraseregions && instr->addr >= regions[i].offset) 911 i++; 912 i--; 913 914 /* OK, now i is pointing at the erase region in which this 915 erase request starts. Check the start of the requested 916 erase range is aligned with the erase size which is in 917 effect here. 918 */ 919 920 if (instr->addr & (regions[i].erasesize-1)) 921 return -EINVAL; 922 923 /* Remember the erase region we start on */ 924 first = i; 925 926 /* Next, check that the end of the requested erase is aligned 927 * with the erase region at that address. 928 */ 929 930 while (i<mtd->numeraseregions && (instr->addr + instr->len) >= regions[i].offset) 931 i++; 932 933 /* As before, drop back one to point at the region in which 934 the address actually falls 935 */ 936 i--; 937 938 if ((instr->addr + instr->len) & (regions[i].erasesize-1)) 939 return -EINVAL; 940 941 chipnum = instr->addr >> cfi->chipshift; 942 adr = instr->addr - (chipnum << cfi->chipshift); 943 len = instr->len; 944 945 i=first; 946 947 while(len) { 948 ret = do_erase_oneblock(map, &cfi->chips[chipnum], adr); 949 950 if (ret) 951 return ret; 952 953 adr += regions[i].erasesize; 954 len -= regions[i].erasesize; 955 956 if (adr % (1<< cfi->chipshift) == (((unsigned long)regions[i].offset + (regions[i].erasesize * regions[i].numblocks)) %( 1<< cfi->chipshift))) 957 i++; 958 959 if (adr >> cfi->chipshift) { 960 adr = 0; 961 chipnum++; 962 963 if (chipnum >= cfi->numchips) 964 break; 965 } 966 } 967 968 instr->state = MTD_ERASE_DONE; 969 mtd_erase_callback(instr); 970 971 return 0; 972 } 973 974 static void cfi_staa_sync (struct mtd_info *mtd) 975 { 976 struct map_info *map = mtd->priv; 977 struct cfi_private *cfi = map->fldrv_priv; 978 int i; 979 struct flchip *chip; 980 int ret = 0; 981 DECLARE_WAITQUEUE(wait, current); 982 983 for (i=0; !ret && i<cfi->numchips; i++) { 984 chip = &cfi->chips[i]; 985 986 retry: 987 mutex_lock(&chip->mutex); 988 989 switch(chip->state) { 990 case FL_READY: 991 case FL_STATUS: 992 case FL_CFI_QUERY: 993 case FL_JEDEC_QUERY: 994 chip->oldstate = chip->state; 995 chip->state = FL_SYNCING; 996 /* No need to wake_up() on this state change - 997 * as the whole point is that nobody can do anything 998 * with the chip now anyway. 999 */ 1000 case FL_SYNCING: 1001 mutex_unlock(&chip->mutex); 1002 break; 1003 1004 default: 1005 /* Not an idle state */ 1006 set_current_state(TASK_UNINTERRUPTIBLE); 1007 add_wait_queue(&chip->wq, &wait); 1008 1009 mutex_unlock(&chip->mutex); 1010 schedule(); 1011 remove_wait_queue(&chip->wq, &wait); 1012 1013 goto retry; 1014 } 1015 } 1016 1017 /* Unlock the chips again */ 1018 1019 for (i--; i >=0; i--) { 1020 chip = &cfi->chips[i]; 1021 1022 mutex_lock(&chip->mutex); 1023 1024 if (chip->state == FL_SYNCING) { 1025 chip->state = chip->oldstate; 1026 wake_up(&chip->wq); 1027 } 1028 mutex_unlock(&chip->mutex); 1029 } 1030 } 1031 1032 static inline int do_lock_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr) 1033 { 1034 struct cfi_private *cfi = map->fldrv_priv; 1035 map_word status, status_OK; 1036 unsigned long timeo = jiffies + HZ; 1037 DECLARE_WAITQUEUE(wait, current); 1038 1039 adr += chip->start; 1040 1041 /* Let's determine this according to the interleave only once */ 1042 status_OK = CMD(0x80); 1043 1044 timeo = jiffies + HZ; 1045 retry: 1046 mutex_lock(&chip->mutex); 1047 1048 /* Check that the chip's ready to talk to us. */ 1049 switch (chip->state) { 1050 case FL_CFI_QUERY: 1051 case FL_JEDEC_QUERY: 1052 case FL_READY: 1053 map_write(map, CMD(0x70), adr); 1054 chip->state = FL_STATUS; 1055 1056 case FL_STATUS: 1057 status = map_read(map, adr); 1058 if (map_word_andequal(map, status, status_OK, status_OK)) 1059 break; 1060 1061 /* Urgh. Chip not yet ready to talk to us. */ 1062 if (time_after(jiffies, timeo)) { 1063 mutex_unlock(&chip->mutex); 1064 printk(KERN_ERR "waiting for chip to be ready timed out in lock\n"); 1065 return -EIO; 1066 } 1067 1068 /* Latency issues. Drop the lock, wait a while and retry */ 1069 mutex_unlock(&chip->mutex); 1070 cfi_udelay(1); 1071 goto retry; 1072 1073 default: 1074 /* Stick ourselves on a wait queue to be woken when 1075 someone changes the status */ 1076 set_current_state(TASK_UNINTERRUPTIBLE); 1077 add_wait_queue(&chip->wq, &wait); 1078 mutex_unlock(&chip->mutex); 1079 schedule(); 1080 remove_wait_queue(&chip->wq, &wait); 1081 timeo = jiffies + HZ; 1082 goto retry; 1083 } 1084 1085 ENABLE_VPP(map); 1086 map_write(map, CMD(0x60), adr); 1087 map_write(map, CMD(0x01), adr); 1088 chip->state = FL_LOCKING; 1089 1090 mutex_unlock(&chip->mutex); 1091 msleep(1000); 1092 mutex_lock(&chip->mutex); 1093 1094 /* FIXME. Use a timer to check this, and return immediately. */ 1095 /* Once the state machine's known to be working I'll do that */ 1096 1097 timeo = jiffies + (HZ*2); 1098 for (;;) { 1099 1100 status = map_read(map, adr); 1101 if (map_word_andequal(map, status, status_OK, status_OK)) 1102 break; 1103 1104 /* OK Still waiting */ 1105 if (time_after(jiffies, timeo)) { 1106 map_write(map, CMD(0x70), adr); 1107 chip->state = FL_STATUS; 1108 printk(KERN_ERR "waiting for lock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]); 1109 DISABLE_VPP(map); 1110 mutex_unlock(&chip->mutex); 1111 return -EIO; 1112 } 1113 1114 /* Latency issues. Drop the lock, wait a while and retry */ 1115 mutex_unlock(&chip->mutex); 1116 cfi_udelay(1); 1117 mutex_lock(&chip->mutex); 1118 } 1119 1120 /* Done and happy. */ 1121 chip->state = FL_STATUS; 1122 DISABLE_VPP(map); 1123 wake_up(&chip->wq); 1124 mutex_unlock(&chip->mutex); 1125 return 0; 1126 } 1127 static int cfi_staa_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 1128 { 1129 struct map_info *map = mtd->priv; 1130 struct cfi_private *cfi = map->fldrv_priv; 1131 unsigned long adr; 1132 int chipnum, ret = 0; 1133 #ifdef DEBUG_LOCK_BITS 1134 int ofs_factor = cfi->interleave * cfi->device_type; 1135 #endif 1136 1137 if (ofs & (mtd->erasesize - 1)) 1138 return -EINVAL; 1139 1140 if (len & (mtd->erasesize -1)) 1141 return -EINVAL; 1142 1143 chipnum = ofs >> cfi->chipshift; 1144 adr = ofs - (chipnum << cfi->chipshift); 1145 1146 while(len) { 1147 1148 #ifdef DEBUG_LOCK_BITS 1149 cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL); 1150 printk("before lock: block status register is %x\n",cfi_read_query(map, adr+(2*ofs_factor))); 1151 cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL); 1152 #endif 1153 1154 ret = do_lock_oneblock(map, &cfi->chips[chipnum], adr); 1155 1156 #ifdef DEBUG_LOCK_BITS 1157 cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL); 1158 printk("after lock: block status register is %x\n",cfi_read_query(map, adr+(2*ofs_factor))); 1159 cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL); 1160 #endif 1161 1162 if (ret) 1163 return ret; 1164 1165 adr += mtd->erasesize; 1166 len -= mtd->erasesize; 1167 1168 if (adr >> cfi->chipshift) { 1169 adr = 0; 1170 chipnum++; 1171 1172 if (chipnum >= cfi->numchips) 1173 break; 1174 } 1175 } 1176 return 0; 1177 } 1178 static inline int do_unlock_oneblock(struct map_info *map, struct flchip *chip, unsigned long adr) 1179 { 1180 struct cfi_private *cfi = map->fldrv_priv; 1181 map_word status, status_OK; 1182 unsigned long timeo = jiffies + HZ; 1183 DECLARE_WAITQUEUE(wait, current); 1184 1185 adr += chip->start; 1186 1187 /* Let's determine this according to the interleave only once */ 1188 status_OK = CMD(0x80); 1189 1190 timeo = jiffies + HZ; 1191 retry: 1192 mutex_lock(&chip->mutex); 1193 1194 /* Check that the chip's ready to talk to us. */ 1195 switch (chip->state) { 1196 case FL_CFI_QUERY: 1197 case FL_JEDEC_QUERY: 1198 case FL_READY: 1199 map_write(map, CMD(0x70), adr); 1200 chip->state = FL_STATUS; 1201 1202 case FL_STATUS: 1203 status = map_read(map, adr); 1204 if (map_word_andequal(map, status, status_OK, status_OK)) 1205 break; 1206 1207 /* Urgh. Chip not yet ready to talk to us. */ 1208 if (time_after(jiffies, timeo)) { 1209 mutex_unlock(&chip->mutex); 1210 printk(KERN_ERR "waiting for chip to be ready timed out in unlock\n"); 1211 return -EIO; 1212 } 1213 1214 /* Latency issues. Drop the lock, wait a while and retry */ 1215 mutex_unlock(&chip->mutex); 1216 cfi_udelay(1); 1217 goto retry; 1218 1219 default: 1220 /* Stick ourselves on a wait queue to be woken when 1221 someone changes the status */ 1222 set_current_state(TASK_UNINTERRUPTIBLE); 1223 add_wait_queue(&chip->wq, &wait); 1224 mutex_unlock(&chip->mutex); 1225 schedule(); 1226 remove_wait_queue(&chip->wq, &wait); 1227 timeo = jiffies + HZ; 1228 goto retry; 1229 } 1230 1231 ENABLE_VPP(map); 1232 map_write(map, CMD(0x60), adr); 1233 map_write(map, CMD(0xD0), adr); 1234 chip->state = FL_UNLOCKING; 1235 1236 mutex_unlock(&chip->mutex); 1237 msleep(1000); 1238 mutex_lock(&chip->mutex); 1239 1240 /* FIXME. Use a timer to check this, and return immediately. */ 1241 /* Once the state machine's known to be working I'll do that */ 1242 1243 timeo = jiffies + (HZ*2); 1244 for (;;) { 1245 1246 status = map_read(map, adr); 1247 if (map_word_andequal(map, status, status_OK, status_OK)) 1248 break; 1249 1250 /* OK Still waiting */ 1251 if (time_after(jiffies, timeo)) { 1252 map_write(map, CMD(0x70), adr); 1253 chip->state = FL_STATUS; 1254 printk(KERN_ERR "waiting for unlock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]); 1255 DISABLE_VPP(map); 1256 mutex_unlock(&chip->mutex); 1257 return -EIO; 1258 } 1259 1260 /* Latency issues. Drop the unlock, wait a while and retry */ 1261 mutex_unlock(&chip->mutex); 1262 cfi_udelay(1); 1263 mutex_lock(&chip->mutex); 1264 } 1265 1266 /* Done and happy. */ 1267 chip->state = FL_STATUS; 1268 DISABLE_VPP(map); 1269 wake_up(&chip->wq); 1270 mutex_unlock(&chip->mutex); 1271 return 0; 1272 } 1273 static int cfi_staa_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 1274 { 1275 struct map_info *map = mtd->priv; 1276 struct cfi_private *cfi = map->fldrv_priv; 1277 unsigned long adr; 1278 int chipnum, ret = 0; 1279 #ifdef DEBUG_LOCK_BITS 1280 int ofs_factor = cfi->interleave * cfi->device_type; 1281 #endif 1282 1283 chipnum = ofs >> cfi->chipshift; 1284 adr = ofs - (chipnum << cfi->chipshift); 1285 1286 #ifdef DEBUG_LOCK_BITS 1287 { 1288 unsigned long temp_adr = adr; 1289 unsigned long temp_len = len; 1290 1291 cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL); 1292 while (temp_len) { 1293 printk("before unlock %x: block status register is %x\n",temp_adr,cfi_read_query(map, temp_adr+(2*ofs_factor))); 1294 temp_adr += mtd->erasesize; 1295 temp_len -= mtd->erasesize; 1296 } 1297 cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL); 1298 } 1299 #endif 1300 1301 ret = do_unlock_oneblock(map, &cfi->chips[chipnum], adr); 1302 1303 #ifdef DEBUG_LOCK_BITS 1304 cfi_send_gen_cmd(0x90, 0x55, 0, map, cfi, cfi->device_type, NULL); 1305 printk("after unlock: block status register is %x\n",cfi_read_query(map, adr+(2*ofs_factor))); 1306 cfi_send_gen_cmd(0xff, 0x55, 0, map, cfi, cfi->device_type, NULL); 1307 #endif 1308 1309 return ret; 1310 } 1311 1312 static int cfi_staa_suspend(struct mtd_info *mtd) 1313 { 1314 struct map_info *map = mtd->priv; 1315 struct cfi_private *cfi = map->fldrv_priv; 1316 int i; 1317 struct flchip *chip; 1318 int ret = 0; 1319 1320 for (i=0; !ret && i<cfi->numchips; i++) { 1321 chip = &cfi->chips[i]; 1322 1323 mutex_lock(&chip->mutex); 1324 1325 switch(chip->state) { 1326 case FL_READY: 1327 case FL_STATUS: 1328 case FL_CFI_QUERY: 1329 case FL_JEDEC_QUERY: 1330 chip->oldstate = chip->state; 1331 chip->state = FL_PM_SUSPENDED; 1332 /* No need to wake_up() on this state change - 1333 * as the whole point is that nobody can do anything 1334 * with the chip now anyway. 1335 */ 1336 case FL_PM_SUSPENDED: 1337 break; 1338 1339 default: 1340 ret = -EAGAIN; 1341 break; 1342 } 1343 mutex_unlock(&chip->mutex); 1344 } 1345 1346 /* Unlock the chips again */ 1347 1348 if (ret) { 1349 for (i--; i >=0; i--) { 1350 chip = &cfi->chips[i]; 1351 1352 mutex_lock(&chip->mutex); 1353 1354 if (chip->state == FL_PM_SUSPENDED) { 1355 /* No need to force it into a known state here, 1356 because we're returning failure, and it didn't 1357 get power cycled */ 1358 chip->state = chip->oldstate; 1359 wake_up(&chip->wq); 1360 } 1361 mutex_unlock(&chip->mutex); 1362 } 1363 } 1364 1365 return ret; 1366 } 1367 1368 static void cfi_staa_resume(struct mtd_info *mtd) 1369 { 1370 struct map_info *map = mtd->priv; 1371 struct cfi_private *cfi = map->fldrv_priv; 1372 int i; 1373 struct flchip *chip; 1374 1375 for (i=0; i<cfi->numchips; i++) { 1376 1377 chip = &cfi->chips[i]; 1378 1379 mutex_lock(&chip->mutex); 1380 1381 /* Go to known state. Chip may have been power cycled */ 1382 if (chip->state == FL_PM_SUSPENDED) { 1383 map_write(map, CMD(0xFF), 0); 1384 chip->state = FL_READY; 1385 wake_up(&chip->wq); 1386 } 1387 1388 mutex_unlock(&chip->mutex); 1389 } 1390 } 1391 1392 static void cfi_staa_destroy(struct mtd_info *mtd) 1393 { 1394 struct map_info *map = mtd->priv; 1395 struct cfi_private *cfi = map->fldrv_priv; 1396 kfree(cfi->cmdset_priv); 1397 kfree(cfi); 1398 } 1399 1400 MODULE_LICENSE("GPL"); 1401