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