1 /* 2 * Common Flash Interface support: 3 * Intel Extended Vendor Command Set (ID 0x0001) 4 * 5 * (C) 2000 Red Hat. GPL'd 6 * 7 * 8 * 10/10/2000 Nicolas Pitre <nico@fluxnic.net> 9 * - completely revamped method functions so they are aware and 10 * independent of the flash geometry (buswidth, interleave, etc.) 11 * - scalability vs code size is completely set at compile-time 12 * (see include/linux/mtd/cfi.h for selection) 13 * - optimized write buffer method 14 * 02/05/2002 Christopher Hoover <ch@hpl.hp.com>/<ch@murgatroid.com> 15 * - reworked lock/unlock/erase support for var size flash 16 * 21/03/2007 Rodolfo Giometti <giometti@linux.it> 17 * - auto unlock sectors on resume for auto locking flash on power up 18 */ 19 20 #include <linux/module.h> 21 #include <linux/types.h> 22 #include <linux/kernel.h> 23 #include <linux/sched.h> 24 #include <linux/init.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/reboot.h> 33 #include <linux/bitmap.h> 34 #include <linux/mtd/xip.h> 35 #include <linux/mtd/map.h> 36 #include <linux/mtd/mtd.h> 37 #include <linux/mtd/cfi.h> 38 39 /* #define CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE */ 40 /* #define CMDSET0001_DISABLE_WRITE_SUSPEND */ 41 42 // debugging, turns off buffer write mode if set to 1 43 #define FORCE_WORD_WRITE 0 44 45 /* Intel chips */ 46 #define I82802AB 0x00ad 47 #define I82802AC 0x00ac 48 #define PF38F4476 0x881c 49 /* STMicroelectronics chips */ 50 #define M50LPW080 0x002F 51 #define M50FLW080A 0x0080 52 #define M50FLW080B 0x0081 53 /* Atmel chips */ 54 #define AT49BV640D 0x02de 55 #define AT49BV640DT 0x02db 56 57 static int cfi_intelext_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *); 58 static int cfi_intelext_write_words(struct mtd_info *, loff_t, size_t, size_t *, const u_char *); 59 static int cfi_intelext_write_buffers(struct mtd_info *, loff_t, size_t, size_t *, const u_char *); 60 static int cfi_intelext_writev(struct mtd_info *, const struct kvec *, unsigned long, loff_t, size_t *); 61 static int cfi_intelext_erase_varsize(struct mtd_info *, struct erase_info *); 62 static void cfi_intelext_sync (struct mtd_info *); 63 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len); 64 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len); 65 static int cfi_intelext_is_locked(struct mtd_info *mtd, loff_t ofs, 66 uint64_t len); 67 #ifdef CONFIG_MTD_OTP 68 static int cfi_intelext_read_fact_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *); 69 static int cfi_intelext_read_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *); 70 static int cfi_intelext_write_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *); 71 static int cfi_intelext_lock_user_prot_reg (struct mtd_info *, loff_t, size_t); 72 static int cfi_intelext_get_fact_prot_info (struct mtd_info *, 73 struct otp_info *, size_t); 74 static int cfi_intelext_get_user_prot_info (struct mtd_info *, 75 struct otp_info *, size_t); 76 #endif 77 static int cfi_intelext_suspend (struct mtd_info *); 78 static void cfi_intelext_resume (struct mtd_info *); 79 static int cfi_intelext_reboot (struct notifier_block *, unsigned long, void *); 80 81 static void cfi_intelext_destroy(struct mtd_info *); 82 83 struct mtd_info *cfi_cmdset_0001(struct map_info *, int); 84 85 static struct mtd_info *cfi_intelext_setup (struct mtd_info *); 86 static int cfi_intelext_partition_fixup(struct mtd_info *, struct cfi_private **); 87 88 static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len, 89 size_t *retlen, void **virt, resource_size_t *phys); 90 static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len); 91 92 static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode); 93 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode); 94 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr); 95 #include "fwh_lock.h" 96 97 98 99 /* 100 * *********** SETUP AND PROBE BITS *********** 101 */ 102 103 static struct mtd_chip_driver cfi_intelext_chipdrv = { 104 .probe = NULL, /* Not usable directly */ 105 .destroy = cfi_intelext_destroy, 106 .name = "cfi_cmdset_0001", 107 .module = THIS_MODULE 108 }; 109 110 /* #define DEBUG_LOCK_BITS */ 111 /* #define DEBUG_CFI_FEATURES */ 112 113 #ifdef DEBUG_CFI_FEATURES 114 static void cfi_tell_features(struct cfi_pri_intelext *extp) 115 { 116 int i; 117 printk(" Extended Query version %c.%c\n", extp->MajorVersion, extp->MinorVersion); 118 printk(" Feature/Command Support: %4.4X\n", extp->FeatureSupport); 119 printk(" - Chip Erase: %s\n", extp->FeatureSupport&1?"supported":"unsupported"); 120 printk(" - Suspend Erase: %s\n", extp->FeatureSupport&2?"supported":"unsupported"); 121 printk(" - Suspend Program: %s\n", extp->FeatureSupport&4?"supported":"unsupported"); 122 printk(" - Legacy Lock/Unlock: %s\n", extp->FeatureSupport&8?"supported":"unsupported"); 123 printk(" - Queued Erase: %s\n", extp->FeatureSupport&16?"supported":"unsupported"); 124 printk(" - Instant block lock: %s\n", extp->FeatureSupport&32?"supported":"unsupported"); 125 printk(" - Protection Bits: %s\n", extp->FeatureSupport&64?"supported":"unsupported"); 126 printk(" - Page-mode read: %s\n", extp->FeatureSupport&128?"supported":"unsupported"); 127 printk(" - Synchronous read: %s\n", extp->FeatureSupport&256?"supported":"unsupported"); 128 printk(" - Simultaneous operations: %s\n", extp->FeatureSupport&512?"supported":"unsupported"); 129 printk(" - Extended Flash Array: %s\n", extp->FeatureSupport&1024?"supported":"unsupported"); 130 for (i=11; i<32; i++) { 131 if (extp->FeatureSupport & (1<<i)) 132 printk(" - Unknown Bit %X: supported\n", i); 133 } 134 135 printk(" Supported functions after Suspend: %2.2X\n", extp->SuspendCmdSupport); 136 printk(" - Program after Erase Suspend: %s\n", extp->SuspendCmdSupport&1?"supported":"unsupported"); 137 for (i=1; i<8; i++) { 138 if (extp->SuspendCmdSupport & (1<<i)) 139 printk(" - Unknown Bit %X: supported\n", i); 140 } 141 142 printk(" Block Status Register Mask: %4.4X\n", extp->BlkStatusRegMask); 143 printk(" - Lock Bit Active: %s\n", extp->BlkStatusRegMask&1?"yes":"no"); 144 printk(" - Lock-Down Bit Active: %s\n", extp->BlkStatusRegMask&2?"yes":"no"); 145 for (i=2; i<3; i++) { 146 if (extp->BlkStatusRegMask & (1<<i)) 147 printk(" - Unknown Bit %X Active: yes\n",i); 148 } 149 printk(" - EFA Lock Bit: %s\n", extp->BlkStatusRegMask&16?"yes":"no"); 150 printk(" - EFA Lock-Down Bit: %s\n", extp->BlkStatusRegMask&32?"yes":"no"); 151 for (i=6; i<16; i++) { 152 if (extp->BlkStatusRegMask & (1<<i)) 153 printk(" - Unknown Bit %X Active: yes\n",i); 154 } 155 156 printk(" Vcc Logic Supply Optimum Program/Erase Voltage: %d.%d V\n", 157 extp->VccOptimal >> 4, extp->VccOptimal & 0xf); 158 if (extp->VppOptimal) 159 printk(" Vpp Programming Supply Optimum Program/Erase Voltage: %d.%d V\n", 160 extp->VppOptimal >> 4, extp->VppOptimal & 0xf); 161 } 162 #endif 163 164 /* Atmel chips don't use the same PRI format as Intel chips */ 165 static void fixup_convert_atmel_pri(struct mtd_info *mtd) 166 { 167 struct map_info *map = mtd->priv; 168 struct cfi_private *cfi = map->fldrv_priv; 169 struct cfi_pri_intelext *extp = cfi->cmdset_priv; 170 struct cfi_pri_atmel atmel_pri; 171 uint32_t features = 0; 172 173 /* Reverse byteswapping */ 174 extp->FeatureSupport = cpu_to_le32(extp->FeatureSupport); 175 extp->BlkStatusRegMask = cpu_to_le16(extp->BlkStatusRegMask); 176 extp->ProtRegAddr = cpu_to_le16(extp->ProtRegAddr); 177 178 memcpy(&atmel_pri, extp, sizeof(atmel_pri)); 179 memset((char *)extp + 5, 0, sizeof(*extp) - 5); 180 181 printk(KERN_ERR "atmel Features: %02x\n", atmel_pri.Features); 182 183 if (atmel_pri.Features & 0x01) /* chip erase supported */ 184 features |= (1<<0); 185 if (atmel_pri.Features & 0x02) /* erase suspend supported */ 186 features |= (1<<1); 187 if (atmel_pri.Features & 0x04) /* program suspend supported */ 188 features |= (1<<2); 189 if (atmel_pri.Features & 0x08) /* simultaneous operations supported */ 190 features |= (1<<9); 191 if (atmel_pri.Features & 0x20) /* page mode read supported */ 192 features |= (1<<7); 193 if (atmel_pri.Features & 0x40) /* queued erase supported */ 194 features |= (1<<4); 195 if (atmel_pri.Features & 0x80) /* Protection bits supported */ 196 features |= (1<<6); 197 198 extp->FeatureSupport = features; 199 200 /* burst write mode not supported */ 201 cfi->cfiq->BufWriteTimeoutTyp = 0; 202 cfi->cfiq->BufWriteTimeoutMax = 0; 203 } 204 205 static void fixup_at49bv640dx_lock(struct mtd_info *mtd) 206 { 207 struct map_info *map = mtd->priv; 208 struct cfi_private *cfi = map->fldrv_priv; 209 struct cfi_pri_intelext *cfip = cfi->cmdset_priv; 210 211 cfip->FeatureSupport |= (1 << 5); 212 mtd->flags |= MTD_POWERUP_LOCK; 213 } 214 215 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE 216 /* Some Intel Strata Flash prior to FPO revision C has bugs in this area */ 217 static void fixup_intel_strataflash(struct mtd_info *mtd) 218 { 219 struct map_info *map = mtd->priv; 220 struct cfi_private *cfi = map->fldrv_priv; 221 struct cfi_pri_intelext *extp = cfi->cmdset_priv; 222 223 printk(KERN_WARNING "cfi_cmdset_0001: Suspend " 224 "erase on write disabled.\n"); 225 extp->SuspendCmdSupport &= ~1; 226 } 227 #endif 228 229 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND 230 static void fixup_no_write_suspend(struct mtd_info *mtd) 231 { 232 struct map_info *map = mtd->priv; 233 struct cfi_private *cfi = map->fldrv_priv; 234 struct cfi_pri_intelext *cfip = cfi->cmdset_priv; 235 236 if (cfip && (cfip->FeatureSupport&4)) { 237 cfip->FeatureSupport &= ~4; 238 printk(KERN_WARNING "cfi_cmdset_0001: write suspend disabled\n"); 239 } 240 } 241 #endif 242 243 static void fixup_st_m28w320ct(struct mtd_info *mtd) 244 { 245 struct map_info *map = mtd->priv; 246 struct cfi_private *cfi = map->fldrv_priv; 247 248 cfi->cfiq->BufWriteTimeoutTyp = 0; /* Not supported */ 249 cfi->cfiq->BufWriteTimeoutMax = 0; /* Not supported */ 250 } 251 252 static void fixup_st_m28w320cb(struct mtd_info *mtd) 253 { 254 struct map_info *map = mtd->priv; 255 struct cfi_private *cfi = map->fldrv_priv; 256 257 /* Note this is done after the region info is endian swapped */ 258 cfi->cfiq->EraseRegionInfo[1] = 259 (cfi->cfiq->EraseRegionInfo[1] & 0xffff0000) | 0x3e; 260 }; 261 262 static void fixup_use_point(struct mtd_info *mtd) 263 { 264 struct map_info *map = mtd->priv; 265 if (!mtd->_point && map_is_linear(map)) { 266 mtd->_point = cfi_intelext_point; 267 mtd->_unpoint = cfi_intelext_unpoint; 268 } 269 } 270 271 static void fixup_use_write_buffers(struct mtd_info *mtd) 272 { 273 struct map_info *map = mtd->priv; 274 struct cfi_private *cfi = map->fldrv_priv; 275 if (cfi->cfiq->BufWriteTimeoutTyp) { 276 printk(KERN_INFO "Using buffer write method\n" ); 277 mtd->_write = cfi_intelext_write_buffers; 278 mtd->_writev = cfi_intelext_writev; 279 } 280 } 281 282 /* 283 * Some chips power-up with all sectors locked by default. 284 */ 285 static void fixup_unlock_powerup_lock(struct mtd_info *mtd) 286 { 287 struct map_info *map = mtd->priv; 288 struct cfi_private *cfi = map->fldrv_priv; 289 struct cfi_pri_intelext *cfip = cfi->cmdset_priv; 290 291 if (cfip->FeatureSupport&32) { 292 printk(KERN_INFO "Using auto-unlock on power-up/resume\n" ); 293 mtd->flags |= MTD_POWERUP_LOCK; 294 } 295 } 296 297 static struct cfi_fixup cfi_fixup_table[] = { 298 { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri }, 299 { CFI_MFR_ATMEL, AT49BV640D, fixup_at49bv640dx_lock }, 300 { CFI_MFR_ATMEL, AT49BV640DT, fixup_at49bv640dx_lock }, 301 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE 302 { CFI_MFR_ANY, CFI_ID_ANY, fixup_intel_strataflash }, 303 #endif 304 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND 305 { CFI_MFR_ANY, CFI_ID_ANY, fixup_no_write_suspend }, 306 #endif 307 #if !FORCE_WORD_WRITE 308 { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers }, 309 #endif 310 { CFI_MFR_ST, 0x00ba, /* M28W320CT */ fixup_st_m28w320ct }, 311 { CFI_MFR_ST, 0x00bb, /* M28W320CB */ fixup_st_m28w320cb }, 312 { CFI_MFR_INTEL, CFI_ID_ANY, fixup_unlock_powerup_lock }, 313 { 0, 0, NULL } 314 }; 315 316 static struct cfi_fixup jedec_fixup_table[] = { 317 { CFI_MFR_INTEL, I82802AB, fixup_use_fwh_lock }, 318 { CFI_MFR_INTEL, I82802AC, fixup_use_fwh_lock }, 319 { CFI_MFR_ST, M50LPW080, fixup_use_fwh_lock }, 320 { CFI_MFR_ST, M50FLW080A, fixup_use_fwh_lock }, 321 { CFI_MFR_ST, M50FLW080B, fixup_use_fwh_lock }, 322 { 0, 0, NULL } 323 }; 324 static struct cfi_fixup fixup_table[] = { 325 /* The CFI vendor ids and the JEDEC vendor IDs appear 326 * to be common. It is like the devices id's are as 327 * well. This table is to pick all cases where 328 * we know that is the case. 329 */ 330 { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_point }, 331 { 0, 0, NULL } 332 }; 333 334 static void cfi_fixup_major_minor(struct cfi_private *cfi, 335 struct cfi_pri_intelext *extp) 336 { 337 if (cfi->mfr == CFI_MFR_INTEL && 338 cfi->id == PF38F4476 && extp->MinorVersion == '3') 339 extp->MinorVersion = '1'; 340 } 341 342 static inline struct cfi_pri_intelext * 343 read_pri_intelext(struct map_info *map, __u16 adr) 344 { 345 struct cfi_private *cfi = map->fldrv_priv; 346 struct cfi_pri_intelext *extp; 347 unsigned int extra_size = 0; 348 unsigned int extp_size = sizeof(*extp); 349 350 again: 351 extp = (struct cfi_pri_intelext *)cfi_read_pri(map, adr, extp_size, "Intel/Sharp"); 352 if (!extp) 353 return NULL; 354 355 cfi_fixup_major_minor(cfi, extp); 356 357 if (extp->MajorVersion != '1' || 358 (extp->MinorVersion < '0' || extp->MinorVersion > '5')) { 359 printk(KERN_ERR " Unknown Intel/Sharp Extended Query " 360 "version %c.%c.\n", extp->MajorVersion, 361 extp->MinorVersion); 362 kfree(extp); 363 return NULL; 364 } 365 366 /* Do some byteswapping if necessary */ 367 extp->FeatureSupport = le32_to_cpu(extp->FeatureSupport); 368 extp->BlkStatusRegMask = le16_to_cpu(extp->BlkStatusRegMask); 369 extp->ProtRegAddr = le16_to_cpu(extp->ProtRegAddr); 370 371 if (extp->MinorVersion >= '0') { 372 extra_size = 0; 373 374 /* Protection Register info */ 375 extra_size += (extp->NumProtectionFields - 1) * 376 sizeof(struct cfi_intelext_otpinfo); 377 } 378 379 if (extp->MinorVersion >= '1') { 380 /* Burst Read info */ 381 extra_size += 2; 382 if (extp_size < sizeof(*extp) + extra_size) 383 goto need_more; 384 extra_size += extp->extra[extra_size - 1]; 385 } 386 387 if (extp->MinorVersion >= '3') { 388 int nb_parts, i; 389 390 /* Number of hardware-partitions */ 391 extra_size += 1; 392 if (extp_size < sizeof(*extp) + extra_size) 393 goto need_more; 394 nb_parts = extp->extra[extra_size - 1]; 395 396 /* skip the sizeof(partregion) field in CFI 1.4 */ 397 if (extp->MinorVersion >= '4') 398 extra_size += 2; 399 400 for (i = 0; i < nb_parts; i++) { 401 struct cfi_intelext_regioninfo *rinfo; 402 rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[extra_size]; 403 extra_size += sizeof(*rinfo); 404 if (extp_size < sizeof(*extp) + extra_size) 405 goto need_more; 406 rinfo->NumIdentPartitions=le16_to_cpu(rinfo->NumIdentPartitions); 407 extra_size += (rinfo->NumBlockTypes - 1) 408 * sizeof(struct cfi_intelext_blockinfo); 409 } 410 411 if (extp->MinorVersion >= '4') 412 extra_size += sizeof(struct cfi_intelext_programming_regioninfo); 413 414 if (extp_size < sizeof(*extp) + extra_size) { 415 need_more: 416 extp_size = sizeof(*extp) + extra_size; 417 kfree(extp); 418 if (extp_size > 4096) { 419 printk(KERN_ERR 420 "%s: cfi_pri_intelext is too fat\n", 421 __func__); 422 return NULL; 423 } 424 goto again; 425 } 426 } 427 428 return extp; 429 } 430 431 struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary) 432 { 433 struct cfi_private *cfi = map->fldrv_priv; 434 struct mtd_info *mtd; 435 int i; 436 437 mtd = kzalloc(sizeof(*mtd), GFP_KERNEL); 438 if (!mtd) { 439 printk(KERN_ERR "Failed to allocate memory for MTD device\n"); 440 return NULL; 441 } 442 mtd->priv = map; 443 mtd->type = MTD_NORFLASH; 444 445 /* Fill in the default mtd operations */ 446 mtd->_erase = cfi_intelext_erase_varsize; 447 mtd->_read = cfi_intelext_read; 448 mtd->_write = cfi_intelext_write_words; 449 mtd->_sync = cfi_intelext_sync; 450 mtd->_lock = cfi_intelext_lock; 451 mtd->_unlock = cfi_intelext_unlock; 452 mtd->_is_locked = cfi_intelext_is_locked; 453 mtd->_suspend = cfi_intelext_suspend; 454 mtd->_resume = cfi_intelext_resume; 455 mtd->flags = MTD_CAP_NORFLASH; 456 mtd->name = map->name; 457 mtd->writesize = 1; 458 mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize; 459 460 mtd->reboot_notifier.notifier_call = cfi_intelext_reboot; 461 462 if (cfi->cfi_mode == CFI_MODE_CFI) { 463 /* 464 * It's a real CFI chip, not one for which the probe 465 * routine faked a CFI structure. So we read the feature 466 * table from it. 467 */ 468 __u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR; 469 struct cfi_pri_intelext *extp; 470 471 extp = read_pri_intelext(map, adr); 472 if (!extp) { 473 kfree(mtd); 474 return NULL; 475 } 476 477 /* Install our own private info structure */ 478 cfi->cmdset_priv = extp; 479 480 cfi_fixup(mtd, cfi_fixup_table); 481 482 #ifdef DEBUG_CFI_FEATURES 483 /* Tell the user about it in lots of lovely detail */ 484 cfi_tell_features(extp); 485 #endif 486 487 if(extp->SuspendCmdSupport & 1) { 488 printk(KERN_NOTICE "cfi_cmdset_0001: Erase suspend on write enabled\n"); 489 } 490 } 491 else if (cfi->cfi_mode == CFI_MODE_JEDEC) { 492 /* Apply jedec specific fixups */ 493 cfi_fixup(mtd, jedec_fixup_table); 494 } 495 /* Apply generic fixups */ 496 cfi_fixup(mtd, fixup_table); 497 498 for (i=0; i< cfi->numchips; i++) { 499 if (cfi->cfiq->WordWriteTimeoutTyp) 500 cfi->chips[i].word_write_time = 501 1<<cfi->cfiq->WordWriteTimeoutTyp; 502 else 503 cfi->chips[i].word_write_time = 50000; 504 505 if (cfi->cfiq->BufWriteTimeoutTyp) 506 cfi->chips[i].buffer_write_time = 507 1<<cfi->cfiq->BufWriteTimeoutTyp; 508 /* No default; if it isn't specified, we won't use it */ 509 510 if (cfi->cfiq->BlockEraseTimeoutTyp) 511 cfi->chips[i].erase_time = 512 1000<<cfi->cfiq->BlockEraseTimeoutTyp; 513 else 514 cfi->chips[i].erase_time = 2000000; 515 516 if (cfi->cfiq->WordWriteTimeoutTyp && 517 cfi->cfiq->WordWriteTimeoutMax) 518 cfi->chips[i].word_write_time_max = 519 1<<(cfi->cfiq->WordWriteTimeoutTyp + 520 cfi->cfiq->WordWriteTimeoutMax); 521 else 522 cfi->chips[i].word_write_time_max = 50000 * 8; 523 524 if (cfi->cfiq->BufWriteTimeoutTyp && 525 cfi->cfiq->BufWriteTimeoutMax) 526 cfi->chips[i].buffer_write_time_max = 527 1<<(cfi->cfiq->BufWriteTimeoutTyp + 528 cfi->cfiq->BufWriteTimeoutMax); 529 530 if (cfi->cfiq->BlockEraseTimeoutTyp && 531 cfi->cfiq->BlockEraseTimeoutMax) 532 cfi->chips[i].erase_time_max = 533 1000<<(cfi->cfiq->BlockEraseTimeoutTyp + 534 cfi->cfiq->BlockEraseTimeoutMax); 535 else 536 cfi->chips[i].erase_time_max = 2000000 * 8; 537 538 cfi->chips[i].ref_point_counter = 0; 539 init_waitqueue_head(&(cfi->chips[i].wq)); 540 } 541 542 map->fldrv = &cfi_intelext_chipdrv; 543 544 return cfi_intelext_setup(mtd); 545 } 546 struct mtd_info *cfi_cmdset_0003(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001"))); 547 struct mtd_info *cfi_cmdset_0200(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001"))); 548 EXPORT_SYMBOL_GPL(cfi_cmdset_0001); 549 EXPORT_SYMBOL_GPL(cfi_cmdset_0003); 550 EXPORT_SYMBOL_GPL(cfi_cmdset_0200); 551 552 static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd) 553 { 554 struct map_info *map = mtd->priv; 555 struct cfi_private *cfi = map->fldrv_priv; 556 unsigned long offset = 0; 557 int i,j; 558 unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave; 559 560 //printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips); 561 562 mtd->size = devsize * cfi->numchips; 563 564 mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips; 565 mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info) 566 * mtd->numeraseregions, GFP_KERNEL); 567 if (!mtd->eraseregions) { 568 printk(KERN_ERR "Failed to allocate memory for MTD erase region info\n"); 569 goto setup_err; 570 } 571 572 for (i=0; i<cfi->cfiq->NumEraseRegions; i++) { 573 unsigned long ernum, ersize; 574 ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave; 575 ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1; 576 577 if (mtd->erasesize < ersize) { 578 mtd->erasesize = ersize; 579 } 580 for (j=0; j<cfi->numchips; j++) { 581 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset; 582 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize; 583 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum; 584 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].lockmap = kmalloc(ernum / 8 + 1, GFP_KERNEL); 585 } 586 offset += (ersize * ernum); 587 } 588 589 if (offset != devsize) { 590 /* Argh */ 591 printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize); 592 goto setup_err; 593 } 594 595 for (i=0; i<mtd->numeraseregions;i++){ 596 printk(KERN_DEBUG "erase region %d: offset=0x%llx,size=0x%x,blocks=%d\n", 597 i,(unsigned long long)mtd->eraseregions[i].offset, 598 mtd->eraseregions[i].erasesize, 599 mtd->eraseregions[i].numblocks); 600 } 601 602 #ifdef CONFIG_MTD_OTP 603 mtd->_read_fact_prot_reg = cfi_intelext_read_fact_prot_reg; 604 mtd->_read_user_prot_reg = cfi_intelext_read_user_prot_reg; 605 mtd->_write_user_prot_reg = cfi_intelext_write_user_prot_reg; 606 mtd->_lock_user_prot_reg = cfi_intelext_lock_user_prot_reg; 607 mtd->_get_fact_prot_info = cfi_intelext_get_fact_prot_info; 608 mtd->_get_user_prot_info = cfi_intelext_get_user_prot_info; 609 #endif 610 611 /* This function has the potential to distort the reality 612 a bit and therefore should be called last. */ 613 if (cfi_intelext_partition_fixup(mtd, &cfi) != 0) 614 goto setup_err; 615 616 __module_get(THIS_MODULE); 617 register_reboot_notifier(&mtd->reboot_notifier); 618 return mtd; 619 620 setup_err: 621 kfree(mtd->eraseregions); 622 kfree(mtd); 623 kfree(cfi->cmdset_priv); 624 return NULL; 625 } 626 627 static int cfi_intelext_partition_fixup(struct mtd_info *mtd, 628 struct cfi_private **pcfi) 629 { 630 struct map_info *map = mtd->priv; 631 struct cfi_private *cfi = *pcfi; 632 struct cfi_pri_intelext *extp = cfi->cmdset_priv; 633 634 /* 635 * Probing of multi-partition flash chips. 636 * 637 * To support multiple partitions when available, we simply arrange 638 * for each of them to have their own flchip structure even if they 639 * are on the same physical chip. This means completely recreating 640 * a new cfi_private structure right here which is a blatent code 641 * layering violation, but this is still the least intrusive 642 * arrangement at this point. This can be rearranged in the future 643 * if someone feels motivated enough. --nico 644 */ 645 if (extp && extp->MajorVersion == '1' && extp->MinorVersion >= '3' 646 && extp->FeatureSupport & (1 << 9)) { 647 struct cfi_private *newcfi; 648 struct flchip *chip; 649 struct flchip_shared *shared; 650 int offs, numregions, numparts, partshift, numvirtchips, i, j; 651 652 /* Protection Register info */ 653 offs = (extp->NumProtectionFields - 1) * 654 sizeof(struct cfi_intelext_otpinfo); 655 656 /* Burst Read info */ 657 offs += extp->extra[offs+1]+2; 658 659 /* Number of partition regions */ 660 numregions = extp->extra[offs]; 661 offs += 1; 662 663 /* skip the sizeof(partregion) field in CFI 1.4 */ 664 if (extp->MinorVersion >= '4') 665 offs += 2; 666 667 /* Number of hardware partitions */ 668 numparts = 0; 669 for (i = 0; i < numregions; i++) { 670 struct cfi_intelext_regioninfo *rinfo; 671 rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[offs]; 672 numparts += rinfo->NumIdentPartitions; 673 offs += sizeof(*rinfo) 674 + (rinfo->NumBlockTypes - 1) * 675 sizeof(struct cfi_intelext_blockinfo); 676 } 677 678 if (!numparts) 679 numparts = 1; 680 681 /* Programming Region info */ 682 if (extp->MinorVersion >= '4') { 683 struct cfi_intelext_programming_regioninfo *prinfo; 684 prinfo = (struct cfi_intelext_programming_regioninfo *)&extp->extra[offs]; 685 mtd->writesize = cfi->interleave << prinfo->ProgRegShift; 686 mtd->flags &= ~MTD_BIT_WRITEABLE; 687 printk(KERN_DEBUG "%s: program region size/ctrl_valid/ctrl_inval = %d/%d/%d\n", 688 map->name, mtd->writesize, 689 cfi->interleave * prinfo->ControlValid, 690 cfi->interleave * prinfo->ControlInvalid); 691 } 692 693 /* 694 * All functions below currently rely on all chips having 695 * the same geometry so we'll just assume that all hardware 696 * partitions are of the same size too. 697 */ 698 partshift = cfi->chipshift - __ffs(numparts); 699 700 if ((1 << partshift) < mtd->erasesize) { 701 printk( KERN_ERR 702 "%s: bad number of hw partitions (%d)\n", 703 __func__, numparts); 704 return -EINVAL; 705 } 706 707 numvirtchips = cfi->numchips * numparts; 708 newcfi = kmalloc(sizeof(struct cfi_private) + numvirtchips * sizeof(struct flchip), GFP_KERNEL); 709 if (!newcfi) 710 return -ENOMEM; 711 shared = kmalloc(sizeof(struct flchip_shared) * cfi->numchips, GFP_KERNEL); 712 if (!shared) { 713 kfree(newcfi); 714 return -ENOMEM; 715 } 716 memcpy(newcfi, cfi, sizeof(struct cfi_private)); 717 newcfi->numchips = numvirtchips; 718 newcfi->chipshift = partshift; 719 720 chip = &newcfi->chips[0]; 721 for (i = 0; i < cfi->numchips; i++) { 722 shared[i].writing = shared[i].erasing = NULL; 723 mutex_init(&shared[i].lock); 724 for (j = 0; j < numparts; j++) { 725 *chip = cfi->chips[i]; 726 chip->start += j << partshift; 727 chip->priv = &shared[i]; 728 /* those should be reset too since 729 they create memory references. */ 730 init_waitqueue_head(&chip->wq); 731 mutex_init(&chip->mutex); 732 chip++; 733 } 734 } 735 736 printk(KERN_DEBUG "%s: %d set(s) of %d interleaved chips " 737 "--> %d partitions of %d KiB\n", 738 map->name, cfi->numchips, cfi->interleave, 739 newcfi->numchips, 1<<(newcfi->chipshift-10)); 740 741 map->fldrv_priv = newcfi; 742 *pcfi = newcfi; 743 kfree(cfi); 744 } 745 746 return 0; 747 } 748 749 /* 750 * *********** CHIP ACCESS FUNCTIONS *********** 751 */ 752 static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode) 753 { 754 DECLARE_WAITQUEUE(wait, current); 755 struct cfi_private *cfi = map->fldrv_priv; 756 map_word status, status_OK = CMD(0x80), status_PWS = CMD(0x01); 757 struct cfi_pri_intelext *cfip = cfi->cmdset_priv; 758 unsigned long timeo = jiffies + HZ; 759 760 /* Prevent setting state FL_SYNCING for chip in suspended state. */ 761 if (mode == FL_SYNCING && chip->oldstate != FL_READY) 762 goto sleep; 763 764 switch (chip->state) { 765 766 case FL_STATUS: 767 for (;;) { 768 status = map_read(map, adr); 769 if (map_word_andequal(map, status, status_OK, status_OK)) 770 break; 771 772 /* At this point we're fine with write operations 773 in other partitions as they don't conflict. */ 774 if (chip->priv && map_word_andequal(map, status, status_PWS, status_PWS)) 775 break; 776 777 mutex_unlock(&chip->mutex); 778 cfi_udelay(1); 779 mutex_lock(&chip->mutex); 780 /* Someone else might have been playing with it. */ 781 return -EAGAIN; 782 } 783 /* Fall through */ 784 case FL_READY: 785 case FL_CFI_QUERY: 786 case FL_JEDEC_QUERY: 787 return 0; 788 789 case FL_ERASING: 790 if (!cfip || 791 !(cfip->FeatureSupport & 2) || 792 !(mode == FL_READY || mode == FL_POINT || 793 (mode == FL_WRITING && (cfip->SuspendCmdSupport & 1)))) 794 goto sleep; 795 796 797 /* Erase suspend */ 798 map_write(map, CMD(0xB0), adr); 799 800 /* If the flash has finished erasing, then 'erase suspend' 801 * appears to make some (28F320) flash devices switch to 802 * 'read' mode. Make sure that we switch to 'read status' 803 * mode so we get the right data. --rmk 804 */ 805 map_write(map, CMD(0x70), adr); 806 chip->oldstate = FL_ERASING; 807 chip->state = FL_ERASE_SUSPENDING; 808 chip->erase_suspended = 1; 809 for (;;) { 810 status = map_read(map, adr); 811 if (map_word_andequal(map, status, status_OK, status_OK)) 812 break; 813 814 if (time_after(jiffies, timeo)) { 815 /* Urgh. Resume and pretend we weren't here. 816 * Make sure we're in 'read status' mode if it had finished */ 817 put_chip(map, chip, adr); 818 printk(KERN_ERR "%s: Chip not ready after erase " 819 "suspended: status = 0x%lx\n", map->name, status.x[0]); 820 return -EIO; 821 } 822 823 mutex_unlock(&chip->mutex); 824 cfi_udelay(1); 825 mutex_lock(&chip->mutex); 826 /* Nobody will touch it while it's in state FL_ERASE_SUSPENDING. 827 So we can just loop here. */ 828 } 829 chip->state = FL_STATUS; 830 return 0; 831 832 case FL_XIP_WHILE_ERASING: 833 if (mode != FL_READY && mode != FL_POINT && 834 (mode != FL_WRITING || !cfip || !(cfip->SuspendCmdSupport&1))) 835 goto sleep; 836 chip->oldstate = chip->state; 837 chip->state = FL_READY; 838 return 0; 839 840 case FL_SHUTDOWN: 841 /* The machine is rebooting now,so no one can get chip anymore */ 842 return -EIO; 843 case FL_POINT: 844 /* Only if there's no operation suspended... */ 845 if (mode == FL_READY && chip->oldstate == FL_READY) 846 return 0; 847 /* Fall through */ 848 default: 849 sleep: 850 set_current_state(TASK_UNINTERRUPTIBLE); 851 add_wait_queue(&chip->wq, &wait); 852 mutex_unlock(&chip->mutex); 853 schedule(); 854 remove_wait_queue(&chip->wq, &wait); 855 mutex_lock(&chip->mutex); 856 return -EAGAIN; 857 } 858 } 859 860 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode) 861 { 862 int ret; 863 DECLARE_WAITQUEUE(wait, current); 864 865 retry: 866 if (chip->priv && 867 (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE 868 || mode == FL_SHUTDOWN) && chip->state != FL_SYNCING) { 869 /* 870 * OK. We have possibility for contention on the write/erase 871 * operations which are global to the real chip and not per 872 * partition. So let's fight it over in the partition which 873 * currently has authority on the operation. 874 * 875 * The rules are as follows: 876 * 877 * - any write operation must own shared->writing. 878 * 879 * - any erase operation must own _both_ shared->writing and 880 * shared->erasing. 881 * 882 * - contention arbitration is handled in the owner's context. 883 * 884 * The 'shared' struct can be read and/or written only when 885 * its lock is taken. 886 */ 887 struct flchip_shared *shared = chip->priv; 888 struct flchip *contender; 889 mutex_lock(&shared->lock); 890 contender = shared->writing; 891 if (contender && contender != chip) { 892 /* 893 * The engine to perform desired operation on this 894 * partition is already in use by someone else. 895 * Let's fight over it in the context of the chip 896 * currently using it. If it is possible to suspend, 897 * that other partition will do just that, otherwise 898 * it'll happily send us to sleep. In any case, when 899 * get_chip returns success we're clear to go ahead. 900 */ 901 ret = mutex_trylock(&contender->mutex); 902 mutex_unlock(&shared->lock); 903 if (!ret) 904 goto retry; 905 mutex_unlock(&chip->mutex); 906 ret = chip_ready(map, contender, contender->start, mode); 907 mutex_lock(&chip->mutex); 908 909 if (ret == -EAGAIN) { 910 mutex_unlock(&contender->mutex); 911 goto retry; 912 } 913 if (ret) { 914 mutex_unlock(&contender->mutex); 915 return ret; 916 } 917 mutex_lock(&shared->lock); 918 919 /* We should not own chip if it is already 920 * in FL_SYNCING state. Put contender and retry. */ 921 if (chip->state == FL_SYNCING) { 922 put_chip(map, contender, contender->start); 923 mutex_unlock(&contender->mutex); 924 goto retry; 925 } 926 mutex_unlock(&contender->mutex); 927 } 928 929 /* Check if we already have suspended erase 930 * on this chip. Sleep. */ 931 if (mode == FL_ERASING && shared->erasing 932 && shared->erasing->oldstate == FL_ERASING) { 933 mutex_unlock(&shared->lock); 934 set_current_state(TASK_UNINTERRUPTIBLE); 935 add_wait_queue(&chip->wq, &wait); 936 mutex_unlock(&chip->mutex); 937 schedule(); 938 remove_wait_queue(&chip->wq, &wait); 939 mutex_lock(&chip->mutex); 940 goto retry; 941 } 942 943 /* We now own it */ 944 shared->writing = chip; 945 if (mode == FL_ERASING) 946 shared->erasing = chip; 947 mutex_unlock(&shared->lock); 948 } 949 ret = chip_ready(map, chip, adr, mode); 950 if (ret == -EAGAIN) 951 goto retry; 952 953 return ret; 954 } 955 956 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr) 957 { 958 struct cfi_private *cfi = map->fldrv_priv; 959 960 if (chip->priv) { 961 struct flchip_shared *shared = chip->priv; 962 mutex_lock(&shared->lock); 963 if (shared->writing == chip && chip->oldstate == FL_READY) { 964 /* We own the ability to write, but we're done */ 965 shared->writing = shared->erasing; 966 if (shared->writing && shared->writing != chip) { 967 /* give back ownership to who we loaned it from */ 968 struct flchip *loaner = shared->writing; 969 mutex_lock(&loaner->mutex); 970 mutex_unlock(&shared->lock); 971 mutex_unlock(&chip->mutex); 972 put_chip(map, loaner, loaner->start); 973 mutex_lock(&chip->mutex); 974 mutex_unlock(&loaner->mutex); 975 wake_up(&chip->wq); 976 return; 977 } 978 shared->erasing = NULL; 979 shared->writing = NULL; 980 } else if (shared->erasing == chip && shared->writing != chip) { 981 /* 982 * We own the ability to erase without the ability 983 * to write, which means the erase was suspended 984 * and some other partition is currently writing. 985 * Don't let the switch below mess things up since 986 * we don't have ownership to resume anything. 987 */ 988 mutex_unlock(&shared->lock); 989 wake_up(&chip->wq); 990 return; 991 } 992 mutex_unlock(&shared->lock); 993 } 994 995 switch(chip->oldstate) { 996 case FL_ERASING: 997 /* What if one interleaved chip has finished and the 998 other hasn't? The old code would leave the finished 999 one in READY mode. That's bad, and caused -EROFS 1000 errors to be returned from do_erase_oneblock because 1001 that's the only bit it checked for at the time. 1002 As the state machine appears to explicitly allow 1003 sending the 0x70 (Read Status) command to an erasing 1004 chip and expecting it to be ignored, that's what we 1005 do. */ 1006 map_write(map, CMD(0xd0), adr); 1007 map_write(map, CMD(0x70), adr); 1008 chip->oldstate = FL_READY; 1009 chip->state = FL_ERASING; 1010 break; 1011 1012 case FL_XIP_WHILE_ERASING: 1013 chip->state = chip->oldstate; 1014 chip->oldstate = FL_READY; 1015 break; 1016 1017 case FL_READY: 1018 case FL_STATUS: 1019 case FL_JEDEC_QUERY: 1020 break; 1021 default: 1022 printk(KERN_ERR "%s: put_chip() called with oldstate %d!!\n", map->name, chip->oldstate); 1023 } 1024 wake_up(&chip->wq); 1025 } 1026 1027 #ifdef CONFIG_MTD_XIP 1028 1029 /* 1030 * No interrupt what so ever can be serviced while the flash isn't in array 1031 * mode. This is ensured by the xip_disable() and xip_enable() functions 1032 * enclosing any code path where the flash is known not to be in array mode. 1033 * And within a XIP disabled code path, only functions marked with __xipram 1034 * may be called and nothing else (it's a good thing to inspect generated 1035 * assembly to make sure inline functions were actually inlined and that gcc 1036 * didn't emit calls to its own support functions). Also configuring MTD CFI 1037 * support to a single buswidth and a single interleave is also recommended. 1038 */ 1039 1040 static void xip_disable(struct map_info *map, struct flchip *chip, 1041 unsigned long adr) 1042 { 1043 /* TODO: chips with no XIP use should ignore and return */ 1044 (void) map_read(map, adr); /* ensure mmu mapping is up to date */ 1045 local_irq_disable(); 1046 } 1047 1048 static void __xipram xip_enable(struct map_info *map, struct flchip *chip, 1049 unsigned long adr) 1050 { 1051 struct cfi_private *cfi = map->fldrv_priv; 1052 if (chip->state != FL_POINT && chip->state != FL_READY) { 1053 map_write(map, CMD(0xff), adr); 1054 chip->state = FL_READY; 1055 } 1056 (void) map_read(map, adr); 1057 xip_iprefetch(); 1058 local_irq_enable(); 1059 } 1060 1061 /* 1062 * When a delay is required for the flash operation to complete, the 1063 * xip_wait_for_operation() function is polling for both the given timeout 1064 * and pending (but still masked) hardware interrupts. Whenever there is an 1065 * interrupt pending then the flash erase or write operation is suspended, 1066 * array mode restored and interrupts unmasked. Task scheduling might also 1067 * happen at that point. The CPU eventually returns from the interrupt or 1068 * the call to schedule() and the suspended flash operation is resumed for 1069 * the remaining of the delay period. 1070 * 1071 * Warning: this function _will_ fool interrupt latency tracing tools. 1072 */ 1073 1074 static int __xipram xip_wait_for_operation( 1075 struct map_info *map, struct flchip *chip, 1076 unsigned long adr, unsigned int chip_op_time_max) 1077 { 1078 struct cfi_private *cfi = map->fldrv_priv; 1079 struct cfi_pri_intelext *cfip = cfi->cmdset_priv; 1080 map_word status, OK = CMD(0x80); 1081 unsigned long usec, suspended, start, done; 1082 flstate_t oldstate, newstate; 1083 1084 start = xip_currtime(); 1085 usec = chip_op_time_max; 1086 if (usec == 0) 1087 usec = 500000; 1088 done = 0; 1089 1090 do { 1091 cpu_relax(); 1092 if (xip_irqpending() && cfip && 1093 ((chip->state == FL_ERASING && (cfip->FeatureSupport&2)) || 1094 (chip->state == FL_WRITING && (cfip->FeatureSupport&4))) && 1095 (cfi_interleave_is_1(cfi) || chip->oldstate == FL_READY)) { 1096 /* 1097 * Let's suspend the erase or write operation when 1098 * supported. Note that we currently don't try to 1099 * suspend interleaved chips if there is already 1100 * another operation suspended (imagine what happens 1101 * when one chip was already done with the current 1102 * operation while another chip suspended it, then 1103 * we resume the whole thing at once). Yes, it 1104 * can happen! 1105 */ 1106 usec -= done; 1107 map_write(map, CMD(0xb0), adr); 1108 map_write(map, CMD(0x70), adr); 1109 suspended = xip_currtime(); 1110 do { 1111 if (xip_elapsed_since(suspended) > 100000) { 1112 /* 1113 * The chip doesn't want to suspend 1114 * after waiting for 100 msecs. 1115 * This is a critical error but there 1116 * is not much we can do here. 1117 */ 1118 return -EIO; 1119 } 1120 status = map_read(map, adr); 1121 } while (!map_word_andequal(map, status, OK, OK)); 1122 1123 /* Suspend succeeded */ 1124 oldstate = chip->state; 1125 if (oldstate == FL_ERASING) { 1126 if (!map_word_bitsset(map, status, CMD(0x40))) 1127 break; 1128 newstate = FL_XIP_WHILE_ERASING; 1129 chip->erase_suspended = 1; 1130 } else { 1131 if (!map_word_bitsset(map, status, CMD(0x04))) 1132 break; 1133 newstate = FL_XIP_WHILE_WRITING; 1134 chip->write_suspended = 1; 1135 } 1136 chip->state = newstate; 1137 map_write(map, CMD(0xff), adr); 1138 (void) map_read(map, adr); 1139 xip_iprefetch(); 1140 local_irq_enable(); 1141 mutex_unlock(&chip->mutex); 1142 xip_iprefetch(); 1143 cond_resched(); 1144 1145 /* 1146 * We're back. However someone else might have 1147 * decided to go write to the chip if we are in 1148 * a suspended erase state. If so let's wait 1149 * until it's done. 1150 */ 1151 mutex_lock(&chip->mutex); 1152 while (chip->state != newstate) { 1153 DECLARE_WAITQUEUE(wait, current); 1154 set_current_state(TASK_UNINTERRUPTIBLE); 1155 add_wait_queue(&chip->wq, &wait); 1156 mutex_unlock(&chip->mutex); 1157 schedule(); 1158 remove_wait_queue(&chip->wq, &wait); 1159 mutex_lock(&chip->mutex); 1160 } 1161 /* Disallow XIP again */ 1162 local_irq_disable(); 1163 1164 /* Resume the write or erase operation */ 1165 map_write(map, CMD(0xd0), adr); 1166 map_write(map, CMD(0x70), adr); 1167 chip->state = oldstate; 1168 start = xip_currtime(); 1169 } else if (usec >= 1000000/HZ) { 1170 /* 1171 * Try to save on CPU power when waiting delay 1172 * is at least a system timer tick period. 1173 * No need to be extremely accurate here. 1174 */ 1175 xip_cpu_idle(); 1176 } 1177 status = map_read(map, adr); 1178 done = xip_elapsed_since(start); 1179 } while (!map_word_andequal(map, status, OK, OK) 1180 && done < usec); 1181 1182 return (done >= usec) ? -ETIME : 0; 1183 } 1184 1185 /* 1186 * The INVALIDATE_CACHED_RANGE() macro is normally used in parallel while 1187 * the flash is actively programming or erasing since we have to poll for 1188 * the operation to complete anyway. We can't do that in a generic way with 1189 * a XIP setup so do it before the actual flash operation in this case 1190 * and stub it out from INVAL_CACHE_AND_WAIT. 1191 */ 1192 #define XIP_INVAL_CACHED_RANGE(map, from, size) \ 1193 INVALIDATE_CACHED_RANGE(map, from, size) 1194 1195 #define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec, usec_max) \ 1196 xip_wait_for_operation(map, chip, cmd_adr, usec_max) 1197 1198 #else 1199 1200 #define xip_disable(map, chip, adr) 1201 #define xip_enable(map, chip, adr) 1202 #define XIP_INVAL_CACHED_RANGE(x...) 1203 #define INVAL_CACHE_AND_WAIT inval_cache_and_wait_for_operation 1204 1205 static int inval_cache_and_wait_for_operation( 1206 struct map_info *map, struct flchip *chip, 1207 unsigned long cmd_adr, unsigned long inval_adr, int inval_len, 1208 unsigned int chip_op_time, unsigned int chip_op_time_max) 1209 { 1210 struct cfi_private *cfi = map->fldrv_priv; 1211 map_word status, status_OK = CMD(0x80); 1212 int chip_state = chip->state; 1213 unsigned int timeo, sleep_time, reset_timeo; 1214 1215 mutex_unlock(&chip->mutex); 1216 if (inval_len) 1217 INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len); 1218 mutex_lock(&chip->mutex); 1219 1220 timeo = chip_op_time_max; 1221 if (!timeo) 1222 timeo = 500000; 1223 reset_timeo = timeo; 1224 sleep_time = chip_op_time / 2; 1225 1226 for (;;) { 1227 if (chip->state != chip_state) { 1228 /* Someone's suspended the operation: sleep */ 1229 DECLARE_WAITQUEUE(wait, current); 1230 set_current_state(TASK_UNINTERRUPTIBLE); 1231 add_wait_queue(&chip->wq, &wait); 1232 mutex_unlock(&chip->mutex); 1233 schedule(); 1234 remove_wait_queue(&chip->wq, &wait); 1235 mutex_lock(&chip->mutex); 1236 continue; 1237 } 1238 1239 status = map_read(map, cmd_adr); 1240 if (map_word_andequal(map, status, status_OK, status_OK)) 1241 break; 1242 1243 if (chip->erase_suspended && chip_state == FL_ERASING) { 1244 /* Erase suspend occurred while sleep: reset timeout */ 1245 timeo = reset_timeo; 1246 chip->erase_suspended = 0; 1247 } 1248 if (chip->write_suspended && chip_state == FL_WRITING) { 1249 /* Write suspend occurred while sleep: reset timeout */ 1250 timeo = reset_timeo; 1251 chip->write_suspended = 0; 1252 } 1253 if (!timeo) { 1254 map_write(map, CMD(0x70), cmd_adr); 1255 chip->state = FL_STATUS; 1256 return -ETIME; 1257 } 1258 1259 /* OK Still waiting. Drop the lock, wait a while and retry. */ 1260 mutex_unlock(&chip->mutex); 1261 if (sleep_time >= 1000000/HZ) { 1262 /* 1263 * Half of the normal delay still remaining 1264 * can be performed with a sleeping delay instead 1265 * of busy waiting. 1266 */ 1267 msleep(sleep_time/1000); 1268 timeo -= sleep_time; 1269 sleep_time = 1000000/HZ; 1270 } else { 1271 udelay(1); 1272 cond_resched(); 1273 timeo--; 1274 } 1275 mutex_lock(&chip->mutex); 1276 } 1277 1278 /* Done and happy. */ 1279 chip->state = FL_STATUS; 1280 return 0; 1281 } 1282 1283 #endif 1284 1285 #define WAIT_TIMEOUT(map, chip, adr, udelay, udelay_max) \ 1286 INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay, udelay_max); 1287 1288 1289 static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len) 1290 { 1291 unsigned long cmd_addr; 1292 struct cfi_private *cfi = map->fldrv_priv; 1293 int ret = 0; 1294 1295 adr += chip->start; 1296 1297 /* Ensure cmd read/writes are aligned. */ 1298 cmd_addr = adr & ~(map_bankwidth(map)-1); 1299 1300 mutex_lock(&chip->mutex); 1301 1302 ret = get_chip(map, chip, cmd_addr, FL_POINT); 1303 1304 if (!ret) { 1305 if (chip->state != FL_POINT && chip->state != FL_READY) 1306 map_write(map, CMD(0xff), cmd_addr); 1307 1308 chip->state = FL_POINT; 1309 chip->ref_point_counter++; 1310 } 1311 mutex_unlock(&chip->mutex); 1312 1313 return ret; 1314 } 1315 1316 static int cfi_intelext_point(struct mtd_info *mtd, loff_t from, size_t len, 1317 size_t *retlen, void **virt, resource_size_t *phys) 1318 { 1319 struct map_info *map = mtd->priv; 1320 struct cfi_private *cfi = map->fldrv_priv; 1321 unsigned long ofs, last_end = 0; 1322 int chipnum; 1323 int ret = 0; 1324 1325 if (!map->virt) 1326 return -EINVAL; 1327 1328 /* Now lock the chip(s) to POINT state */ 1329 1330 /* ofs: offset within the first chip that the first read should start */ 1331 chipnum = (from >> cfi->chipshift); 1332 ofs = from - (chipnum << cfi->chipshift); 1333 1334 *virt = map->virt + cfi->chips[chipnum].start + ofs; 1335 if (phys) 1336 *phys = map->phys + cfi->chips[chipnum].start + ofs; 1337 1338 while (len) { 1339 unsigned long thislen; 1340 1341 if (chipnum >= cfi->numchips) 1342 break; 1343 1344 /* We cannot point across chips that are virtually disjoint */ 1345 if (!last_end) 1346 last_end = cfi->chips[chipnum].start; 1347 else if (cfi->chips[chipnum].start != last_end) 1348 break; 1349 1350 if ((len + ofs -1) >> cfi->chipshift) 1351 thislen = (1<<cfi->chipshift) - ofs; 1352 else 1353 thislen = len; 1354 1355 ret = do_point_onechip(map, &cfi->chips[chipnum], ofs, thislen); 1356 if (ret) 1357 break; 1358 1359 *retlen += thislen; 1360 len -= thislen; 1361 1362 ofs = 0; 1363 last_end += 1 << cfi->chipshift; 1364 chipnum++; 1365 } 1366 return 0; 1367 } 1368 1369 static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len) 1370 { 1371 struct map_info *map = mtd->priv; 1372 struct cfi_private *cfi = map->fldrv_priv; 1373 unsigned long ofs; 1374 int chipnum, err = 0; 1375 1376 /* Now unlock the chip(s) POINT state */ 1377 1378 /* ofs: offset within the first chip that the first read should start */ 1379 chipnum = (from >> cfi->chipshift); 1380 ofs = from - (chipnum << cfi->chipshift); 1381 1382 while (len && !err) { 1383 unsigned long thislen; 1384 struct flchip *chip; 1385 1386 chip = &cfi->chips[chipnum]; 1387 if (chipnum >= cfi->numchips) 1388 break; 1389 1390 if ((len + ofs -1) >> cfi->chipshift) 1391 thislen = (1<<cfi->chipshift) - ofs; 1392 else 1393 thislen = len; 1394 1395 mutex_lock(&chip->mutex); 1396 if (chip->state == FL_POINT) { 1397 chip->ref_point_counter--; 1398 if(chip->ref_point_counter == 0) 1399 chip->state = FL_READY; 1400 } else { 1401 printk(KERN_ERR "%s: Error: unpoint called on non pointed region\n", map->name); 1402 err = -EINVAL; 1403 } 1404 1405 put_chip(map, chip, chip->start); 1406 mutex_unlock(&chip->mutex); 1407 1408 len -= thislen; 1409 ofs = 0; 1410 chipnum++; 1411 } 1412 1413 return err; 1414 } 1415 1416 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf) 1417 { 1418 unsigned long cmd_addr; 1419 struct cfi_private *cfi = map->fldrv_priv; 1420 int ret; 1421 1422 adr += chip->start; 1423 1424 /* Ensure cmd read/writes are aligned. */ 1425 cmd_addr = adr & ~(map_bankwidth(map)-1); 1426 1427 mutex_lock(&chip->mutex); 1428 ret = get_chip(map, chip, cmd_addr, FL_READY); 1429 if (ret) { 1430 mutex_unlock(&chip->mutex); 1431 return ret; 1432 } 1433 1434 if (chip->state != FL_POINT && chip->state != FL_READY) { 1435 map_write(map, CMD(0xff), cmd_addr); 1436 1437 chip->state = FL_READY; 1438 } 1439 1440 map_copy_from(map, buf, adr, len); 1441 1442 put_chip(map, chip, cmd_addr); 1443 1444 mutex_unlock(&chip->mutex); 1445 return 0; 1446 } 1447 1448 static int cfi_intelext_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf) 1449 { 1450 struct map_info *map = mtd->priv; 1451 struct cfi_private *cfi = map->fldrv_priv; 1452 unsigned long ofs; 1453 int chipnum; 1454 int ret = 0; 1455 1456 /* ofs: offset within the first chip that the first read should start */ 1457 chipnum = (from >> cfi->chipshift); 1458 ofs = from - (chipnum << cfi->chipshift); 1459 1460 while (len) { 1461 unsigned long thislen; 1462 1463 if (chipnum >= cfi->numchips) 1464 break; 1465 1466 if ((len + ofs -1) >> cfi->chipshift) 1467 thislen = (1<<cfi->chipshift) - ofs; 1468 else 1469 thislen = len; 1470 1471 ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf); 1472 if (ret) 1473 break; 1474 1475 *retlen += thislen; 1476 len -= thislen; 1477 buf += thislen; 1478 1479 ofs = 0; 1480 chipnum++; 1481 } 1482 return ret; 1483 } 1484 1485 static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip, 1486 unsigned long adr, map_word datum, int mode) 1487 { 1488 struct cfi_private *cfi = map->fldrv_priv; 1489 map_word status, write_cmd; 1490 int ret=0; 1491 1492 adr += chip->start; 1493 1494 switch (mode) { 1495 case FL_WRITING: 1496 write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0x40) : CMD(0x41); 1497 break; 1498 case FL_OTP_WRITE: 1499 write_cmd = CMD(0xc0); 1500 break; 1501 default: 1502 return -EINVAL; 1503 } 1504 1505 mutex_lock(&chip->mutex); 1506 ret = get_chip(map, chip, adr, mode); 1507 if (ret) { 1508 mutex_unlock(&chip->mutex); 1509 return ret; 1510 } 1511 1512 XIP_INVAL_CACHED_RANGE(map, adr, map_bankwidth(map)); 1513 ENABLE_VPP(map); 1514 xip_disable(map, chip, adr); 1515 map_write(map, write_cmd, adr); 1516 map_write(map, datum, adr); 1517 chip->state = mode; 1518 1519 ret = INVAL_CACHE_AND_WAIT(map, chip, adr, 1520 adr, map_bankwidth(map), 1521 chip->word_write_time, 1522 chip->word_write_time_max); 1523 if (ret) { 1524 xip_enable(map, chip, adr); 1525 printk(KERN_ERR "%s: word write error (status timeout)\n", map->name); 1526 goto out; 1527 } 1528 1529 /* check for errors */ 1530 status = map_read(map, adr); 1531 if (map_word_bitsset(map, status, CMD(0x1a))) { 1532 unsigned long chipstatus = MERGESTATUS(status); 1533 1534 /* reset status */ 1535 map_write(map, CMD(0x50), adr); 1536 map_write(map, CMD(0x70), adr); 1537 xip_enable(map, chip, adr); 1538 1539 if (chipstatus & 0x02) { 1540 ret = -EROFS; 1541 } else if (chipstatus & 0x08) { 1542 printk(KERN_ERR "%s: word write error (bad VPP)\n", map->name); 1543 ret = -EIO; 1544 } else { 1545 printk(KERN_ERR "%s: word write error (status 0x%lx)\n", map->name, chipstatus); 1546 ret = -EINVAL; 1547 } 1548 1549 goto out; 1550 } 1551 1552 xip_enable(map, chip, adr); 1553 out: DISABLE_VPP(map); 1554 put_chip(map, chip, adr); 1555 mutex_unlock(&chip->mutex); 1556 return ret; 1557 } 1558 1559 1560 static int cfi_intelext_write_words (struct mtd_info *mtd, loff_t to , size_t len, size_t *retlen, const u_char *buf) 1561 { 1562 struct map_info *map = mtd->priv; 1563 struct cfi_private *cfi = map->fldrv_priv; 1564 int ret = 0; 1565 int chipnum; 1566 unsigned long ofs; 1567 1568 chipnum = to >> cfi->chipshift; 1569 ofs = to - (chipnum << cfi->chipshift); 1570 1571 /* If it's not bus-aligned, do the first byte write */ 1572 if (ofs & (map_bankwidth(map)-1)) { 1573 unsigned long bus_ofs = ofs & ~(map_bankwidth(map)-1); 1574 int gap = ofs - bus_ofs; 1575 int n; 1576 map_word datum; 1577 1578 n = min_t(int, len, map_bankwidth(map)-gap); 1579 datum = map_word_ff(map); 1580 datum = map_word_load_partial(map, datum, buf, gap, n); 1581 1582 ret = do_write_oneword(map, &cfi->chips[chipnum], 1583 bus_ofs, datum, FL_WRITING); 1584 if (ret) 1585 return ret; 1586 1587 len -= n; 1588 ofs += n; 1589 buf += n; 1590 (*retlen) += n; 1591 1592 if (ofs >> cfi->chipshift) { 1593 chipnum ++; 1594 ofs = 0; 1595 if (chipnum == cfi->numchips) 1596 return 0; 1597 } 1598 } 1599 1600 while(len >= map_bankwidth(map)) { 1601 map_word datum = map_word_load(map, buf); 1602 1603 ret = do_write_oneword(map, &cfi->chips[chipnum], 1604 ofs, datum, FL_WRITING); 1605 if (ret) 1606 return ret; 1607 1608 ofs += map_bankwidth(map); 1609 buf += map_bankwidth(map); 1610 (*retlen) += map_bankwidth(map); 1611 len -= map_bankwidth(map); 1612 1613 if (ofs >> cfi->chipshift) { 1614 chipnum ++; 1615 ofs = 0; 1616 if (chipnum == cfi->numchips) 1617 return 0; 1618 } 1619 } 1620 1621 if (len & (map_bankwidth(map)-1)) { 1622 map_word datum; 1623 1624 datum = map_word_ff(map); 1625 datum = map_word_load_partial(map, datum, buf, 0, len); 1626 1627 ret = do_write_oneword(map, &cfi->chips[chipnum], 1628 ofs, datum, FL_WRITING); 1629 if (ret) 1630 return ret; 1631 1632 (*retlen) += len; 1633 } 1634 1635 return 0; 1636 } 1637 1638 1639 static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip, 1640 unsigned long adr, const struct kvec **pvec, 1641 unsigned long *pvec_seek, int len) 1642 { 1643 struct cfi_private *cfi = map->fldrv_priv; 1644 map_word status, write_cmd, datum; 1645 unsigned long cmd_adr; 1646 int ret, wbufsize, word_gap, words; 1647 const struct kvec *vec; 1648 unsigned long vec_seek; 1649 unsigned long initial_adr; 1650 int initial_len = len; 1651 1652 wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize; 1653 adr += chip->start; 1654 initial_adr = adr; 1655 cmd_adr = adr & ~(wbufsize-1); 1656 1657 /* Let's determine this according to the interleave only once */ 1658 write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0xe8) : CMD(0xe9); 1659 1660 mutex_lock(&chip->mutex); 1661 ret = get_chip(map, chip, cmd_adr, FL_WRITING); 1662 if (ret) { 1663 mutex_unlock(&chip->mutex); 1664 return ret; 1665 } 1666 1667 XIP_INVAL_CACHED_RANGE(map, initial_adr, initial_len); 1668 ENABLE_VPP(map); 1669 xip_disable(map, chip, cmd_adr); 1670 1671 /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set 1672 [...], the device will not accept any more Write to Buffer commands". 1673 So we must check here and reset those bits if they're set. Otherwise 1674 we're just pissing in the wind */ 1675 if (chip->state != FL_STATUS) { 1676 map_write(map, CMD(0x70), cmd_adr); 1677 chip->state = FL_STATUS; 1678 } 1679 status = map_read(map, cmd_adr); 1680 if (map_word_bitsset(map, status, CMD(0x30))) { 1681 xip_enable(map, chip, cmd_adr); 1682 printk(KERN_WARNING "SR.4 or SR.5 bits set in buffer write (status %lx). Clearing.\n", status.x[0]); 1683 xip_disable(map, chip, cmd_adr); 1684 map_write(map, CMD(0x50), cmd_adr); 1685 map_write(map, CMD(0x70), cmd_adr); 1686 } 1687 1688 chip->state = FL_WRITING_TO_BUFFER; 1689 map_write(map, write_cmd, cmd_adr); 1690 ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0, 0); 1691 if (ret) { 1692 /* Argh. Not ready for write to buffer */ 1693 map_word Xstatus = map_read(map, cmd_adr); 1694 map_write(map, CMD(0x70), cmd_adr); 1695 chip->state = FL_STATUS; 1696 status = map_read(map, cmd_adr); 1697 map_write(map, CMD(0x50), cmd_adr); 1698 map_write(map, CMD(0x70), cmd_adr); 1699 xip_enable(map, chip, cmd_adr); 1700 printk(KERN_ERR "%s: Chip not ready for buffer write. Xstatus = %lx, status = %lx\n", 1701 map->name, Xstatus.x[0], status.x[0]); 1702 goto out; 1703 } 1704 1705 /* Figure out the number of words to write */ 1706 word_gap = (-adr & (map_bankwidth(map)-1)); 1707 words = DIV_ROUND_UP(len - word_gap, map_bankwidth(map)); 1708 if (!word_gap) { 1709 words--; 1710 } else { 1711 word_gap = map_bankwidth(map) - word_gap; 1712 adr -= word_gap; 1713 datum = map_word_ff(map); 1714 } 1715 1716 /* Write length of data to come */ 1717 map_write(map, CMD(words), cmd_adr ); 1718 1719 /* Write data */ 1720 vec = *pvec; 1721 vec_seek = *pvec_seek; 1722 do { 1723 int n = map_bankwidth(map) - word_gap; 1724 if (n > vec->iov_len - vec_seek) 1725 n = vec->iov_len - vec_seek; 1726 if (n > len) 1727 n = len; 1728 1729 if (!word_gap && len < map_bankwidth(map)) 1730 datum = map_word_ff(map); 1731 1732 datum = map_word_load_partial(map, datum, 1733 vec->iov_base + vec_seek, 1734 word_gap, n); 1735 1736 len -= n; 1737 word_gap += n; 1738 if (!len || word_gap == map_bankwidth(map)) { 1739 map_write(map, datum, adr); 1740 adr += map_bankwidth(map); 1741 word_gap = 0; 1742 } 1743 1744 vec_seek += n; 1745 if (vec_seek == vec->iov_len) { 1746 vec++; 1747 vec_seek = 0; 1748 } 1749 } while (len); 1750 *pvec = vec; 1751 *pvec_seek = vec_seek; 1752 1753 /* GO GO GO */ 1754 map_write(map, CMD(0xd0), cmd_adr); 1755 chip->state = FL_WRITING; 1756 1757 ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, 1758 initial_adr, initial_len, 1759 chip->buffer_write_time, 1760 chip->buffer_write_time_max); 1761 if (ret) { 1762 map_write(map, CMD(0x70), cmd_adr); 1763 chip->state = FL_STATUS; 1764 xip_enable(map, chip, cmd_adr); 1765 printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name); 1766 goto out; 1767 } 1768 1769 /* check for errors */ 1770 status = map_read(map, cmd_adr); 1771 if (map_word_bitsset(map, status, CMD(0x1a))) { 1772 unsigned long chipstatus = MERGESTATUS(status); 1773 1774 /* reset status */ 1775 map_write(map, CMD(0x50), cmd_adr); 1776 map_write(map, CMD(0x70), cmd_adr); 1777 xip_enable(map, chip, cmd_adr); 1778 1779 if (chipstatus & 0x02) { 1780 ret = -EROFS; 1781 } else if (chipstatus & 0x08) { 1782 printk(KERN_ERR "%s: buffer write error (bad VPP)\n", map->name); 1783 ret = -EIO; 1784 } else { 1785 printk(KERN_ERR "%s: buffer write error (status 0x%lx)\n", map->name, chipstatus); 1786 ret = -EINVAL; 1787 } 1788 1789 goto out; 1790 } 1791 1792 xip_enable(map, chip, cmd_adr); 1793 out: DISABLE_VPP(map); 1794 put_chip(map, chip, cmd_adr); 1795 mutex_unlock(&chip->mutex); 1796 return ret; 1797 } 1798 1799 static int cfi_intelext_writev (struct mtd_info *mtd, const struct kvec *vecs, 1800 unsigned long count, loff_t to, size_t *retlen) 1801 { 1802 struct map_info *map = mtd->priv; 1803 struct cfi_private *cfi = map->fldrv_priv; 1804 int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize; 1805 int ret = 0; 1806 int chipnum; 1807 unsigned long ofs, vec_seek, i; 1808 size_t len = 0; 1809 1810 for (i = 0; i < count; i++) 1811 len += vecs[i].iov_len; 1812 1813 if (!len) 1814 return 0; 1815 1816 chipnum = to >> cfi->chipshift; 1817 ofs = to - (chipnum << cfi->chipshift); 1818 vec_seek = 0; 1819 1820 do { 1821 /* We must not cross write block boundaries */ 1822 int size = wbufsize - (ofs & (wbufsize-1)); 1823 1824 if (size > len) 1825 size = len; 1826 ret = do_write_buffer(map, &cfi->chips[chipnum], 1827 ofs, &vecs, &vec_seek, size); 1828 if (ret) 1829 return ret; 1830 1831 ofs += size; 1832 (*retlen) += size; 1833 len -= size; 1834 1835 if (ofs >> cfi->chipshift) { 1836 chipnum ++; 1837 ofs = 0; 1838 if (chipnum == cfi->numchips) 1839 return 0; 1840 } 1841 1842 /* Be nice and reschedule with the chip in a usable state for other 1843 processes. */ 1844 cond_resched(); 1845 1846 } while (len); 1847 1848 return 0; 1849 } 1850 1851 static int cfi_intelext_write_buffers (struct mtd_info *mtd, loff_t to, 1852 size_t len, size_t *retlen, const u_char *buf) 1853 { 1854 struct kvec vec; 1855 1856 vec.iov_base = (void *) buf; 1857 vec.iov_len = len; 1858 1859 return cfi_intelext_writev(mtd, &vec, 1, to, retlen); 1860 } 1861 1862 static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip, 1863 unsigned long adr, int len, void *thunk) 1864 { 1865 struct cfi_private *cfi = map->fldrv_priv; 1866 map_word status; 1867 int retries = 3; 1868 int ret; 1869 1870 adr += chip->start; 1871 1872 retry: 1873 mutex_lock(&chip->mutex); 1874 ret = get_chip(map, chip, adr, FL_ERASING); 1875 if (ret) { 1876 mutex_unlock(&chip->mutex); 1877 return ret; 1878 } 1879 1880 XIP_INVAL_CACHED_RANGE(map, adr, len); 1881 ENABLE_VPP(map); 1882 xip_disable(map, chip, adr); 1883 1884 /* Clear the status register first */ 1885 map_write(map, CMD(0x50), adr); 1886 1887 /* Now erase */ 1888 map_write(map, CMD(0x20), adr); 1889 map_write(map, CMD(0xD0), adr); 1890 chip->state = FL_ERASING; 1891 chip->erase_suspended = 0; 1892 1893 ret = INVAL_CACHE_AND_WAIT(map, chip, adr, 1894 adr, len, 1895 chip->erase_time, 1896 chip->erase_time_max); 1897 if (ret) { 1898 map_write(map, CMD(0x70), adr); 1899 chip->state = FL_STATUS; 1900 xip_enable(map, chip, adr); 1901 printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name); 1902 goto out; 1903 } 1904 1905 /* We've broken this before. It doesn't hurt to be safe */ 1906 map_write(map, CMD(0x70), adr); 1907 chip->state = FL_STATUS; 1908 status = map_read(map, adr); 1909 1910 /* check for errors */ 1911 if (map_word_bitsset(map, status, CMD(0x3a))) { 1912 unsigned long chipstatus = MERGESTATUS(status); 1913 1914 /* Reset the error bits */ 1915 map_write(map, CMD(0x50), adr); 1916 map_write(map, CMD(0x70), adr); 1917 xip_enable(map, chip, adr); 1918 1919 if ((chipstatus & 0x30) == 0x30) { 1920 printk(KERN_ERR "%s: block erase error: (bad command sequence, status 0x%lx)\n", map->name, chipstatus); 1921 ret = -EINVAL; 1922 } else if (chipstatus & 0x02) { 1923 /* Protection bit set */ 1924 ret = -EROFS; 1925 } else if (chipstatus & 0x8) { 1926 /* Voltage */ 1927 printk(KERN_ERR "%s: block erase error: (bad VPP)\n", map->name); 1928 ret = -EIO; 1929 } else if (chipstatus & 0x20 && retries--) { 1930 printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus); 1931 DISABLE_VPP(map); 1932 put_chip(map, chip, adr); 1933 mutex_unlock(&chip->mutex); 1934 goto retry; 1935 } else { 1936 printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus); 1937 ret = -EIO; 1938 } 1939 1940 goto out; 1941 } 1942 1943 xip_enable(map, chip, adr); 1944 out: DISABLE_VPP(map); 1945 put_chip(map, chip, adr); 1946 mutex_unlock(&chip->mutex); 1947 return ret; 1948 } 1949 1950 static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr) 1951 { 1952 unsigned long ofs, len; 1953 int ret; 1954 1955 ofs = instr->addr; 1956 len = instr->len; 1957 1958 ret = cfi_varsize_frob(mtd, do_erase_oneblock, ofs, len, NULL); 1959 if (ret) 1960 return ret; 1961 1962 instr->state = MTD_ERASE_DONE; 1963 mtd_erase_callback(instr); 1964 1965 return 0; 1966 } 1967 1968 static void cfi_intelext_sync (struct mtd_info *mtd) 1969 { 1970 struct map_info *map = mtd->priv; 1971 struct cfi_private *cfi = map->fldrv_priv; 1972 int i; 1973 struct flchip *chip; 1974 int ret = 0; 1975 1976 for (i=0; !ret && i<cfi->numchips; i++) { 1977 chip = &cfi->chips[i]; 1978 1979 mutex_lock(&chip->mutex); 1980 ret = get_chip(map, chip, chip->start, FL_SYNCING); 1981 1982 if (!ret) { 1983 chip->oldstate = chip->state; 1984 chip->state = FL_SYNCING; 1985 /* No need to wake_up() on this state change - 1986 * as the whole point is that nobody can do anything 1987 * with the chip now anyway. 1988 */ 1989 } 1990 mutex_unlock(&chip->mutex); 1991 } 1992 1993 /* Unlock the chips again */ 1994 1995 for (i--; i >=0; i--) { 1996 chip = &cfi->chips[i]; 1997 1998 mutex_lock(&chip->mutex); 1999 2000 if (chip->state == FL_SYNCING) { 2001 chip->state = chip->oldstate; 2002 chip->oldstate = FL_READY; 2003 wake_up(&chip->wq); 2004 } 2005 mutex_unlock(&chip->mutex); 2006 } 2007 } 2008 2009 static int __xipram do_getlockstatus_oneblock(struct map_info *map, 2010 struct flchip *chip, 2011 unsigned long adr, 2012 int len, void *thunk) 2013 { 2014 struct cfi_private *cfi = map->fldrv_priv; 2015 int status, ofs_factor = cfi->interleave * cfi->device_type; 2016 2017 adr += chip->start; 2018 xip_disable(map, chip, adr+(2*ofs_factor)); 2019 map_write(map, CMD(0x90), adr+(2*ofs_factor)); 2020 chip->state = FL_JEDEC_QUERY; 2021 status = cfi_read_query(map, adr+(2*ofs_factor)); 2022 xip_enable(map, chip, 0); 2023 return status; 2024 } 2025 2026 #ifdef DEBUG_LOCK_BITS 2027 static int __xipram do_printlockstatus_oneblock(struct map_info *map, 2028 struct flchip *chip, 2029 unsigned long adr, 2030 int len, void *thunk) 2031 { 2032 printk(KERN_DEBUG "block status register for 0x%08lx is %x\n", 2033 adr, do_getlockstatus_oneblock(map, chip, adr, len, thunk)); 2034 return 0; 2035 } 2036 #endif 2037 2038 #define DO_XXLOCK_ONEBLOCK_LOCK ((void *) 1) 2039 #define DO_XXLOCK_ONEBLOCK_UNLOCK ((void *) 2) 2040 2041 static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip, 2042 unsigned long adr, int len, void *thunk) 2043 { 2044 struct cfi_private *cfi = map->fldrv_priv; 2045 struct cfi_pri_intelext *extp = cfi->cmdset_priv; 2046 int mdelay; 2047 int ret; 2048 2049 adr += chip->start; 2050 2051 mutex_lock(&chip->mutex); 2052 ret = get_chip(map, chip, adr, FL_LOCKING); 2053 if (ret) { 2054 mutex_unlock(&chip->mutex); 2055 return ret; 2056 } 2057 2058 ENABLE_VPP(map); 2059 xip_disable(map, chip, adr); 2060 2061 map_write(map, CMD(0x60), adr); 2062 if (thunk == DO_XXLOCK_ONEBLOCK_LOCK) { 2063 map_write(map, CMD(0x01), adr); 2064 chip->state = FL_LOCKING; 2065 } else if (thunk == DO_XXLOCK_ONEBLOCK_UNLOCK) { 2066 map_write(map, CMD(0xD0), adr); 2067 chip->state = FL_UNLOCKING; 2068 } else 2069 BUG(); 2070 2071 /* 2072 * If Instant Individual Block Locking supported then no need 2073 * to delay. 2074 */ 2075 /* 2076 * Unlocking may take up to 1.4 seconds on some Intel flashes. So 2077 * lets use a max of 1.5 seconds (1500ms) as timeout. 2078 * 2079 * See "Clear Block Lock-Bits Time" on page 40 in 2080 * "3 Volt Intel StrataFlash Memory" 28F128J3,28F640J3,28F320J3 manual 2081 * from February 2003 2082 */ 2083 mdelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1500 : 0; 2084 2085 ret = WAIT_TIMEOUT(map, chip, adr, mdelay, mdelay * 1000); 2086 if (ret) { 2087 map_write(map, CMD(0x70), adr); 2088 chip->state = FL_STATUS; 2089 xip_enable(map, chip, adr); 2090 printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name); 2091 goto out; 2092 } 2093 2094 xip_enable(map, chip, adr); 2095 out: DISABLE_VPP(map); 2096 put_chip(map, chip, adr); 2097 mutex_unlock(&chip->mutex); 2098 return ret; 2099 } 2100 2101 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 2102 { 2103 int ret; 2104 2105 #ifdef DEBUG_LOCK_BITS 2106 printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n", 2107 __func__, ofs, len); 2108 cfi_varsize_frob(mtd, do_printlockstatus_oneblock, 2109 ofs, len, NULL); 2110 #endif 2111 2112 ret = cfi_varsize_frob(mtd, do_xxlock_oneblock, 2113 ofs, len, DO_XXLOCK_ONEBLOCK_LOCK); 2114 2115 #ifdef DEBUG_LOCK_BITS 2116 printk(KERN_DEBUG "%s: lock status after, ret=%d\n", 2117 __func__, ret); 2118 cfi_varsize_frob(mtd, do_printlockstatus_oneblock, 2119 ofs, len, NULL); 2120 #endif 2121 2122 return ret; 2123 } 2124 2125 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) 2126 { 2127 int ret; 2128 2129 #ifdef DEBUG_LOCK_BITS 2130 printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n", 2131 __func__, ofs, len); 2132 cfi_varsize_frob(mtd, do_printlockstatus_oneblock, 2133 ofs, len, NULL); 2134 #endif 2135 2136 ret = cfi_varsize_frob(mtd, do_xxlock_oneblock, 2137 ofs, len, DO_XXLOCK_ONEBLOCK_UNLOCK); 2138 2139 #ifdef DEBUG_LOCK_BITS 2140 printk(KERN_DEBUG "%s: lock status after, ret=%d\n", 2141 __func__, ret); 2142 cfi_varsize_frob(mtd, do_printlockstatus_oneblock, 2143 ofs, len, NULL); 2144 #endif 2145 2146 return ret; 2147 } 2148 2149 static int cfi_intelext_is_locked(struct mtd_info *mtd, loff_t ofs, 2150 uint64_t len) 2151 { 2152 return cfi_varsize_frob(mtd, do_getlockstatus_oneblock, 2153 ofs, len, NULL) ? 1 : 0; 2154 } 2155 2156 #ifdef CONFIG_MTD_OTP 2157 2158 typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip, 2159 u_long data_offset, u_char *buf, u_int size, 2160 u_long prot_offset, u_int groupno, u_int groupsize); 2161 2162 static int __xipram 2163 do_otp_read(struct map_info *map, struct flchip *chip, u_long offset, 2164 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz) 2165 { 2166 struct cfi_private *cfi = map->fldrv_priv; 2167 int ret; 2168 2169 mutex_lock(&chip->mutex); 2170 ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY); 2171 if (ret) { 2172 mutex_unlock(&chip->mutex); 2173 return ret; 2174 } 2175 2176 /* let's ensure we're not reading back cached data from array mode */ 2177 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size); 2178 2179 xip_disable(map, chip, chip->start); 2180 if (chip->state != FL_JEDEC_QUERY) { 2181 map_write(map, CMD(0x90), chip->start); 2182 chip->state = FL_JEDEC_QUERY; 2183 } 2184 map_copy_from(map, buf, chip->start + offset, size); 2185 xip_enable(map, chip, chip->start); 2186 2187 /* then ensure we don't keep OTP data in the cache */ 2188 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size); 2189 2190 put_chip(map, chip, chip->start); 2191 mutex_unlock(&chip->mutex); 2192 return 0; 2193 } 2194 2195 static int 2196 do_otp_write(struct map_info *map, struct flchip *chip, u_long offset, 2197 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz) 2198 { 2199 int ret; 2200 2201 while (size) { 2202 unsigned long bus_ofs = offset & ~(map_bankwidth(map)-1); 2203 int gap = offset - bus_ofs; 2204 int n = min_t(int, size, map_bankwidth(map)-gap); 2205 map_word datum = map_word_ff(map); 2206 2207 datum = map_word_load_partial(map, datum, buf, gap, n); 2208 ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE); 2209 if (ret) 2210 return ret; 2211 2212 offset += n; 2213 buf += n; 2214 size -= n; 2215 } 2216 2217 return 0; 2218 } 2219 2220 static int 2221 do_otp_lock(struct map_info *map, struct flchip *chip, u_long offset, 2222 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz) 2223 { 2224 struct cfi_private *cfi = map->fldrv_priv; 2225 map_word datum; 2226 2227 /* make sure area matches group boundaries */ 2228 if (size != grpsz) 2229 return -EXDEV; 2230 2231 datum = map_word_ff(map); 2232 datum = map_word_clr(map, datum, CMD(1 << grpno)); 2233 return do_write_oneword(map, chip, prot, datum, FL_OTP_WRITE); 2234 } 2235 2236 static int cfi_intelext_otp_walk(struct mtd_info *mtd, loff_t from, size_t len, 2237 size_t *retlen, u_char *buf, 2238 otp_op_t action, int user_regs) 2239 { 2240 struct map_info *map = mtd->priv; 2241 struct cfi_private *cfi = map->fldrv_priv; 2242 struct cfi_pri_intelext *extp = cfi->cmdset_priv; 2243 struct flchip *chip; 2244 struct cfi_intelext_otpinfo *otp; 2245 u_long devsize, reg_prot_offset, data_offset; 2246 u_int chip_num, chip_step, field, reg_fact_size, reg_user_size; 2247 u_int groups, groupno, groupsize, reg_fact_groups, reg_user_groups; 2248 int ret; 2249 2250 *retlen = 0; 2251 2252 /* Check that we actually have some OTP registers */ 2253 if (!extp || !(extp->FeatureSupport & 64) || !extp->NumProtectionFields) 2254 return -ENODATA; 2255 2256 /* we need real chips here not virtual ones */ 2257 devsize = (1 << cfi->cfiq->DevSize) * cfi->interleave; 2258 chip_step = devsize >> cfi->chipshift; 2259 chip_num = 0; 2260 2261 /* Some chips have OTP located in the _top_ partition only. 2262 For example: Intel 28F256L18T (T means top-parameter device) */ 2263 if (cfi->mfr == CFI_MFR_INTEL) { 2264 switch (cfi->id) { 2265 case 0x880b: 2266 case 0x880c: 2267 case 0x880d: 2268 chip_num = chip_step - 1; 2269 } 2270 } 2271 2272 for ( ; chip_num < cfi->numchips; chip_num += chip_step) { 2273 chip = &cfi->chips[chip_num]; 2274 otp = (struct cfi_intelext_otpinfo *)&extp->extra[0]; 2275 2276 /* first OTP region */ 2277 field = 0; 2278 reg_prot_offset = extp->ProtRegAddr; 2279 reg_fact_groups = 1; 2280 reg_fact_size = 1 << extp->FactProtRegSize; 2281 reg_user_groups = 1; 2282 reg_user_size = 1 << extp->UserProtRegSize; 2283 2284 while (len > 0) { 2285 /* flash geometry fixup */ 2286 data_offset = reg_prot_offset + 1; 2287 data_offset *= cfi->interleave * cfi->device_type; 2288 reg_prot_offset *= cfi->interleave * cfi->device_type; 2289 reg_fact_size *= cfi->interleave; 2290 reg_user_size *= cfi->interleave; 2291 2292 if (user_regs) { 2293 groups = reg_user_groups; 2294 groupsize = reg_user_size; 2295 /* skip over factory reg area */ 2296 groupno = reg_fact_groups; 2297 data_offset += reg_fact_groups * reg_fact_size; 2298 } else { 2299 groups = reg_fact_groups; 2300 groupsize = reg_fact_size; 2301 groupno = 0; 2302 } 2303 2304 while (len > 0 && groups > 0) { 2305 if (!action) { 2306 /* 2307 * Special case: if action is NULL 2308 * we fill buf with otp_info records. 2309 */ 2310 struct otp_info *otpinfo; 2311 map_word lockword; 2312 len -= sizeof(struct otp_info); 2313 if (len <= 0) 2314 return -ENOSPC; 2315 ret = do_otp_read(map, chip, 2316 reg_prot_offset, 2317 (u_char *)&lockword, 2318 map_bankwidth(map), 2319 0, 0, 0); 2320 if (ret) 2321 return ret; 2322 otpinfo = (struct otp_info *)buf; 2323 otpinfo->start = from; 2324 otpinfo->length = groupsize; 2325 otpinfo->locked = 2326 !map_word_bitsset(map, lockword, 2327 CMD(1 << groupno)); 2328 from += groupsize; 2329 buf += sizeof(*otpinfo); 2330 *retlen += sizeof(*otpinfo); 2331 } else if (from >= groupsize) { 2332 from -= groupsize; 2333 data_offset += groupsize; 2334 } else { 2335 int size = groupsize; 2336 data_offset += from; 2337 size -= from; 2338 from = 0; 2339 if (size > len) 2340 size = len; 2341 ret = action(map, chip, data_offset, 2342 buf, size, reg_prot_offset, 2343 groupno, groupsize); 2344 if (ret < 0) 2345 return ret; 2346 buf += size; 2347 len -= size; 2348 *retlen += size; 2349 data_offset += size; 2350 } 2351 groupno++; 2352 groups--; 2353 } 2354 2355 /* next OTP region */ 2356 if (++field == extp->NumProtectionFields) 2357 break; 2358 reg_prot_offset = otp->ProtRegAddr; 2359 reg_fact_groups = otp->FactGroups; 2360 reg_fact_size = 1 << otp->FactProtRegSize; 2361 reg_user_groups = otp->UserGroups; 2362 reg_user_size = 1 << otp->UserProtRegSize; 2363 otp++; 2364 } 2365 } 2366 2367 return 0; 2368 } 2369 2370 static int cfi_intelext_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, 2371 size_t len, size_t *retlen, 2372 u_char *buf) 2373 { 2374 return cfi_intelext_otp_walk(mtd, from, len, retlen, 2375 buf, do_otp_read, 0); 2376 } 2377 2378 static int cfi_intelext_read_user_prot_reg(struct mtd_info *mtd, loff_t from, 2379 size_t len, size_t *retlen, 2380 u_char *buf) 2381 { 2382 return cfi_intelext_otp_walk(mtd, from, len, retlen, 2383 buf, do_otp_read, 1); 2384 } 2385 2386 static int cfi_intelext_write_user_prot_reg(struct mtd_info *mtd, loff_t from, 2387 size_t len, size_t *retlen, 2388 u_char *buf) 2389 { 2390 return cfi_intelext_otp_walk(mtd, from, len, retlen, 2391 buf, do_otp_write, 1); 2392 } 2393 2394 static int cfi_intelext_lock_user_prot_reg(struct mtd_info *mtd, 2395 loff_t from, size_t len) 2396 { 2397 size_t retlen; 2398 return cfi_intelext_otp_walk(mtd, from, len, &retlen, 2399 NULL, do_otp_lock, 1); 2400 } 2401 2402 static int cfi_intelext_get_fact_prot_info(struct mtd_info *mtd, 2403 struct otp_info *buf, size_t len) 2404 { 2405 size_t retlen; 2406 int ret; 2407 2408 ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 0); 2409 return ret ? : retlen; 2410 } 2411 2412 static int cfi_intelext_get_user_prot_info(struct mtd_info *mtd, 2413 struct otp_info *buf, size_t len) 2414 { 2415 size_t retlen; 2416 int ret; 2417 2418 ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 1); 2419 return ret ? : retlen; 2420 } 2421 2422 #endif 2423 2424 static void cfi_intelext_save_locks(struct mtd_info *mtd) 2425 { 2426 struct mtd_erase_region_info *region; 2427 int block, status, i; 2428 unsigned long adr; 2429 size_t len; 2430 2431 for (i = 0; i < mtd->numeraseregions; i++) { 2432 region = &mtd->eraseregions[i]; 2433 if (!region->lockmap) 2434 continue; 2435 2436 for (block = 0; block < region->numblocks; block++){ 2437 len = region->erasesize; 2438 adr = region->offset + block * len; 2439 2440 status = cfi_varsize_frob(mtd, 2441 do_getlockstatus_oneblock, adr, len, NULL); 2442 if (status) 2443 set_bit(block, region->lockmap); 2444 else 2445 clear_bit(block, region->lockmap); 2446 } 2447 } 2448 } 2449 2450 static int cfi_intelext_suspend(struct mtd_info *mtd) 2451 { 2452 struct map_info *map = mtd->priv; 2453 struct cfi_private *cfi = map->fldrv_priv; 2454 struct cfi_pri_intelext *extp = cfi->cmdset_priv; 2455 int i; 2456 struct flchip *chip; 2457 int ret = 0; 2458 2459 if ((mtd->flags & MTD_POWERUP_LOCK) 2460 && extp && (extp->FeatureSupport & (1 << 5))) 2461 cfi_intelext_save_locks(mtd); 2462 2463 for (i=0; !ret && i<cfi->numchips; i++) { 2464 chip = &cfi->chips[i]; 2465 2466 mutex_lock(&chip->mutex); 2467 2468 switch (chip->state) { 2469 case FL_READY: 2470 case FL_STATUS: 2471 case FL_CFI_QUERY: 2472 case FL_JEDEC_QUERY: 2473 if (chip->oldstate == FL_READY) { 2474 /* place the chip in a known state before suspend */ 2475 map_write(map, CMD(0xFF), cfi->chips[i].start); 2476 chip->oldstate = chip->state; 2477 chip->state = FL_PM_SUSPENDED; 2478 /* No need to wake_up() on this state change - 2479 * as the whole point is that nobody can do anything 2480 * with the chip now anyway. 2481 */ 2482 } else { 2483 /* There seems to be an operation pending. We must wait for it. */ 2484 printk(KERN_NOTICE "Flash device refused suspend due to pending operation (oldstate %d)\n", chip->oldstate); 2485 ret = -EAGAIN; 2486 } 2487 break; 2488 default: 2489 /* Should we actually wait? Once upon a time these routines weren't 2490 allowed to. Or should we return -EAGAIN, because the upper layers 2491 ought to have already shut down anything which was using the device 2492 anyway? The latter for now. */ 2493 printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->state); 2494 ret = -EAGAIN; 2495 case FL_PM_SUSPENDED: 2496 break; 2497 } 2498 mutex_unlock(&chip->mutex); 2499 } 2500 2501 /* Unlock the chips again */ 2502 2503 if (ret) { 2504 for (i--; i >=0; i--) { 2505 chip = &cfi->chips[i]; 2506 2507 mutex_lock(&chip->mutex); 2508 2509 if (chip->state == FL_PM_SUSPENDED) { 2510 /* No need to force it into a known state here, 2511 because we're returning failure, and it didn't 2512 get power cycled */ 2513 chip->state = chip->oldstate; 2514 chip->oldstate = FL_READY; 2515 wake_up(&chip->wq); 2516 } 2517 mutex_unlock(&chip->mutex); 2518 } 2519 } 2520 2521 return ret; 2522 } 2523 2524 static void cfi_intelext_restore_locks(struct mtd_info *mtd) 2525 { 2526 struct mtd_erase_region_info *region; 2527 int block, i; 2528 unsigned long adr; 2529 size_t len; 2530 2531 for (i = 0; i < mtd->numeraseregions; i++) { 2532 region = &mtd->eraseregions[i]; 2533 if (!region->lockmap) 2534 continue; 2535 2536 for_each_clear_bit(block, region->lockmap, region->numblocks) { 2537 len = region->erasesize; 2538 adr = region->offset + block * len; 2539 cfi_intelext_unlock(mtd, adr, len); 2540 } 2541 } 2542 } 2543 2544 static void cfi_intelext_resume(struct mtd_info *mtd) 2545 { 2546 struct map_info *map = mtd->priv; 2547 struct cfi_private *cfi = map->fldrv_priv; 2548 struct cfi_pri_intelext *extp = cfi->cmdset_priv; 2549 int i; 2550 struct flchip *chip; 2551 2552 for (i=0; i<cfi->numchips; i++) { 2553 2554 chip = &cfi->chips[i]; 2555 2556 mutex_lock(&chip->mutex); 2557 2558 /* Go to known state. Chip may have been power cycled */ 2559 if (chip->state == FL_PM_SUSPENDED) { 2560 map_write(map, CMD(0xFF), cfi->chips[i].start); 2561 chip->oldstate = chip->state = FL_READY; 2562 wake_up(&chip->wq); 2563 } 2564 2565 mutex_unlock(&chip->mutex); 2566 } 2567 2568 if ((mtd->flags & MTD_POWERUP_LOCK) 2569 && extp && (extp->FeatureSupport & (1 << 5))) 2570 cfi_intelext_restore_locks(mtd); 2571 } 2572 2573 static int cfi_intelext_reset(struct mtd_info *mtd) 2574 { 2575 struct map_info *map = mtd->priv; 2576 struct cfi_private *cfi = map->fldrv_priv; 2577 int i, ret; 2578 2579 for (i=0; i < cfi->numchips; i++) { 2580 struct flchip *chip = &cfi->chips[i]; 2581 2582 /* force the completion of any ongoing operation 2583 and switch to array mode so any bootloader in 2584 flash is accessible for soft reboot. */ 2585 mutex_lock(&chip->mutex); 2586 ret = get_chip(map, chip, chip->start, FL_SHUTDOWN); 2587 if (!ret) { 2588 map_write(map, CMD(0xff), chip->start); 2589 chip->state = FL_SHUTDOWN; 2590 put_chip(map, chip, chip->start); 2591 } 2592 mutex_unlock(&chip->mutex); 2593 } 2594 2595 return 0; 2596 } 2597 2598 static int cfi_intelext_reboot(struct notifier_block *nb, unsigned long val, 2599 void *v) 2600 { 2601 struct mtd_info *mtd; 2602 2603 mtd = container_of(nb, struct mtd_info, reboot_notifier); 2604 cfi_intelext_reset(mtd); 2605 return NOTIFY_DONE; 2606 } 2607 2608 static void cfi_intelext_destroy(struct mtd_info *mtd) 2609 { 2610 struct map_info *map = mtd->priv; 2611 struct cfi_private *cfi = map->fldrv_priv; 2612 struct mtd_erase_region_info *region; 2613 int i; 2614 cfi_intelext_reset(mtd); 2615 unregister_reboot_notifier(&mtd->reboot_notifier); 2616 kfree(cfi->cmdset_priv); 2617 kfree(cfi->cfiq); 2618 kfree(cfi->chips[0].priv); 2619 kfree(cfi); 2620 for (i = 0; i < mtd->numeraseregions; i++) { 2621 region = &mtd->eraseregions[i]; 2622 if (region->lockmap) 2623 kfree(region->lockmap); 2624 } 2625 kfree(mtd->eraseregions); 2626 } 2627 2628 MODULE_LICENSE("GPL"); 2629 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al."); 2630 MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips"); 2631 MODULE_ALIAS("cfi_cmdset_0003"); 2632 MODULE_ALIAS("cfi_cmdset_0200"); 2633