drivers/mtd/spi-nor/spi-nor.c

   1 /*
   2  * Based on m25p80.c, by Mike Lavender (mike@steroidmicros.com), with
   3  * influence from lart.c (Abraham Van Der Merwe) and mtd_dataflash.c
   4  *
   5  * Copyright (C) 2005, Intec Automation Inc.
   6  * Copyright (C) 2014, Freescale Semiconductor, Inc.
   7  *
   8  * This code is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/err.h>
  14 #include <linux/errno.h>
  15 #include <linux/module.h>
  16 #include <linux/device.h>
  17 #include <linux/mutex.h>
  18 #include <linux/math64.h>
  19
  20 #include <linux/mtd/cfi.h>
  21 #include <linux/mtd/mtd.h>
  22 #include <linux/of_platform.h>
  23 #include <linux/spi/flash.h>
  24 #include <linux/mtd/spi-nor.h>
  25
  26 /* Define max times to check status register before we give up. */
  27 #define MAX_READY_WAIT_JIFFIES  (40 * HZ) /* M25P16 specs 40s max chip erase */
  28
  29 #define JEDEC_MFR(_jedec_id)    ((_jedec_id) >> 16)
  30
  31 static const struct spi_device_id *spi_nor_match_id(const char *name);
  32
  33 /*
  34  * Read the status register, returning its value in the location
  35  * Return the status register value.
  36  * Returns negative if error occurred.
  37  */
  38 static int read_sr(struct spi_nor *nor)
  39 {
  40         int ret;
  41         u8 val;
  42
  43         ret = nor->read_reg(nor, SPINOR_OP_RDSR, &val, 1);
  44         if (ret < 0) {
  45                 pr_err("error %d reading SR\n", (int) ret);
  46                 return ret;
  47         }
  48
  49         return val;
  50 }
  51
  52 /*
  53  * Read the flag status register, returning its value in the location
  54  * Return the status register value.
  55  * Returns negative if error occurred.
  56  */
  57 static int read_fsr(struct spi_nor *nor)
  58 {
  59         int ret;
  60         u8 val;
  61
  62         ret = nor->read_reg(nor, SPINOR_OP_RDFSR, &val, 1);
  63         if (ret < 0) {
  64                 pr_err("error %d reading FSR\n", ret);
  65                 return ret;
  66         }
  67
  68         return val;
  69 }
  70
  71 /*
  72  * Read configuration register, returning its value in the
  73  * location. Return the configuration register value.
  74  * Returns negative if error occured.
  75  */
  76 static int read_cr(struct spi_nor *nor)
  77 {
  78         int ret;
  79         u8 val;
  80
  81         ret = nor->read_reg(nor, SPINOR_OP_RDCR, &val, 1);
  82         if (ret < 0) {
  83                 dev_err(nor->dev, "error %d reading CR\n", ret);
  84                 return ret;
  85         }
  86
  87         return val;
  88 }
  89
  90 /*
  91  * Dummy Cycle calculation for different type of read.
  92  * It can be used to support more commands with
  93  * different dummy cycle requirements.
  94  */
  95 static inline int spi_nor_read_dummy_cycles(struct spi_nor *nor)
  96 {
  97         switch (nor->flash_read) {
  98         case SPI_NOR_FAST:
  99         case SPI_NOR_DUAL:
 100         case SPI_NOR_QUAD:
 101                 return 8;
 102         case SPI_NOR_NORMAL:
 103                 return 0;
 104         }
 105         return 0;
 106 }
 107
 108 /*
 109  * Write status register 1 byte
 110  * Returns negative if error occurred.
 111  */
 112 static inline int write_sr(struct spi_nor *nor, u8 val)
 113 {
 114         nor->cmd_buf[0] = val;
 115         return nor->write_reg(nor, SPINOR_OP_WRSR, nor->cmd_buf, 1, 0);
 116 }
 117
 118 /*
 119  * Set write enable latch with Write Enable command.
 120  * Returns negative if error occurred.
 121  */
 122 static inline int write_enable(struct spi_nor *nor)
 123 {
 124         return nor->write_reg(nor, SPINOR_OP_WREN, NULL, 0, 0);
 125 }
 126
 127 /*
 128  * Send write disble instruction to the chip.
 129  */
 130 static inline int write_disable(struct spi_nor *nor)
 131 {
 132         return nor->write_reg(nor, SPINOR_OP_WRDI, NULL, 0, 0);
 133 }
 134
 135 static inline struct spi_nor *mtd_to_spi_nor(struct mtd_info *mtd)
 136 {
 137         return mtd->priv;
 138 }
 139
 140 /* Enable/disable 4-byte addressing mode. */
 141 static inline int set_4byte(struct spi_nor *nor, u32 jedec_id, int enable)
 142 {
 143         int status;
 144         bool need_wren = false;
 145         u8 cmd;
 146
 147         switch (JEDEC_MFR(jedec_id)) {
 148         case CFI_MFR_ST: /* Micron, actually */
 149                 /* Some Micron need WREN command; all will accept it */
 150                 need_wren = true;
 151         case CFI_MFR_MACRONIX:
 152         case 0xEF /* winbond */:
 153                 if (need_wren)
 154                         write_enable(nor);
 155
 156                 cmd = enable ? SPINOR_OP_EN4B : SPINOR_OP_EX4B;
 157                 status = nor->write_reg(nor, cmd, NULL, 0, 0);
 158                 if (need_wren)
 159                         write_disable(nor);
 160
 161                 return status;
 162         default:
 163                 /* Spansion style */
 164                 nor->cmd_buf[0] = enable << 7;
 165                 return nor->write_reg(nor, SPINOR_OP_BRWR, nor->cmd_buf, 1, 0);
 166         }
 167 }
 168 static inline int spi_nor_sr_ready(struct spi_nor *nor)
 169 {
 170         int sr = read_sr(nor);
 171         if (sr < 0)
 172                 return sr;
 173         else
 174                 return !(sr & SR_WIP);
 175 }
 176
 177 static inline int spi_nor_fsr_ready(struct spi_nor *nor)
 178 {
 179         int fsr = read_fsr(nor);
 180         if (fsr < 0)
 181                 return fsr;
 182         else
 183                 return fsr & FSR_READY;
 184 }
 185
 186 static int spi_nor_ready(struct spi_nor *nor)
 187 {
 188         int sr, fsr;
 189         sr = spi_nor_sr_ready(nor);
 190         if (sr < 0)
 191                 return sr;
 192         fsr = nor->flags & SNOR_F_USE_FSR ? spi_nor_fsr_ready(nor) : 1;
 193         if (fsr < 0)
 194                 return fsr;
 195         return sr && fsr;
 196 }
 197
 198 /*
 199  * Service routine to read status register until ready, or timeout occurs.
 200  * Returns non-zero if error.
 201  */
 202 static int spi_nor_wait_till_ready(struct spi_nor *nor)
 203 {
 204         unsigned long deadline;
 205         int ret;
 206
 207         deadline = jiffies + MAX_READY_WAIT_JIFFIES;
 208
 209         do {
 210                 cond_resched();
 211
 212                 ret = spi_nor_ready(nor);
 213                 if (ret < 0)
 214                         return ret;
 215                 if (ret)
 216                         return 0;
 217         } while (!time_after_eq(jiffies, deadline));
 218
 219         return -ETIMEDOUT;
 220 }
 221
 222 /*
 223  * Erase the whole flash memory
 224  *
 225  * Returns 0 if successful, non-zero otherwise.
 226  */
 227 static int erase_chip(struct spi_nor *nor)
 228 {
 229         dev_dbg(nor->dev, " %lldKiB\n", (long long)(nor->mtd->size >> 10));
 230
 231         /* Send write enable, then erase commands. */
 232         write_enable(nor);
 233
 234         return nor->write_reg(nor, SPINOR_OP_CHIP_ERASE, NULL, 0, 0);
 235 }
 236
 237 static int spi_nor_lock_and_prep(struct spi_nor *nor, enum spi_nor_ops ops)
 238 {
 239         int ret = 0;
 240
 241         mutex_lock(&nor->lock);
 242
 243         if (nor->prepare) {
 244                 ret = nor->prepare(nor, ops);
 245                 if (ret) {
 246                         dev_err(nor->dev, "failed in the preparation.\n");
 247                         mutex_unlock(&nor->lock);
 248                         return ret;
 249                 }
 250         }
 251         return ret;
 252 }
 253
 254 static void spi_nor_unlock_and_unprep(struct spi_nor *nor, enum spi_nor_ops ops)
 255 {
 256         if (nor->unprepare)
 257                 nor->unprepare(nor, ops);
 258         mutex_unlock(&nor->lock);
 259 }
 260
 261 /*
 262  * Erase an address range on the nor chip.  The address range may extend
 263  * one or more erase sectors.  Return an error is there is a problem erasing.
 264  */
 265 static int spi_nor_erase(struct mtd_info *mtd, struct erase_info *instr)
 266 {
 267         struct spi_nor *nor = mtd_to_spi_nor(mtd);
 268         u32 addr, len;
 269         uint32_t rem;
 270         int ret;
 271
 272         dev_dbg(nor->dev, "at 0x%llx, len %lld\n", (long long)instr->addr,
 273                         (long long)instr->len);
 274
 275         div_u64_rem(instr->len, mtd->erasesize, &rem);
 276         if (rem)
 277                 return -EINVAL;
 278
 279         addr = instr->addr;
 280         len = instr->len;
 281
 282         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_ERASE);
 283         if (ret)
 284                 return ret;
 285
 286         /* whole-chip erase? */
 287         if (len == mtd->size) {
 288                 if (erase_chip(nor)) {
 289                         ret = -EIO;
 290                         goto erase_err;
 291                 }
 292
 293                 ret = spi_nor_wait_till_ready(nor);
 294                 if (ret)
 295                         goto erase_err;
 296
 297         /* REVISIT in some cases we could speed up erasing large regions
 298          * by using SPINOR_OP_SE instead of SPINOR_OP_BE_4K.  We may have set up
 299          * to use "small sector erase", but that's not always optimal.
 300          */
 301
 302         /* "sector"-at-a-time erase */
 303         } else {
 304                 while (len) {
 305                         if (nor->erase(nor, addr)) {
 306                                 ret = -EIO;
 307                                 goto erase_err;
 308                         }
 309
 310                         addr += mtd->erasesize;
 311                         len -= mtd->erasesize;
 312
 313                         ret = spi_nor_wait_till_ready(nor);
 314                         if (ret)
 315                                 goto erase_err;
 316                 }
 317         }
 318
 319         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE);
 320
 321         instr->state = MTD_ERASE_DONE;
 322         mtd_erase_callback(instr);
 323
 324         return ret;
 325
 326 erase_err:
 327         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE);
 328         instr->state = MTD_ERASE_FAILED;
 329         return ret;
 330 }
 331
 332 static int spi_nor_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 333 {
 334         struct spi_nor *nor = mtd_to_spi_nor(mtd);
 335         uint32_t offset = ofs;
 336         uint8_t status_old, status_new;
 337         int ret = 0;
 338
 339         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_LOCK);
 340         if (ret)
 341                 return ret;
 342
 343         status_old = read_sr(nor);
 344
 345         if (offset < mtd->size - (mtd->size / 2))
 346                 status_new = status_old | SR_BP2 | SR_BP1 | SR_BP0;
 347         else if (offset < mtd->size - (mtd->size / 4))
 348                 status_new = (status_old & ~SR_BP0) | SR_BP2 | SR_BP1;
 349         else if (offset < mtd->size - (mtd->size / 8))
 350                 status_new = (status_old & ~SR_BP1) | SR_BP2 | SR_BP0;
 351         else if (offset < mtd->size - (mtd->size / 16))
 352                 status_new = (status_old & ~(SR_BP0 | SR_BP1)) | SR_BP2;
 353         else if (offset < mtd->size - (mtd->size / 32))
 354                 status_new = (status_old & ~SR_BP2) | SR_BP1 | SR_BP0;
 355         else if (offset < mtd->size - (mtd->size / 64))
 356                 status_new = (status_old & ~(SR_BP2 | SR_BP0)) | SR_BP1;
 357         else
 358                 status_new = (status_old & ~(SR_BP2 | SR_BP1)) | SR_BP0;
 359
 360         /* Only modify protection if it will not unlock other areas */
 361         if ((status_new & (SR_BP2 | SR_BP1 | SR_BP0)) >
 362                                 (status_old & (SR_BP2 | SR_BP1 | SR_BP0))) {
 363                 write_enable(nor);
 364                 ret = write_sr(nor, status_new);
 365                 if (ret)
 366                         goto err;
 367         }
 368
 369 err:
 370         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_LOCK);
 371         return ret;
 372 }
 373
 374 static int spi_nor_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 375 {
 376         struct spi_nor *nor = mtd_to_spi_nor(mtd);
 377         uint32_t offset = ofs;
 378         uint8_t status_old, status_new;
 379         int ret = 0;
 380
 381         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_UNLOCK);
 382         if (ret)
 383                 return ret;
 384
 385         status_old = read_sr(nor);
 386
 387         if (offset+len > mtd->size - (mtd->size / 64))
 388                 status_new = status_old & ~(SR_BP2 | SR_BP1 | SR_BP0);
 389         else if (offset+len > mtd->size - (mtd->size / 32))
 390                 status_new = (status_old & ~(SR_BP2 | SR_BP1)) | SR_BP0;
 391         else if (offset+len > mtd->size - (mtd->size / 16))
 392                 status_new = (status_old & ~(SR_BP2 | SR_BP0)) | SR_BP1;
 393         else if (offset+len > mtd->size - (mtd->size / 8))
 394                 status_new = (status_old & ~SR_BP2) | SR_BP1 | SR_BP0;
 395         else if (offset+len > mtd->size - (mtd->size / 4))
 396                 status_new = (status_old & ~(SR_BP0 | SR_BP1)) | SR_BP2;
 397         else if (offset+len > mtd->size - (mtd->size / 2))
 398                 status_new = (status_old & ~SR_BP1) | SR_BP2 | SR_BP0;
 399         else
 400                 status_new = (status_old & ~SR_BP0) | SR_BP2 | SR_BP1;
 401
 402         /* Only modify protection if it will not lock other areas */
 403         if ((status_new & (SR_BP2 | SR_BP1 | SR_BP0)) <
 404                                 (status_old & (SR_BP2 | SR_BP1 | SR_BP0))) {
 405                 write_enable(nor);
 406                 ret = write_sr(nor, status_new);
 407                 if (ret)
 408                         goto err;
 409         }
 410
 411 err:
 412         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_UNLOCK);
 413         return ret;
 414 }
 415
 416 struct flash_info {
 417         /* JEDEC id zero means "no ID" (most older chips); otherwise it has
 418          * a high byte of zero plus three data bytes: the manufacturer id,
 419          * then a two byte device id.
 420          */
 421         u32             jedec_id;
 422         u16             ext_id;
 423
 424         /* The size listed here is what works with SPINOR_OP_SE, which isn't
 425          * necessarily called a "sector" by the vendor.
 426          */
 427         unsigned        sector_size;
 428         u16             n_sectors;
 429
 430         u16             page_size;
 431         u16             addr_width;
 432
 433         u16             flags;
 434 #define SECT_4K                 0x01    /* SPINOR_OP_BE_4K works uniformly */
 435 #define SPI_NOR_NO_ERASE        0x02    /* No erase command needed */
 436 #define SST_WRITE               0x04    /* use SST byte programming */
 437 #define SPI_NOR_NO_FR           0x08    /* Can't do fastread */
 438 #define SECT_4K_PMC             0x10    /* SPINOR_OP_BE_4K_PMC works uniformly */
 439 #define SPI_NOR_DUAL_READ       0x20    /* Flash supports Dual Read */
 440 #define SPI_NOR_QUAD_READ       0x40    /* Flash supports Quad Read */
 441 #define USE_FSR                 0x80    /* use flag status register */
 442 };
 443
 444 #define INFO(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags)      \
 445         ((kernel_ulong_t)&(struct flash_info) {                         \
 446                 .jedec_id = (_jedec_id),                                \
 447                 .ext_id = (_ext_id),                                    \
 448                 .sector_size = (_sector_size),                          \
 449                 .n_sectors = (_n_sectors),                              \
 450                 .page_size = 256,                                       \
 451                 .flags = (_flags),                                      \
 452         })
 453
 454 #define CAT25_INFO(_sector_size, _n_sectors, _page_size, _addr_width, _flags)   \
 455         ((kernel_ulong_t)&(struct flash_info) {                         \
 456                 .sector_size = (_sector_size),                          \
 457                 .n_sectors = (_n_sectors),                              \
 458                 .page_size = (_page_size),                              \
 459                 .addr_width = (_addr_width),                            \
 460                 .flags = (_flags),                                      \
 461         })
 462
 463 /* NOTE: double check command sets and memory organization when you add
 464  * more nor chips.  This current list focusses on newer chips, which
 465  * have been converging on command sets which including JEDEC ID.
 466  */
 467 static const struct spi_device_id spi_nor_ids[] = {
 468         /* Atmel -- some are (confusingly) marketed as "DataFlash" */
 469         { "at25fs010",  INFO(0x1f6601, 0, 32 * 1024,   4, SECT_4K) },
 470         { "at25fs040",  INFO(0x1f6604, 0, 64 * 1024,   8, SECT_4K) },
 471
 472         { "at25df041a", INFO(0x1f4401, 0, 64 * 1024,   8, SECT_4K) },
 473         { "at25df321a", INFO(0x1f4701, 0, 64 * 1024,  64, SECT_4K) },
 474         { "at25df641",  INFO(0x1f4800, 0, 64 * 1024, 128, SECT_4K) },
 475
 476         { "at26f004",   INFO(0x1f0400, 0, 64 * 1024,  8, SECT_4K) },
 477         { "at26df081a", INFO(0x1f4501, 0, 64 * 1024, 16, SECT_4K) },
 478         { "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32, SECT_4K) },
 479         { "at26df321",  INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K) },
 480
 481         { "at45db081d", INFO(0x1f2500, 0, 64 * 1024, 16, SECT_4K) },
 482
 483         /* EON -- en25xxx */
 484         { "en25f32",    INFO(0x1c3116, 0, 64 * 1024,   64, SECT_4K) },
 485         { "en25p32",    INFO(0x1c2016, 0, 64 * 1024,   64, 0) },
 486         { "en25q32b",   INFO(0x1c3016, 0, 64 * 1024,   64, 0) },
 487         { "en25p64",    INFO(0x1c2017, 0, 64 * 1024,  128, 0) },
 488         { "en25q64",    INFO(0x1c3017, 0, 64 * 1024,  128, SECT_4K) },
 489         { "en25qh128",  INFO(0x1c7018, 0, 64 * 1024,  256, 0) },
 490         { "en25qh256",  INFO(0x1c7019, 0, 64 * 1024,  512, 0) },
 491
 492         /* ESMT */
 493         { "f25l32pa", INFO(0x8c2016, 0, 64 * 1024, 64, SECT_4K) },
 494
 495         /* Everspin */
 496         { "mr25h256", CAT25_INFO( 32 * 1024, 1, 256, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
 497         { "mr25h10",  CAT25_INFO(128 * 1024, 1, 256, 3, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
 498
 499         /* GigaDevice */
 500         { "gd25q32", INFO(0xc84016, 0, 64 * 1024,  64, SECT_4K) },
 501         { "gd25q64", INFO(0xc84017, 0, 64 * 1024, 128, SECT_4K) },
 502
 503         /* Intel/Numonyx -- xxxs33b */
 504         { "160s33b",  INFO(0x898911, 0, 64 * 1024,  32, 0) },
 505         { "320s33b",  INFO(0x898912, 0, 64 * 1024,  64, 0) },
 506         { "640s33b",  INFO(0x898913, 0, 64 * 1024, 128, 0) },
 507
 508         /* Macronix */
 509         { "mx25l2005a",  INFO(0xc22012, 0, 64 * 1024,   4, SECT_4K) },
 510         { "mx25l4005a",  INFO(0xc22013, 0, 64 * 1024,   8, SECT_4K) },
 511         { "mx25l8005",   INFO(0xc22014, 0, 64 * 1024,  16, 0) },
 512         { "mx25l1606e",  INFO(0xc22015, 0, 64 * 1024,  32, SECT_4K) },
 513         { "mx25l3205d",  INFO(0xc22016, 0, 64 * 1024,  64, 0) },
 514         { "mx25l3255e",  INFO(0xc29e16, 0, 64 * 1024,  64, SECT_4K) },
 515         { "mx25l6405d",  INFO(0xc22017, 0, 64 * 1024, 128, 0) },
 516         { "mx25l12805d", INFO(0xc22018, 0, 64 * 1024, 256, 0) },
 517         { "mx25l12855e", INFO(0xc22618, 0, 64 * 1024, 256, 0) },
 518         { "mx25l25635e", INFO(0xc22019, 0, 64 * 1024, 512, 0) },
 519         { "mx25l25655e", INFO(0xc22619, 0, 64 * 1024, 512, 0) },
 520         { "mx66l51235l", INFO(0xc2201a, 0, 64 * 1024, 1024, SPI_NOR_QUAD_READ) },
 521         { "mx66l1g55g",  INFO(0xc2261b, 0, 64 * 1024, 2048, SPI_NOR_QUAD_READ) },
 522
 523         /* Micron */
 524         { "n25q032",     INFO(0x20ba16, 0, 64 * 1024,   64, 0) },
 525         { "n25q064",     INFO(0x20ba17, 0, 64 * 1024,  128, 0) },
 526         { "n25q128a11",  INFO(0x20bb18, 0, 64 * 1024,  256, 0) },
 527         { "n25q128a13",  INFO(0x20ba18, 0, 64 * 1024,  256, 0) },
 528         { "n25q256a",    INFO(0x20ba19, 0, 64 * 1024,  512, SECT_4K) },
 529         { "n25q512a",    INFO(0x20bb20, 0, 64 * 1024, 1024, SECT_4K) },
 530         { "n25q512ax3",  INFO(0x20ba20, 0, 64 * 1024, 1024, USE_FSR) },
 531         { "n25q00",      INFO(0x20ba21, 0, 64 * 1024, 2048, USE_FSR) },
 532
 533         /* PMC */
 534         { "pm25lv512",   INFO(0,        0, 32 * 1024,    2, SECT_4K_PMC) },
 535         { "pm25lv010",   INFO(0,        0, 32 * 1024,    4, SECT_4K_PMC) },
 536         { "pm25lq032",   INFO(0x7f9d46, 0, 64 * 1024,   64, SECT_4K) },
 537
 538         /* Spansion -- single (large) sector size only, at least
 539          * for the chips listed here (without boot sectors).
 540          */
 541         { "s25sl032p",  INFO(0x010215, 0x4d00,  64 * 1024,  64, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
 542         { "s25sl064p",  INFO(0x010216, 0x4d00,  64 * 1024, 128, 0) },
 543         { "s25fl256s0", INFO(0x010219, 0x4d00, 256 * 1024, 128, 0) },
 544         { "s25fl256s1", INFO(0x010219, 0x4d01,  64 * 1024, 512, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
 545         { "s25fl512s",  INFO(0x010220, 0x4d00, 256 * 1024, 256, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
 546         { "s70fl01gs",  INFO(0x010221, 0x4d00, 256 * 1024, 256, 0) },
 547         { "s25sl12800", INFO(0x012018, 0x0300, 256 * 1024,  64, 0) },
 548         { "s25sl12801", INFO(0x012018, 0x0301,  64 * 1024, 256, 0) },
 549         { "s25fl129p0", INFO(0x012018, 0x4d00, 256 * 1024,  64, 0) },
 550         { "s25fl129p1", INFO(0x012018, 0x4d01,  64 * 1024, 256, 0) },
 551         { "s25sl004a",  INFO(0x010212,      0,  64 * 1024,   8, 0) },
 552         { "s25sl008a",  INFO(0x010213,      0,  64 * 1024,  16, 0) },
 553         { "s25sl016a",  INFO(0x010214,      0,  64 * 1024,  32, 0) },
 554         { "s25sl032a",  INFO(0x010215,      0,  64 * 1024,  64, 0) },
 555         { "s25sl064a",  INFO(0x010216,      0,  64 * 1024, 128, 0) },
 556         { "s25fl008k",  INFO(0xef4014,      0,  64 * 1024,  16, SECT_4K) },
 557         { "s25fl016k",  INFO(0xef4015,      0,  64 * 1024,  32, SECT_4K) },
 558         { "s25fl064k",  INFO(0xef4017,      0,  64 * 1024, 128, SECT_4K) },
 559
 560         /* SST -- large erase sizes are "overlays", "sectors" are 4K */
 561         { "sst25vf040b", INFO(0xbf258d, 0, 64 * 1024,  8, SECT_4K | SST_WRITE) },
 562         { "sst25vf080b", INFO(0xbf258e, 0, 64 * 1024, 16, SECT_4K | SST_WRITE) },
 563         { "sst25vf016b", INFO(0xbf2541, 0, 64 * 1024, 32, SECT_4K | SST_WRITE) },
 564         { "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64, SECT_4K | SST_WRITE) },
 565         { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128, SECT_4K) },
 566         { "sst25wf512",  INFO(0xbf2501, 0, 64 * 1024,  1, SECT_4K | SST_WRITE) },
 567         { "sst25wf010",  INFO(0xbf2502, 0, 64 * 1024,  2, SECT_4K | SST_WRITE) },
 568         { "sst25wf020",  INFO(0xbf2503, 0, 64 * 1024,  4, SECT_4K | SST_WRITE) },
 569         { "sst25wf040",  INFO(0xbf2504, 0, 64 * 1024,  8, SECT_4K | SST_WRITE) },
 570
 571         /* ST Microelectronics -- newer production may have feature updates */
 572         { "m25p05",  INFO(0x202010,  0,  32 * 1024,   2, 0) },
 573         { "m25p10",  INFO(0x202011,  0,  32 * 1024,   4, 0) },
 574         { "m25p20",  INFO(0x202012,  0,  64 * 1024,   4, 0) },
 575         { "m25p40",  INFO(0x202013,  0,  64 * 1024,   8, 0) },
 576         { "m25p80",  INFO(0x202014,  0,  64 * 1024,  16, 0) },
 577         { "m25p16",  INFO(0x202015,  0,  64 * 1024,  32, 0) },
 578         { "m25p32",  INFO(0x202016,  0,  64 * 1024,  64, 0) },
 579         { "m25p64",  INFO(0x202017,  0,  64 * 1024, 128, 0) },
 580         { "m25p128", INFO(0x202018,  0, 256 * 1024,  64, 0) },
 581
 582         { "m25p05-nonjedec",  INFO(0, 0,  32 * 1024,   2, 0) },
 583         { "m25p10-nonjedec",  INFO(0, 0,  32 * 1024,   4, 0) },
 584         { "m25p20-nonjedec",  INFO(0, 0,  64 * 1024,   4, 0) },
 585         { "m25p40-nonjedec",  INFO(0, 0,  64 * 1024,   8, 0) },
 586         { "m25p80-nonjedec",  INFO(0, 0,  64 * 1024,  16, 0) },
 587         { "m25p16-nonjedec",  INFO(0, 0,  64 * 1024,  32, 0) },
 588         { "m25p32-nonjedec",  INFO(0, 0,  64 * 1024,  64, 0) },
 589         { "m25p64-nonjedec",  INFO(0, 0,  64 * 1024, 128, 0) },
 590         { "m25p128-nonjedec", INFO(0, 0, 256 * 1024,  64, 0) },
 591
 592         { "m45pe10", INFO(0x204011,  0, 64 * 1024,    2, 0) },
 593         { "m45pe80", INFO(0x204014,  0, 64 * 1024,   16, 0) },
 594         { "m45pe16", INFO(0x204015,  0, 64 * 1024,   32, 0) },
 595
 596         { "m25pe20", INFO(0x208012,  0, 64 * 1024,  4,       0) },
 597         { "m25pe80", INFO(0x208014,  0, 64 * 1024, 16,       0) },
 598         { "m25pe16", INFO(0x208015,  0, 64 * 1024, 32, SECT_4K) },
 599
 600         { "m25px16",    INFO(0x207115,  0, 64 * 1024, 32, SECT_4K) },
 601         { "m25px32",    INFO(0x207116,  0, 64 * 1024, 64, SECT_4K) },
 602         { "m25px32-s0", INFO(0x207316,  0, 64 * 1024, 64, SECT_4K) },
 603         { "m25px32-s1", INFO(0x206316,  0, 64 * 1024, 64, SECT_4K) },
 604         { "m25px64",    INFO(0x207117,  0, 64 * 1024, 128, 0) },
 605         { "m25px80",    INFO(0x207114,  0, 64 * 1024, 16, 0) },
 606
 607         /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
 608         { "w25x10", INFO(0xef3011, 0, 64 * 1024,  2,  SECT_4K) },
 609         { "w25x20", INFO(0xef3012, 0, 64 * 1024,  4,  SECT_4K) },
 610         { "w25x40", INFO(0xef3013, 0, 64 * 1024,  8,  SECT_4K) },
 611         { "w25x80", INFO(0xef3014, 0, 64 * 1024,  16, SECT_4K) },
 612         { "w25x16", INFO(0xef3015, 0, 64 * 1024,  32, SECT_4K) },
 613         { "w25x32", INFO(0xef3016, 0, 64 * 1024,  64, SECT_4K) },
 614         { "w25q32", INFO(0xef4016, 0, 64 * 1024,  64, SECT_4K) },
 615         { "w25q32dw", INFO(0xef6016, 0, 64 * 1024,  64, SECT_4K) },
 616         { "w25x64", INFO(0xef3017, 0, 64 * 1024, 128, SECT_4K) },
 617         { "w25q64", INFO(0xef4017, 0, 64 * 1024, 128, SECT_4K) },
 618         { "w25q80", INFO(0xef5014, 0, 64 * 1024,  16, SECT_4K) },
 619         { "w25q80bl", INFO(0xef4014, 0, 64 * 1024,  16, SECT_4K) },
 620         { "w25q128", INFO(0xef4018, 0, 64 * 1024, 256, SECT_4K) },
 621         { "w25q256", INFO(0xef4019, 0, 64 * 1024, 512, SECT_4K) },
 622
 623         /* Catalyst / On Semiconductor -- non-JEDEC */
 624         { "cat25c11", CAT25_INFO(  16, 8, 16, 1, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
 625         { "cat25c03", CAT25_INFO(  32, 8, 16, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
 626         { "cat25c09", CAT25_INFO( 128, 8, 32, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
 627         { "cat25c17", CAT25_INFO( 256, 8, 32, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
 628         { "cat25128", CAT25_INFO(2048, 8, 64, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
 629         { },
 630 };
 631
 632 static const struct spi_device_id *spi_nor_read_id(struct spi_nor *nor)
 633 {
 634         int                     tmp;
 635         u8                      id[5];
 636         u32                     jedec;
 637         u16                     ext_jedec;
 638         struct flash_info       *info;
 639
 640         tmp = nor->read_reg(nor, SPINOR_OP_RDID, id, 5);
 641         if (tmp < 0) {
 642                 dev_dbg(nor->dev, " error %d reading JEDEC ID\n", tmp);
 643                 return ERR_PTR(tmp);
 644         }
 645         jedec = id[0];
 646         jedec = jedec << 8;
 647         jedec |= id[1];
 648         jedec = jedec << 8;
 649         jedec |= id[2];
 650
 651         ext_jedec = id[3] << 8 | id[4];
 652
 653         for (tmp = 0; tmp < ARRAY_SIZE(spi_nor_ids) - 1; tmp++) {
 654                 info = (void *)spi_nor_ids[tmp].driver_data;
 655                 if (info->jedec_id == jedec) {
 656                         if (info->ext_id == 0 || info->ext_id == ext_jedec)
 657                                 return &spi_nor_ids[tmp];
 658                 }
 659         }
 660         dev_err(nor->dev, "unrecognized JEDEC id %06x\n", jedec);
 661         return ERR_PTR(-ENODEV);
 662 }
 663
 664 static int spi_nor_read(struct mtd_info *mtd, loff_t from, size_t len,
 665                         size_t *retlen, u_char *buf)
 666 {
 667         struct spi_nor *nor = mtd_to_spi_nor(mtd);
 668         int ret;
 669
 670         dev_dbg(nor->dev, "from 0x%08x, len %zd\n", (u32)from, len);
 671
 672         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_READ);
 673         if (ret)
 674                 return ret;
 675
 676         ret = nor->read(nor, from, len, retlen, buf);
 677
 678         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_READ);
 679         return ret;
 680 }
 681
 682 static int sst_write(struct mtd_info *mtd, loff_t to, size_t len,
 683                 size_t *retlen, const u_char *buf)
 684 {
 685         struct spi_nor *nor = mtd_to_spi_nor(mtd);
 686         size_t actual;
 687         int ret;
 688
 689         dev_dbg(nor->dev, "to 0x%08x, len %zd\n", (u32)to, len);
 690
 691         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_WRITE);
 692         if (ret)
 693                 return ret;
 694
 695         write_enable(nor);
 696
 697         nor->sst_write_second = false;
 698
 699         actual = to % 2;
 700         /* Start write from odd address. */
 701         if (actual) {
 702                 nor->program_opcode = SPINOR_OP_BP;
 703
 704                 /* write one byte. */
 705                 nor->write(nor, to, 1, retlen, buf);
 706                 ret = spi_nor_wait_till_ready(nor);
 707                 if (ret)
 708                         goto time_out;
 709         }
 710         to += actual;
 711
 712         /* Write out most of the data here. */
 713         for (; actual < len - 1; actual += 2) {
 714                 nor->program_opcode = SPINOR_OP_AAI_WP;
 715
 716                 /* write two bytes. */
 717                 nor->write(nor, to, 2, retlen, buf + actual);
 718                 ret = spi_nor_wait_till_ready(nor);
 719                 if (ret)
 720                         goto time_out;
 721                 to += 2;
 722                 nor->sst_write_second = true;
 723         }
 724         nor->sst_write_second = false;
 725
 726         write_disable(nor);
 727         ret = spi_nor_wait_till_ready(nor);
 728         if (ret)
 729                 goto time_out;
 730
 731         /* Write out trailing byte if it exists. */
 732         if (actual != len) {
 733                 write_enable(nor);
 734
 735                 nor->program_opcode = SPINOR_OP_BP;
 736                 nor->write(nor, to, 1, retlen, buf + actual);
 737
 738                 ret = spi_nor_wait_till_ready(nor);
 739                 if (ret)
 740                         goto time_out;
 741                 write_disable(nor);
 742         }
 743 time_out:
 744         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_WRITE);
 745         return ret;
 746 }
 747
 748 /*
 749  * Write an address range to the nor chip.  Data must be written in
 750  * FLASH_PAGESIZE chunks.  The address range may be any size provided
 751  * it is within the physical boundaries.
 752  */
 753 static int spi_nor_write(struct mtd_info *mtd, loff_t to, size_t len,
 754         size_t *retlen, const u_char *buf)
 755 {
 756         struct spi_nor *nor = mtd_to_spi_nor(mtd);
 757         u32 page_offset, page_size, i;
 758         int ret;
 759
 760         dev_dbg(nor->dev, "to 0x%08x, len %zd\n", (u32)to, len);
 761
 762         ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_WRITE);
 763         if (ret)
 764                 return ret;
 765
 766         write_enable(nor);
 767
 768         page_offset = to & (nor->page_size - 1);
 769
 770         /* do all the bytes fit onto one page? */
 771         if (page_offset + len <= nor->page_size) {
 772                 nor->write(nor, to, len, retlen, buf);
 773         } else {
 774                 /* the size of data remaining on the first page */
 775                 page_size = nor->page_size - page_offset;
 776                 nor->write(nor, to, page_size, retlen, buf);
 777
 778                 /* write everything in nor->page_size chunks */
 779                 for (i = page_size; i < len; i += page_size) {
 780                         page_size = len - i;
 781                         if (page_size > nor->page_size)
 782                                 page_size = nor->page_size;
 783
 784                         ret = spi_nor_wait_till_ready(nor);
 785                         if (ret)
 786                                 goto write_err;
 787
 788                         write_enable(nor);
 789
 790                         nor->write(nor, to + i, page_size, retlen, buf + i);
 791                 }
 792         }
 793
 794         ret = spi_nor_wait_till_ready(nor);
 795 write_err:
 796         spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_WRITE);
 797         return ret;
 798 }
 799
 800 static int macronix_quad_enable(struct spi_nor *nor)
 801 {
 802         int ret, val;
 803
 804         val = read_sr(nor);
 805         write_enable(nor);
 806
 807         nor->cmd_buf[0] = val | SR_QUAD_EN_MX;
 808         nor->write_reg(nor, SPINOR_OP_WRSR, nor->cmd_buf, 1, 0);
 809
 810         if (spi_nor_wait_till_ready(nor))
 811                 return 1;
 812
 813         ret = read_sr(nor);
 814         if (!(ret > 0 && (ret & SR_QUAD_EN_MX))) {
 815                 dev_err(nor->dev, "Macronix Quad bit not set\n");
 816                 return -EINVAL;
 817         }
 818
 819         return 0;
 820 }
 821
 822 /*
 823  * Write status Register and configuration register with 2 bytes
 824  * The first byte will be written to the status register, while the
 825  * second byte will be written to the configuration register.
 826  * Return negative if error occured.
 827  */
 828 static int write_sr_cr(struct spi_nor *nor, u16 val)
 829 {
 830         nor->cmd_buf[0] = val & 0xff;
 831         nor->cmd_buf[1] = (val >> 8);
 832
 833         return nor->write_reg(nor, SPINOR_OP_WRSR, nor->cmd_buf, 2, 0);
 834 }
 835
 836 static int spansion_quad_enable(struct spi_nor *nor)
 837 {
 838         int ret;
 839         int quad_en = CR_QUAD_EN_SPAN << 8;
 840
 841         write_enable(nor);
 842
 843         ret = write_sr_cr(nor, quad_en);
 844         if (ret < 0) {
 845                 dev_err(nor->dev,
 846                         "error while writing configuration register\n");
 847                 return -EINVAL;
 848         }
 849
 850         /* read back and check it */
 851         ret = read_cr(nor);
 852         if (!(ret > 0 && (ret & CR_QUAD_EN_SPAN))) {
 853                 dev_err(nor->dev, "Spansion Quad bit not set\n");
 854                 return -EINVAL;
 855         }
 856
 857         return 0;
 858 }
 859
 860 static int set_quad_mode(struct spi_nor *nor, u32 jedec_id)
 861 {
 862         int status;
 863
 864         switch (JEDEC_MFR(jedec_id)) {
 865         case CFI_MFR_MACRONIX:
 866                 status = macronix_quad_enable(nor);
 867                 if (status) {
 868                         dev_err(nor->dev, "Macronix quad-read not enabled\n");
 869                         return -EINVAL;
 870                 }
 871                 return status;
 872         default:
 873                 status = spansion_quad_enable(nor);
 874                 if (status) {
 875                         dev_err(nor->dev, "Spansion quad-read not enabled\n");
 876                         return -EINVAL;
 877                 }
 878                 return status;
 879         }
 880 }
 881
 882 static int spi_nor_check(struct spi_nor *nor)
 883 {
 884         if (!nor->dev || !nor->read || !nor->write ||
 885                 !nor->read_reg || !nor->write_reg || !nor->erase) {
 886                 pr_err("spi-nor: please fill all the necessary fields!\n");
 887                 return -EINVAL;
 888         }
 889
 890         return 0;
 891 }
 892
 893 int spi_nor_scan(struct spi_nor *nor, const char *name, enum read_mode mode)
 894 {
 895         const struct spi_device_id      *id = NULL;
 896         struct flash_info               *info;
 897         struct device *dev = nor->dev;
 898         struct mtd_info *mtd = nor->mtd;
 899         struct device_node *np = dev->of_node;
 900         int ret;
 901         int i;
 902
 903         ret = spi_nor_check(nor);
 904         if (ret)
 905                 return ret;
 906
 907         id = spi_nor_match_id(name);
 908         if (!id)
 909                 return -ENOENT;
 910
 911         info = (void *)id->driver_data;
 912
 913         if (info->jedec_id) {
 914                 const struct spi_device_id *jid;
 915
 916                 jid = spi_nor_read_id(nor);
 917                 if (IS_ERR(jid)) {
 918                         return PTR_ERR(jid);
 919                 } else if (jid != id) {
 920                         /*
 921                          * JEDEC knows better, so overwrite platform ID. We
 922                          * can't trust partitions any longer, but we'll let
 923                          * mtd apply them anyway, since some partitions may be
 924                          * marked read-only, and we don't want to lose that
 925                          * information, even if it's not 100% accurate.
 926                          */
 927                         dev_warn(dev, "found %s, expected %s\n",
 928                                  jid->name, id->name);
 929                         id = jid;
 930                         info = (void *)jid->driver_data;
 931                 }
 932         }
 933
 934         mutex_init(&nor->lock);
 935
 936         /*
 937          * Atmel, SST and Intel/Numonyx serial nor tend to power
 938          * up with the software protection bits set
 939          */
 940
 941         if (JEDEC_MFR(info->jedec_id) == CFI_MFR_ATMEL ||
 942             JEDEC_MFR(info->jedec_id) == CFI_MFR_INTEL ||
 943             JEDEC_MFR(info->jedec_id) == CFI_MFR_SST) {
 944                 write_enable(nor);
 945                 write_sr(nor, 0);
 946         }
 947
 948         if (!mtd->name)
 949                 mtd->name = dev_name(dev);
 950         mtd->type = MTD_NORFLASH;
 951         mtd->writesize = 1;
 952         mtd->flags = MTD_CAP_NORFLASH;
 953         mtd->size = info->sector_size * info->n_sectors;
 954         mtd->_erase = spi_nor_erase;
 955         mtd->_read = spi_nor_read;
 956
 957         /* nor protection support for STmicro chips */
 958         if (JEDEC_MFR(info->jedec_id) == CFI_MFR_ST) {
 959                 mtd->_lock = spi_nor_lock;
 960                 mtd->_unlock = spi_nor_unlock;
 961         }
 962
 963         /* sst nor chips use AAI word program */
 964         if (info->flags & SST_WRITE)
 965                 mtd->_write = sst_write;
 966         else
 967                 mtd->_write = spi_nor_write;
 968
 969         if (info->flags & USE_FSR)
 970                 nor->flags |= SNOR_F_USE_FSR;
 971
 972 #ifdef CONFIG_MTD_SPI_NOR_USE_4K_SECTORS
 973         /* prefer "small sector" erase if possible */
 974         if (info->flags & SECT_4K) {
 975                 nor->erase_opcode = SPINOR_OP_BE_4K;
 976                 mtd->erasesize = 4096;
 977         } else if (info->flags & SECT_4K_PMC) {
 978                 nor->erase_opcode = SPINOR_OP_BE_4K_PMC;
 979                 mtd->erasesize = 4096;
 980         } else
 981 #endif
 982         {
 983                 nor->erase_opcode = SPINOR_OP_SE;
 984                 mtd->erasesize = info->sector_size;
 985         }
 986
 987         if (info->flags & SPI_NOR_NO_ERASE)
 988                 mtd->flags |= MTD_NO_ERASE;
 989
 990         mtd->dev.parent = dev;
 991         nor->page_size = info->page_size;
 992         mtd->writebufsize = nor->page_size;
 993
 994         if (np) {
 995                 /* If we were instantiated by DT, use it */
 996                 if (of_property_read_bool(np, "m25p,fast-read"))
 997                         nor->flash_read = SPI_NOR_FAST;
 998                 else
 999                         nor->flash_read = SPI_NOR_NORMAL;
1000         } else {
1001                 /* If we weren't instantiated by DT, default to fast-read */
1002                 nor->flash_read = SPI_NOR_FAST;
1003         }
1004
1005         /* Some devices cannot do fast-read, no matter what DT tells us */
1006         if (info->flags & SPI_NOR_NO_FR)
1007                 nor->flash_read = SPI_NOR_NORMAL;
1008
1009         /* Quad/Dual-read mode takes precedence over fast/normal */
1010         if (mode == SPI_NOR_QUAD && info->flags & SPI_NOR_QUAD_READ) {
1011                 ret = set_quad_mode(nor, info->jedec_id);
1012                 if (ret) {
1013                         dev_err(dev, "quad mode not supported\n");
1014                         return ret;
1015                 }
1016                 nor->flash_read = SPI_NOR_QUAD;
1017         } else if (mode == SPI_NOR_DUAL && info->flags & SPI_NOR_DUAL_READ) {
1018                 nor->flash_read = SPI_NOR_DUAL;
1019         }
1020
1021         /* Default commands */
1022         switch (nor->flash_read) {
1023         case SPI_NOR_QUAD:
1024                 nor->read_opcode = SPINOR_OP_READ_1_1_4;
1025                 break;
1026         case SPI_NOR_DUAL:
1027                 nor->read_opcode = SPINOR_OP_READ_1_1_2;
1028                 break;
1029         case SPI_NOR_FAST:
1030                 nor->read_opcode = SPINOR_OP_READ_FAST;
1031                 break;
1032         case SPI_NOR_NORMAL:
1033                 nor->read_opcode = SPINOR_OP_READ;
1034                 break;
1035         default:
1036                 dev_err(dev, "No Read opcode defined\n");
1037                 return -EINVAL;
1038         }
1039
1040         nor->program_opcode = SPINOR_OP_PP;
1041
1042         if (info->addr_width)
1043                 nor->addr_width = info->addr_width;
1044         else if (mtd->size > 0x1000000) {
1045                 /* enable 4-byte addressing if the device exceeds 16MiB */
1046                 nor->addr_width = 4;
1047                 if (JEDEC_MFR(info->jedec_id) == CFI_MFR_AMD) {
1048                         /* Dedicated 4-byte command set */
1049                         switch (nor->flash_read) {
1050                         case SPI_NOR_QUAD:
1051                                 nor->read_opcode = SPINOR_OP_READ4_1_1_4;
1052                                 break;
1053                         case SPI_NOR_DUAL:
1054                                 nor->read_opcode = SPINOR_OP_READ4_1_1_2;
1055                                 break;
1056                         case SPI_NOR_FAST:
1057                                 nor->read_opcode = SPINOR_OP_READ4_FAST;
1058                                 break;
1059                         case SPI_NOR_NORMAL:
1060                                 nor->read_opcode = SPINOR_OP_READ4;
1061                                 break;
1062                         }
1063                         nor->program_opcode = SPINOR_OP_PP_4B;
1064                         /* No small sector erase for 4-byte command set */
1065                         nor->erase_opcode = SPINOR_OP_SE_4B;
1066                         mtd->erasesize = info->sector_size;
1067                 } else
1068                         set_4byte(nor, info->jedec_id, 1);
1069         } else {
1070                 nor->addr_width = 3;
1071         }
1072
1073         nor->read_dummy = spi_nor_read_dummy_cycles(nor);
1074
1075         dev_info(dev, "%s (%lld Kbytes)\n", id->name,
1076                         (long long)mtd->size >> 10);
1077
1078         dev_dbg(dev,
1079                 "mtd .name = %s, .size = 0x%llx (%lldMiB), "
1080                 ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
1081                 mtd->name, (long long)mtd->size, (long long)(mtd->size >> 20),
1082                 mtd->erasesize, mtd->erasesize / 1024, mtd->numeraseregions);
1083
1084         if (mtd->numeraseregions)
1085                 for (i = 0; i < mtd->numeraseregions; i++)
1086                         dev_dbg(dev,
1087                                 "mtd.eraseregions[%d] = { .offset = 0x%llx, "
1088                                 ".erasesize = 0x%.8x (%uKiB), "
1089                                 ".numblocks = %d }\n",
1090                                 i, (long long)mtd->eraseregions[i].offset,
1091                                 mtd->eraseregions[i].erasesize,
1092                                 mtd->eraseregions[i].erasesize / 1024,
1093                                 mtd->eraseregions[i].numblocks);
1094         return 0;
1095 }
1096 EXPORT_SYMBOL_GPL(spi_nor_scan);
1097
1098 static const struct spi_device_id *spi_nor_match_id(const char *name)
1099 {
1100         const struct spi_device_id *id = spi_nor_ids;
1101
1102         while (id->name[0]) {
1103                 if (!strcmp(name, id->name))
1104                         return id;
1105                 id++;
1106         }
1107         return NULL;
1108 }
1109
1110 MODULE_LICENSE("GPL");
1111 MODULE_AUTHOR("Huang Shijie <shijie8@gmail.com>");
1112 MODULE_AUTHOR("Mike Lavender");
1113 MODULE_DESCRIPTION("framework for SPI NOR");