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