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