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