drivers/mtd/devices/m25p80.c

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