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