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