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