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