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