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