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