2014-02-24 18:37:37 +08:00
|
|
|
/*
|
2014-04-10 16:27:28 +08:00
|
|
|
* Based on m25p80.c, by Mike Lavender (mike@steroidmicros.com), with
|
|
|
|
* influence from lart.c (Abraham Van Der Merwe) and mtd_dataflash.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005, Intec Automation Inc.
|
|
|
|
* Copyright (C) 2014, Freescale Semiconductor, Inc.
|
2014-02-24 18:37:37 +08:00
|
|
|
*
|
|
|
|
* This code is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/math64.h>
|
mtd: spi-nor: scale up timeout for full-chip erase
This patch fixes timeout issues seen on large NOR flash (e.g., 16MB
w25q128fw) when using ioctl(MEMERASE) with offset=0 and length=16M. The
input parameters matter because spi_nor_erase() uses a different code
path for full-chip erase, where we use the SPINOR_OP_CHIP_ERASE (0xc7)
opcode.
Fix: use a different timeout for full-chip erase than for other
commands.
While most operations can be expected to perform relatively similarly
across a variety of NOR flash types and sizes (and therefore might as
well use a similar timeout to keep things simple), full-chip erase is
unique, because the time it typically takes to complete:
(1) is much larger than most operations and
(2) scales with the size of the flash.
Let's base our timeout on the original comments stuck here -- that a 2MB
flash requires max 40s to erase.
Small survey of a few flash datasheets I have lying around:
Chip Size (MB) Max chip erase (seconds)
---- -------- ------------------------
w25q32fw 4 50
w25q64cv 8 30
w25q64fw 8 100
w25q128fw 16 200
s25fl128s 16 ~256
s25fl256s 32 ~512
From this data, it seems plenty sufficient to say we need to wait for
40 seconds for each 2MB of flash.
After this change, it might make some sense to decrease the timeout for
everything else, as even the most extreme operations (single block
erase?) shouldn't take more than a handful of seconds. But for safety,
let's leave it as-is. It's only an error case, after all, so we don't
exactly need to optimize it.
Signed-off-by: Furquan Shaikh <furquan@google.com>
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-19 05:59:17 +08:00
|
|
|
#include <linux/sizes.h>
|
2017-06-26 21:10:00 +08:00
|
|
|
#include <linux/slab.h>
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
#include <linux/mtd/mtd.h>
|
|
|
|
#include <linux/of_platform.h>
|
|
|
|
#include <linux/spi/flash.h>
|
|
|
|
#include <linux/mtd/spi-nor.h>
|
|
|
|
|
|
|
|
/* Define max times to check status register before we give up. */
|
mtd: spi-nor: scale up timeout for full-chip erase
This patch fixes timeout issues seen on large NOR flash (e.g., 16MB
w25q128fw) when using ioctl(MEMERASE) with offset=0 and length=16M. The
input parameters matter because spi_nor_erase() uses a different code
path for full-chip erase, where we use the SPINOR_OP_CHIP_ERASE (0xc7)
opcode.
Fix: use a different timeout for full-chip erase than for other
commands.
While most operations can be expected to perform relatively similarly
across a variety of NOR flash types and sizes (and therefore might as
well use a similar timeout to keep things simple), full-chip erase is
unique, because the time it typically takes to complete:
(1) is much larger than most operations and
(2) scales with the size of the flash.
Let's base our timeout on the original comments stuck here -- that a 2MB
flash requires max 40s to erase.
Small survey of a few flash datasheets I have lying around:
Chip Size (MB) Max chip erase (seconds)
---- -------- ------------------------
w25q32fw 4 50
w25q64cv 8 30
w25q64fw 8 100
w25q128fw 16 200
s25fl128s 16 ~256
s25fl256s 32 ~512
From this data, it seems plenty sufficient to say we need to wait for
40 seconds for each 2MB of flash.
After this change, it might make some sense to decrease the timeout for
everything else, as even the most extreme operations (single block
erase?) shouldn't take more than a handful of seconds. But for safety,
let's leave it as-is. It's only an error case, after all, so we don't
exactly need to optimize it.
Signed-off-by: Furquan Shaikh <furquan@google.com>
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-19 05:59:17 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For everything but full-chip erase; probably could be much smaller, but kept
|
|
|
|
* around for safety for now
|
|
|
|
*/
|
|
|
|
#define DEFAULT_READY_WAIT_JIFFIES (40UL * HZ)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For full-chip erase, calibrated to a 2MB flash (M25P16); should be scaled up
|
|
|
|
* for larger flash
|
|
|
|
*/
|
|
|
|
#define CHIP_ERASE_2MB_READY_WAIT_JIFFIES (40UL * HZ)
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2014-11-06 11:24:33 +08:00
|
|
|
#define SPI_NOR_MAX_ID_LEN 6
|
2015-11-11 04:15:27 +08:00
|
|
|
#define SPI_NOR_MAX_ADDR_WIDTH 4
|
2014-11-06 11:24:33 +08:00
|
|
|
|
|
|
|
struct flash_info {
|
2015-08-11 03:39:03 +08:00
|
|
|
char *name;
|
|
|
|
|
2014-11-06 11:24:33 +08:00
|
|
|
/*
|
|
|
|
* This array stores the ID bytes.
|
|
|
|
* The first three bytes are the JEDIC ID.
|
|
|
|
* JEDEC ID zero means "no ID" (mostly older chips).
|
|
|
|
*/
|
|
|
|
u8 id[SPI_NOR_MAX_ID_LEN];
|
|
|
|
u8 id_len;
|
|
|
|
|
|
|
|
/* The size listed here is what works with SPINOR_OP_SE, which isn't
|
|
|
|
* necessarily called a "sector" by the vendor.
|
|
|
|
*/
|
|
|
|
unsigned sector_size;
|
|
|
|
u16 n_sectors;
|
|
|
|
|
|
|
|
u16 page_size;
|
|
|
|
u16 addr_width;
|
|
|
|
|
|
|
|
u16 flags;
|
2016-01-30 03:25:34 +08:00
|
|
|
#define SECT_4K BIT(0) /* SPINOR_OP_BE_4K works uniformly */
|
|
|
|
#define SPI_NOR_NO_ERASE BIT(1) /* No erase command needed */
|
|
|
|
#define SST_WRITE BIT(2) /* use SST byte programming */
|
|
|
|
#define SPI_NOR_NO_FR BIT(3) /* Can't do fastread */
|
|
|
|
#define SECT_4K_PMC BIT(4) /* SPINOR_OP_BE_4K_PMC works uniformly */
|
|
|
|
#define SPI_NOR_DUAL_READ BIT(5) /* Flash supports Dual Read */
|
|
|
|
#define SPI_NOR_QUAD_READ BIT(6) /* Flash supports Quad Read */
|
|
|
|
#define USE_FSR BIT(7) /* use flag status register */
|
2016-01-30 03:25:35 +08:00
|
|
|
#define SPI_NOR_HAS_LOCK BIT(8) /* Flash supports lock/unlock via SR */
|
2016-01-30 03:25:36 +08:00
|
|
|
#define SPI_NOR_HAS_TB BIT(9) /*
|
|
|
|
* Flash SR has Top/Bottom (TB) protect
|
|
|
|
* bit. Must be used with
|
|
|
|
* SPI_NOR_HAS_LOCK.
|
|
|
|
*/
|
2016-12-02 19:31:44 +08:00
|
|
|
#define SPI_S3AN BIT(10) /*
|
|
|
|
* Xilinx Spartan 3AN In-System Flash
|
|
|
|
* (MFR cannot be used for probing
|
|
|
|
* because it has the same value as
|
|
|
|
* ATMEL flashes)
|
|
|
|
*/
|
2016-10-27 18:03:57 +08:00
|
|
|
#define SPI_NOR_4B_OPCODES BIT(11) /*
|
|
|
|
* Use dedicated 4byte address op codes
|
|
|
|
* to support memory size above 128Mib.
|
|
|
|
*/
|
2017-01-07 01:19:00 +08:00
|
|
|
#define NO_CHIP_ERASE BIT(12) /* Chip does not support chip erase */
|
2017-06-26 21:10:00 +08:00
|
|
|
#define SPI_NOR_SKIP_SFDP BIT(13) /* Skip parsing of SFDP tables */
|
2017-07-17 23:54:07 +08:00
|
|
|
#define USE_CLSR BIT(14) /* use CLSR command */
|
2017-08-28 09:58:29 +08:00
|
|
|
|
|
|
|
int (*quad_enable)(struct spi_nor *nor);
|
2014-11-06 11:24:33 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
#define JEDEC_MFR(info) ((info)->id[0])
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2015-08-11 03:39:03 +08:00
|
|
|
static const struct flash_info *spi_nor_match_id(const char *name);
|
2014-09-29 17:47:54 +08:00
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/*
|
|
|
|
* Read the status register, returning its value in the location
|
|
|
|
* Return the status register value.
|
|
|
|
* Returns negative if error occurred.
|
|
|
|
*/
|
|
|
|
static int read_sr(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 val;
|
|
|
|
|
2014-04-09 09:15:31 +08:00
|
|
|
ret = nor->read_reg(nor, SPINOR_OP_RDSR, &val, 1);
|
2014-02-24 18:37:37 +08:00
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("error %d reading SR\n", (int) ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2014-04-29 23:29:51 +08:00
|
|
|
/*
|
|
|
|
* Read the flag status register, returning its value in the location
|
|
|
|
* Return the status register value.
|
|
|
|
* Returns negative if error occurred.
|
|
|
|
*/
|
|
|
|
static int read_fsr(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 val;
|
|
|
|
|
|
|
|
ret = nor->read_reg(nor, SPINOR_OP_RDFSR, &val, 1);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("error %d reading FSR\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/*
|
|
|
|
* Read configuration register, returning its value in the
|
|
|
|
* location. Return the configuration register value.
|
2017-01-27 09:36:38 +08:00
|
|
|
* Returns negative if error occurred.
|
2014-02-24 18:37:37 +08:00
|
|
|
*/
|
|
|
|
static int read_cr(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 val;
|
|
|
|
|
2014-04-09 09:15:31 +08:00
|
|
|
ret = nor->read_reg(nor, SPINOR_OP_RDCR, &val, 1);
|
2014-02-24 18:37:37 +08:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(nor->dev, "error %d reading CR\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write status register 1 byte
|
|
|
|
* Returns negative if error occurred.
|
|
|
|
*/
|
|
|
|
static inline int write_sr(struct spi_nor *nor, u8 val)
|
|
|
|
{
|
|
|
|
nor->cmd_buf[0] = val;
|
2015-08-19 17:56:44 +08:00
|
|
|
return nor->write_reg(nor, SPINOR_OP_WRSR, nor->cmd_buf, 1);
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set write enable latch with Write Enable command.
|
|
|
|
* Returns negative if error occurred.
|
|
|
|
*/
|
|
|
|
static inline int write_enable(struct spi_nor *nor)
|
|
|
|
{
|
2015-08-19 17:56:44 +08:00
|
|
|
return nor->write_reg(nor, SPINOR_OP_WREN, NULL, 0);
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2017-03-10 08:16:31 +08:00
|
|
|
* Send write disable instruction to the chip.
|
2014-02-24 18:37:37 +08:00
|
|
|
*/
|
|
|
|
static inline int write_disable(struct spi_nor *nor)
|
|
|
|
{
|
2015-08-19 17:56:44 +08:00
|
|
|
return nor->write_reg(nor, SPINOR_OP_WRDI, NULL, 0);
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct spi_nor *mtd_to_spi_nor(struct mtd_info *mtd)
|
|
|
|
{
|
|
|
|
return mtd->priv;
|
|
|
|
}
|
|
|
|
|
2016-10-27 18:03:57 +08:00
|
|
|
|
|
|
|
static u8 spi_nor_convert_opcode(u8 opcode, const u8 table[][2], size_t size)
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++)
|
|
|
|
if (table[i][0] == opcode)
|
|
|
|
return table[i][1];
|
|
|
|
|
|
|
|
/* No conversion found, keep input op code. */
|
|
|
|
return opcode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u8 spi_nor_convert_3to4_read(u8 opcode)
|
|
|
|
{
|
|
|
|
static const u8 spi_nor_3to4_read[][2] = {
|
|
|
|
{ SPINOR_OP_READ, SPINOR_OP_READ_4B },
|
|
|
|
{ SPINOR_OP_READ_FAST, SPINOR_OP_READ_FAST_4B },
|
|
|
|
{ SPINOR_OP_READ_1_1_2, SPINOR_OP_READ_1_1_2_4B },
|
|
|
|
{ SPINOR_OP_READ_1_2_2, SPINOR_OP_READ_1_2_2_4B },
|
|
|
|
{ SPINOR_OP_READ_1_1_4, SPINOR_OP_READ_1_1_4_4B },
|
|
|
|
{ SPINOR_OP_READ_1_4_4, SPINOR_OP_READ_1_4_4_4B },
|
2017-04-26 04:08:48 +08:00
|
|
|
|
|
|
|
{ SPINOR_OP_READ_1_1_1_DTR, SPINOR_OP_READ_1_1_1_DTR_4B },
|
|
|
|
{ SPINOR_OP_READ_1_2_2_DTR, SPINOR_OP_READ_1_2_2_DTR_4B },
|
|
|
|
{ SPINOR_OP_READ_1_4_4_DTR, SPINOR_OP_READ_1_4_4_DTR_4B },
|
2016-10-27 18:03:57 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
return spi_nor_convert_opcode(opcode, spi_nor_3to4_read,
|
|
|
|
ARRAY_SIZE(spi_nor_3to4_read));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u8 spi_nor_convert_3to4_program(u8 opcode)
|
|
|
|
{
|
|
|
|
static const u8 spi_nor_3to4_program[][2] = {
|
|
|
|
{ SPINOR_OP_PP, SPINOR_OP_PP_4B },
|
|
|
|
{ SPINOR_OP_PP_1_1_4, SPINOR_OP_PP_1_1_4_4B },
|
|
|
|
{ SPINOR_OP_PP_1_4_4, SPINOR_OP_PP_1_4_4_4B },
|
|
|
|
};
|
|
|
|
|
|
|
|
return spi_nor_convert_opcode(opcode, spi_nor_3to4_program,
|
|
|
|
ARRAY_SIZE(spi_nor_3to4_program));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u8 spi_nor_convert_3to4_erase(u8 opcode)
|
|
|
|
{
|
|
|
|
static const u8 spi_nor_3to4_erase[][2] = {
|
|
|
|
{ SPINOR_OP_BE_4K, SPINOR_OP_BE_4K_4B },
|
|
|
|
{ SPINOR_OP_BE_32K, SPINOR_OP_BE_32K_4B },
|
|
|
|
{ SPINOR_OP_SE, SPINOR_OP_SE_4B },
|
|
|
|
};
|
|
|
|
|
|
|
|
return spi_nor_convert_opcode(opcode, spi_nor_3to4_erase,
|
|
|
|
ARRAY_SIZE(spi_nor_3to4_erase));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spi_nor_set_4byte_opcodes(struct spi_nor *nor,
|
|
|
|
const struct flash_info *info)
|
|
|
|
{
|
|
|
|
/* Do some manufacturer fixups first */
|
|
|
|
switch (JEDEC_MFR(info)) {
|
|
|
|
case SNOR_MFR_SPANSION:
|
|
|
|
/* No small sector erase for 4-byte command set */
|
|
|
|
nor->erase_opcode = SPINOR_OP_SE;
|
|
|
|
nor->mtd.erasesize = info->sector_size;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
nor->read_opcode = spi_nor_convert_3to4_read(nor->read_opcode);
|
|
|
|
nor->program_opcode = spi_nor_convert_3to4_program(nor->program_opcode);
|
|
|
|
nor->erase_opcode = spi_nor_convert_3to4_erase(nor->erase_opcode);
|
|
|
|
}
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/* Enable/disable 4-byte addressing mode. */
|
2015-08-11 03:39:03 +08:00
|
|
|
static inline int set_4byte(struct spi_nor *nor, const struct flash_info *info,
|
2014-11-06 11:24:33 +08:00
|
|
|
int enable)
|
2014-02-24 18:37:37 +08:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
bool need_wren = false;
|
|
|
|
u8 cmd;
|
|
|
|
|
2014-11-06 11:24:33 +08:00
|
|
|
switch (JEDEC_MFR(info)) {
|
2015-09-02 03:57:09 +08:00
|
|
|
case SNOR_MFR_MICRON:
|
2014-02-24 18:37:37 +08:00
|
|
|
/* Some Micron need WREN command; all will accept it */
|
|
|
|
need_wren = true;
|
2015-09-02 03:57:09 +08:00
|
|
|
case SNOR_MFR_MACRONIX:
|
|
|
|
case SNOR_MFR_WINBOND:
|
2014-02-24 18:37:37 +08:00
|
|
|
if (need_wren)
|
|
|
|
write_enable(nor);
|
|
|
|
|
2014-04-09 09:15:31 +08:00
|
|
|
cmd = enable ? SPINOR_OP_EN4B : SPINOR_OP_EX4B;
|
2015-08-19 17:56:44 +08:00
|
|
|
status = nor->write_reg(nor, cmd, NULL, 0);
|
2014-02-24 18:37:37 +08:00
|
|
|
if (need_wren)
|
|
|
|
write_disable(nor);
|
|
|
|
|
2018-04-21 06:54:40 +08:00
|
|
|
if (!status && !enable &&
|
|
|
|
JEDEC_MFR(info) == SNOR_MFR_WINBOND) {
|
|
|
|
/*
|
|
|
|
* On Winbond W25Q256FV, leaving 4byte mode causes
|
|
|
|
* the Extended Address Register to be set to 1, so all
|
|
|
|
* 3-byte-address reads come from the second 16M.
|
|
|
|
* We must clear the register to enable normal behavior.
|
|
|
|
*/
|
|
|
|
write_enable(nor);
|
|
|
|
nor->cmd_buf[0] = 0;
|
|
|
|
nor->write_reg(nor, SPINOR_OP_WREAR, nor->cmd_buf, 1);
|
|
|
|
write_disable(nor);
|
|
|
|
}
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
return status;
|
|
|
|
default:
|
|
|
|
/* Spansion style */
|
|
|
|
nor->cmd_buf[0] = enable << 7;
|
2015-08-19 17:56:44 +08:00
|
|
|
return nor->write_reg(nor, SPINOR_OP_BRWR, nor->cmd_buf, 1);
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
}
|
2016-12-02 19:31:44 +08:00
|
|
|
|
|
|
|
static int s3an_sr_ready(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 val;
|
|
|
|
|
|
|
|
ret = nor->read_reg(nor, SPINOR_OP_XRDSR, &val, 1);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(nor->dev, "error %d reading XRDSR\n", (int) ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !!(val & XSR_RDY);
|
|
|
|
}
|
|
|
|
|
2014-09-10 15:26:16 +08:00
|
|
|
static inline int spi_nor_sr_ready(struct spi_nor *nor)
|
2014-02-24 18:37:37 +08:00
|
|
|
{
|
2014-09-10 15:26:16 +08:00
|
|
|
int sr = read_sr(nor);
|
|
|
|
if (sr < 0)
|
|
|
|
return sr;
|
2017-07-17 23:54:07 +08:00
|
|
|
|
|
|
|
if (nor->flags & SNOR_F_USE_CLSR && sr & (SR_E_ERR | SR_P_ERR)) {
|
|
|
|
if (sr & SR_E_ERR)
|
|
|
|
dev_err(nor->dev, "Erase Error occurred\n");
|
|
|
|
else
|
|
|
|
dev_err(nor->dev, "Programming Error occurred\n");
|
|
|
|
|
|
|
|
nor->write_reg(nor, SPINOR_OP_CLSR, NULL, 0);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !(sr & SR_WIP);
|
2014-09-10 15:26:16 +08:00
|
|
|
}
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2014-09-10 15:26:16 +08:00
|
|
|
static inline int spi_nor_fsr_ready(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
int fsr = read_fsr(nor);
|
|
|
|
if (fsr < 0)
|
|
|
|
return fsr;
|
2017-12-04 20:34:47 +08:00
|
|
|
|
|
|
|
if (fsr & (FSR_E_ERR | FSR_P_ERR)) {
|
|
|
|
if (fsr & FSR_E_ERR)
|
|
|
|
dev_err(nor->dev, "Erase operation failed.\n");
|
|
|
|
else
|
|
|
|
dev_err(nor->dev, "Program operation failed.\n");
|
|
|
|
|
|
|
|
if (fsr & FSR_PT_ERR)
|
|
|
|
dev_err(nor->dev,
|
|
|
|
"Attempted to modify a protected sector.\n");
|
|
|
|
|
|
|
|
nor->write_reg(nor, SPINOR_OP_CLFSR, NULL, 0);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return fsr & FSR_READY;
|
2014-09-10 15:26:16 +08:00
|
|
|
}
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2014-09-10 15:26:16 +08:00
|
|
|
static int spi_nor_ready(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
int sr, fsr;
|
2016-12-02 19:31:44 +08:00
|
|
|
|
|
|
|
if (nor->flags & SNOR_F_READY_XSR_RDY)
|
|
|
|
sr = s3an_sr_ready(nor);
|
|
|
|
else
|
|
|
|
sr = spi_nor_sr_ready(nor);
|
2014-09-10 15:26:16 +08:00
|
|
|
if (sr < 0)
|
|
|
|
return sr;
|
|
|
|
fsr = nor->flags & SNOR_F_USE_FSR ? spi_nor_fsr_ready(nor) : 1;
|
|
|
|
if (fsr < 0)
|
|
|
|
return fsr;
|
|
|
|
return sr && fsr;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
2014-08-07 09:17:00 +08:00
|
|
|
/*
|
|
|
|
* Service routine to read status register until ready, or timeout occurs.
|
|
|
|
* Returns non-zero if error.
|
|
|
|
*/
|
mtd: spi-nor: scale up timeout for full-chip erase
This patch fixes timeout issues seen on large NOR flash (e.g., 16MB
w25q128fw) when using ioctl(MEMERASE) with offset=0 and length=16M. The
input parameters matter because spi_nor_erase() uses a different code
path for full-chip erase, where we use the SPINOR_OP_CHIP_ERASE (0xc7)
opcode.
Fix: use a different timeout for full-chip erase than for other
commands.
While most operations can be expected to perform relatively similarly
across a variety of NOR flash types and sizes (and therefore might as
well use a similar timeout to keep things simple), full-chip erase is
unique, because the time it typically takes to complete:
(1) is much larger than most operations and
(2) scales with the size of the flash.
Let's base our timeout on the original comments stuck here -- that a 2MB
flash requires max 40s to erase.
Small survey of a few flash datasheets I have lying around:
Chip Size (MB) Max chip erase (seconds)
---- -------- ------------------------
w25q32fw 4 50
w25q64cv 8 30
w25q64fw 8 100
w25q128fw 16 200
s25fl128s 16 ~256
s25fl256s 32 ~512
From this data, it seems plenty sufficient to say we need to wait for
40 seconds for each 2MB of flash.
After this change, it might make some sense to decrease the timeout for
everything else, as even the most extreme operations (single block
erase?) shouldn't take more than a handful of seconds. But for safety,
let's leave it as-is. It's only an error case, after all, so we don't
exactly need to optimize it.
Signed-off-by: Furquan Shaikh <furquan@google.com>
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-19 05:59:17 +08:00
|
|
|
static int spi_nor_wait_till_ready_with_timeout(struct spi_nor *nor,
|
|
|
|
unsigned long timeout_jiffies)
|
2014-04-29 23:29:51 +08:00
|
|
|
{
|
|
|
|
unsigned long deadline;
|
2014-11-05 18:32:03 +08:00
|
|
|
int timeout = 0, ret;
|
2014-04-29 23:29:51 +08:00
|
|
|
|
mtd: spi-nor: scale up timeout for full-chip erase
This patch fixes timeout issues seen on large NOR flash (e.g., 16MB
w25q128fw) when using ioctl(MEMERASE) with offset=0 and length=16M. The
input parameters matter because spi_nor_erase() uses a different code
path for full-chip erase, where we use the SPINOR_OP_CHIP_ERASE (0xc7)
opcode.
Fix: use a different timeout for full-chip erase than for other
commands.
While most operations can be expected to perform relatively similarly
across a variety of NOR flash types and sizes (and therefore might as
well use a similar timeout to keep things simple), full-chip erase is
unique, because the time it typically takes to complete:
(1) is much larger than most operations and
(2) scales with the size of the flash.
Let's base our timeout on the original comments stuck here -- that a 2MB
flash requires max 40s to erase.
Small survey of a few flash datasheets I have lying around:
Chip Size (MB) Max chip erase (seconds)
---- -------- ------------------------
w25q32fw 4 50
w25q64cv 8 30
w25q64fw 8 100
w25q128fw 16 200
s25fl128s 16 ~256
s25fl256s 32 ~512
From this data, it seems plenty sufficient to say we need to wait for
40 seconds for each 2MB of flash.
After this change, it might make some sense to decrease the timeout for
everything else, as even the most extreme operations (single block
erase?) shouldn't take more than a handful of seconds. But for safety,
let's leave it as-is. It's only an error case, after all, so we don't
exactly need to optimize it.
Signed-off-by: Furquan Shaikh <furquan@google.com>
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-19 05:59:17 +08:00
|
|
|
deadline = jiffies + timeout_jiffies;
|
2014-04-29 23:29:51 +08:00
|
|
|
|
2014-11-05 18:32:03 +08:00
|
|
|
while (!timeout) {
|
|
|
|
if (time_after_eq(jiffies, deadline))
|
|
|
|
timeout = 1;
|
2014-04-29 23:29:51 +08:00
|
|
|
|
2014-09-10 15:26:16 +08:00
|
|
|
ret = spi_nor_ready(nor);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
if (ret)
|
|
|
|
return 0;
|
2014-11-05 18:32:03 +08:00
|
|
|
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_err(nor->dev, "flash operation timed out\n");
|
2014-04-29 23:29:51 +08:00
|
|
|
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
mtd: spi-nor: scale up timeout for full-chip erase
This patch fixes timeout issues seen on large NOR flash (e.g., 16MB
w25q128fw) when using ioctl(MEMERASE) with offset=0 and length=16M. The
input parameters matter because spi_nor_erase() uses a different code
path for full-chip erase, where we use the SPINOR_OP_CHIP_ERASE (0xc7)
opcode.
Fix: use a different timeout for full-chip erase than for other
commands.
While most operations can be expected to perform relatively similarly
across a variety of NOR flash types and sizes (and therefore might as
well use a similar timeout to keep things simple), full-chip erase is
unique, because the time it typically takes to complete:
(1) is much larger than most operations and
(2) scales with the size of the flash.
Let's base our timeout on the original comments stuck here -- that a 2MB
flash requires max 40s to erase.
Small survey of a few flash datasheets I have lying around:
Chip Size (MB) Max chip erase (seconds)
---- -------- ------------------------
w25q32fw 4 50
w25q64cv 8 30
w25q64fw 8 100
w25q128fw 16 200
s25fl128s 16 ~256
s25fl256s 32 ~512
From this data, it seems plenty sufficient to say we need to wait for
40 seconds for each 2MB of flash.
After this change, it might make some sense to decrease the timeout for
everything else, as even the most extreme operations (single block
erase?) shouldn't take more than a handful of seconds. But for safety,
let's leave it as-is. It's only an error case, after all, so we don't
exactly need to optimize it.
Signed-off-by: Furquan Shaikh <furquan@google.com>
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-19 05:59:17 +08:00
|
|
|
static int spi_nor_wait_till_ready(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
return spi_nor_wait_till_ready_with_timeout(nor,
|
|
|
|
DEFAULT_READY_WAIT_JIFFIES);
|
|
|
|
}
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/*
|
|
|
|
* Erase the whole flash memory
|
|
|
|
*
|
|
|
|
* Returns 0 if successful, non-zero otherwise.
|
|
|
|
*/
|
|
|
|
static int erase_chip(struct spi_nor *nor)
|
|
|
|
{
|
2015-08-14 06:46:05 +08:00
|
|
|
dev_dbg(nor->dev, " %lldKiB\n", (long long)(nor->mtd.size >> 10));
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2015-08-19 17:56:44 +08:00
|
|
|
return nor->write_reg(nor, SPINOR_OP_CHIP_ERASE, NULL, 0);
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_lock_and_prep(struct spi_nor *nor, enum spi_nor_ops ops)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mutex_lock(&nor->lock);
|
|
|
|
|
|
|
|
if (nor->prepare) {
|
|
|
|
ret = nor->prepare(nor, ops);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(nor->dev, "failed in the preparation.\n");
|
|
|
|
mutex_unlock(&nor->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spi_nor_unlock_and_unprep(struct spi_nor *nor, enum spi_nor_ops ops)
|
|
|
|
{
|
|
|
|
if (nor->unprepare)
|
|
|
|
nor->unprepare(nor, ops);
|
|
|
|
mutex_unlock(&nor->lock);
|
|
|
|
}
|
|
|
|
|
2016-12-02 19:31:44 +08:00
|
|
|
/*
|
|
|
|
* This code converts an address to the Default Address Mode, that has non
|
|
|
|
* power of two page sizes. We must support this mode because it is the default
|
|
|
|
* mode supported by Xilinx tools, it can access the whole flash area and
|
|
|
|
* changing over to the Power-of-two mode is irreversible and corrupts the
|
|
|
|
* original data.
|
|
|
|
* Addr can safely be unsigned int, the biggest S3AN device is smaller than
|
|
|
|
* 4 MiB.
|
|
|
|
*/
|
|
|
|
static loff_t spi_nor_s3an_addr_convert(struct spi_nor *nor, unsigned int addr)
|
|
|
|
{
|
2017-01-19 00:40:16 +08:00
|
|
|
unsigned int offset;
|
|
|
|
unsigned int page;
|
2016-12-02 19:31:44 +08:00
|
|
|
|
2017-01-19 00:40:16 +08:00
|
|
|
offset = addr % nor->page_size;
|
|
|
|
page = addr / nor->page_size;
|
|
|
|
page <<= (nor->page_size > 512) ? 10 : 9;
|
2016-12-02 19:31:44 +08:00
|
|
|
|
2017-01-19 00:40:16 +08:00
|
|
|
return page | offset;
|
2016-12-02 19:31:44 +08:00
|
|
|
}
|
|
|
|
|
2015-11-11 04:15:27 +08:00
|
|
|
/*
|
|
|
|
* Initiate the erasure of a single sector
|
|
|
|
*/
|
|
|
|
static int spi_nor_erase_sector(struct spi_nor *nor, u32 addr)
|
|
|
|
{
|
|
|
|
u8 buf[SPI_NOR_MAX_ADDR_WIDTH];
|
|
|
|
int i;
|
|
|
|
|
2016-12-02 19:31:44 +08:00
|
|
|
if (nor->flags & SNOR_F_S3AN_ADDR_DEFAULT)
|
|
|
|
addr = spi_nor_s3an_addr_convert(nor, addr);
|
|
|
|
|
2015-11-11 04:15:27 +08:00
|
|
|
if (nor->erase)
|
|
|
|
return nor->erase(nor, addr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Default implementation, if driver doesn't have a specialized HW
|
|
|
|
* control
|
|
|
|
*/
|
|
|
|
for (i = nor->addr_width - 1; i >= 0; i--) {
|
|
|
|
buf[i] = addr & 0xff;
|
|
|
|
addr >>= 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
return nor->write_reg(nor, nor->erase_opcode, buf, nor->addr_width);
|
|
|
|
}
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/*
|
|
|
|
* Erase an address range on the nor chip. The address range may extend
|
|
|
|
* one or more erase sectors. Return an error is there is a problem erasing.
|
|
|
|
*/
|
|
|
|
static int spi_nor_erase(struct mtd_info *mtd, struct erase_info *instr)
|
|
|
|
{
|
|
|
|
struct spi_nor *nor = mtd_to_spi_nor(mtd);
|
|
|
|
u32 addr, len;
|
|
|
|
uint32_t rem;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(nor->dev, "at 0x%llx, len %lld\n", (long long)instr->addr,
|
|
|
|
(long long)instr->len);
|
|
|
|
|
|
|
|
div_u64_rem(instr->len, mtd->erasesize, &rem);
|
|
|
|
if (rem)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
addr = instr->addr;
|
|
|
|
len = instr->len;
|
|
|
|
|
|
|
|
ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_ERASE);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* whole-chip erase? */
|
2016-12-02 19:31:44 +08:00
|
|
|
if (len == mtd->size && !(nor->flags & SNOR_F_NO_OP_CHIP_ERASE)) {
|
mtd: spi-nor: scale up timeout for full-chip erase
This patch fixes timeout issues seen on large NOR flash (e.g., 16MB
w25q128fw) when using ioctl(MEMERASE) with offset=0 and length=16M. The
input parameters matter because spi_nor_erase() uses a different code
path for full-chip erase, where we use the SPINOR_OP_CHIP_ERASE (0xc7)
opcode.
Fix: use a different timeout for full-chip erase than for other
commands.
While most operations can be expected to perform relatively similarly
across a variety of NOR flash types and sizes (and therefore might as
well use a similar timeout to keep things simple), full-chip erase is
unique, because the time it typically takes to complete:
(1) is much larger than most operations and
(2) scales with the size of the flash.
Let's base our timeout on the original comments stuck here -- that a 2MB
flash requires max 40s to erase.
Small survey of a few flash datasheets I have lying around:
Chip Size (MB) Max chip erase (seconds)
---- -------- ------------------------
w25q32fw 4 50
w25q64cv 8 30
w25q64fw 8 100
w25q128fw 16 200
s25fl128s 16 ~256
s25fl256s 32 ~512
From this data, it seems plenty sufficient to say we need to wait for
40 seconds for each 2MB of flash.
After this change, it might make some sense to decrease the timeout for
everything else, as even the most extreme operations (single block
erase?) shouldn't take more than a handful of seconds. But for safety,
let's leave it as-is. It's only an error case, after all, so we don't
exactly need to optimize it.
Signed-off-by: Furquan Shaikh <furquan@google.com>
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-19 05:59:17 +08:00
|
|
|
unsigned long timeout;
|
|
|
|
|
2014-11-05 18:29:03 +08:00
|
|
|
write_enable(nor);
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
if (erase_chip(nor)) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto erase_err;
|
|
|
|
}
|
|
|
|
|
mtd: spi-nor: scale up timeout for full-chip erase
This patch fixes timeout issues seen on large NOR flash (e.g., 16MB
w25q128fw) when using ioctl(MEMERASE) with offset=0 and length=16M. The
input parameters matter because spi_nor_erase() uses a different code
path for full-chip erase, where we use the SPINOR_OP_CHIP_ERASE (0xc7)
opcode.
Fix: use a different timeout for full-chip erase than for other
commands.
While most operations can be expected to perform relatively similarly
across a variety of NOR flash types and sizes (and therefore might as
well use a similar timeout to keep things simple), full-chip erase is
unique, because the time it typically takes to complete:
(1) is much larger than most operations and
(2) scales with the size of the flash.
Let's base our timeout on the original comments stuck here -- that a 2MB
flash requires max 40s to erase.
Small survey of a few flash datasheets I have lying around:
Chip Size (MB) Max chip erase (seconds)
---- -------- ------------------------
w25q32fw 4 50
w25q64cv 8 30
w25q64fw 8 100
w25q128fw 16 200
s25fl128s 16 ~256
s25fl256s 32 ~512
From this data, it seems plenty sufficient to say we need to wait for
40 seconds for each 2MB of flash.
After this change, it might make some sense to decrease the timeout for
everything else, as even the most extreme operations (single block
erase?) shouldn't take more than a handful of seconds. But for safety,
let's leave it as-is. It's only an error case, after all, so we don't
exactly need to optimize it.
Signed-off-by: Furquan Shaikh <furquan@google.com>
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-19 05:59:17 +08:00
|
|
|
/*
|
|
|
|
* Scale the timeout linearly with the size of the flash, with
|
|
|
|
* a minimum calibrated to an old 2MB flash. We could try to
|
|
|
|
* pull these from CFI/SFDP, but these values should be good
|
|
|
|
* enough for now.
|
|
|
|
*/
|
|
|
|
timeout = max(CHIP_ERASE_2MB_READY_WAIT_JIFFIES,
|
|
|
|
CHIP_ERASE_2MB_READY_WAIT_JIFFIES *
|
|
|
|
(unsigned long)(mtd->size / SZ_2M));
|
|
|
|
ret = spi_nor_wait_till_ready_with_timeout(nor, timeout);
|
2014-08-07 09:16:57 +08:00
|
|
|
if (ret)
|
|
|
|
goto erase_err;
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/* REVISIT in some cases we could speed up erasing large regions
|
2014-04-09 09:15:31 +08:00
|
|
|
* by using SPINOR_OP_SE instead of SPINOR_OP_BE_4K. We may have set up
|
2014-02-24 18:37:37 +08:00
|
|
|
* to use "small sector erase", but that's not always optimal.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* "sector"-at-a-time erase */
|
|
|
|
} else {
|
|
|
|
while (len) {
|
2014-11-05 18:29:03 +08:00
|
|
|
write_enable(nor);
|
|
|
|
|
2015-11-11 04:15:27 +08:00
|
|
|
ret = spi_nor_erase_sector(nor, addr);
|
|
|
|
if (ret)
|
2014-02-24 18:37:37 +08:00
|
|
|
goto erase_err;
|
|
|
|
|
|
|
|
addr += mtd->erasesize;
|
|
|
|
len -= mtd->erasesize;
|
2014-08-07 09:16:57 +08:00
|
|
|
|
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
|
|
|
if (ret)
|
|
|
|
goto erase_err;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-05 18:29:03 +08:00
|
|
|
write_disable(nor);
|
|
|
|
|
2015-11-18 03:18:54 +08:00
|
|
|
erase_err:
|
2014-02-24 18:37:37 +08:00
|
|
|
spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-12-06 02:13:44 +08:00
|
|
|
/* Write status register and ensure bits in mask match written values */
|
|
|
|
static int write_sr_and_check(struct spi_nor *nor, u8 status_new, u8 mask)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
write_enable(nor);
|
|
|
|
ret = write_sr(nor, status_new);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = read_sr(nor);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return ((ret & mask) != (status_new & mask)) ? -EIO : 0;
|
|
|
|
}
|
|
|
|
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
static void stm_get_locked_range(struct spi_nor *nor, u8 sr, loff_t *ofs,
|
|
|
|
uint64_t *len)
|
|
|
|
{
|
|
|
|
struct mtd_info *mtd = &nor->mtd;
|
|
|
|
u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
|
|
|
|
int shift = ffs(mask) - 1;
|
|
|
|
int pow;
|
|
|
|
|
|
|
|
if (!(sr & mask)) {
|
|
|
|
/* No protection */
|
|
|
|
*ofs = 0;
|
|
|
|
*len = 0;
|
|
|
|
} else {
|
|
|
|
pow = ((sr & mask) ^ mask) >> shift;
|
|
|
|
*len = mtd->size >> pow;
|
2016-01-30 03:25:36 +08:00
|
|
|
if (nor->flags & SNOR_F_HAS_SR_TB && sr & SR_TB)
|
|
|
|
*ofs = 0;
|
|
|
|
else
|
|
|
|
*ofs = mtd->size - *len;
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-01-30 03:25:32 +08:00
|
|
|
* Return 1 if the entire region is locked (if @locked is true) or unlocked (if
|
|
|
|
* @locked is false); 0 otherwise
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
*/
|
2016-01-30 03:25:32 +08:00
|
|
|
static int stm_check_lock_status_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
|
|
|
|
u8 sr, bool locked)
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
{
|
|
|
|
loff_t lock_offs;
|
|
|
|
uint64_t lock_len;
|
|
|
|
|
2016-01-30 03:25:32 +08:00
|
|
|
if (!len)
|
|
|
|
return 1;
|
|
|
|
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
stm_get_locked_range(nor, sr, &lock_offs, &lock_len);
|
|
|
|
|
2016-01-30 03:25:32 +08:00
|
|
|
if (locked)
|
|
|
|
/* Requested range is a sub-range of locked range */
|
|
|
|
return (ofs + len <= lock_offs + lock_len) && (ofs >= lock_offs);
|
|
|
|
else
|
|
|
|
/* Requested range does not overlap with locked range */
|
|
|
|
return (ofs >= lock_offs + lock_len) || (ofs + len <= lock_offs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stm_is_locked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
|
|
|
|
u8 sr)
|
|
|
|
{
|
|
|
|
return stm_check_lock_status_sr(nor, ofs, len, sr, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stm_is_unlocked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
|
|
|
|
u8 sr)
|
|
|
|
{
|
|
|
|
return stm_check_lock_status_sr(nor, ofs, len, sr, false);
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock a region of the flash. Compatible with ST Micro and similar flash.
|
2016-01-30 03:25:36 +08:00
|
|
|
* Supports the block protection bits BP{0,1,2} in the status register
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
* (SR). Does not support these features found in newer SR bitfields:
|
|
|
|
* - SEC: sector/block protect - only handle SEC=0 (block protect)
|
|
|
|
* - CMP: complement protect - only support CMP=0 (range is not complemented)
|
|
|
|
*
|
2016-01-30 03:25:36 +08:00
|
|
|
* Support for the following is provided conditionally for some flash:
|
|
|
|
* - TB: top/bottom protect
|
|
|
|
*
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
* Sample table portion for 8MB flash (Winbond w25q64fw):
|
|
|
|
*
|
|
|
|
* SEC | TB | BP2 | BP1 | BP0 | Prot Length | Protected Portion
|
|
|
|
* --------------------------------------------------------------------------
|
|
|
|
* X | X | 0 | 0 | 0 | NONE | NONE
|
|
|
|
* 0 | 0 | 0 | 0 | 1 | 128 KB | Upper 1/64
|
|
|
|
* 0 | 0 | 0 | 1 | 0 | 256 KB | Upper 1/32
|
|
|
|
* 0 | 0 | 0 | 1 | 1 | 512 KB | Upper 1/16
|
|
|
|
* 0 | 0 | 1 | 0 | 0 | 1 MB | Upper 1/8
|
|
|
|
* 0 | 0 | 1 | 0 | 1 | 2 MB | Upper 1/4
|
|
|
|
* 0 | 0 | 1 | 1 | 0 | 4 MB | Upper 1/2
|
|
|
|
* X | X | 1 | 1 | 1 | 8 MB | ALL
|
2016-01-30 03:25:36 +08:00
|
|
|
* ------|-------|-------|-------|-------|---------------|-------------------
|
|
|
|
* 0 | 1 | 0 | 0 | 1 | 128 KB | Lower 1/64
|
|
|
|
* 0 | 1 | 0 | 1 | 0 | 256 KB | Lower 1/32
|
|
|
|
* 0 | 1 | 0 | 1 | 1 | 512 KB | Lower 1/16
|
|
|
|
* 0 | 1 | 1 | 0 | 0 | 1 MB | Lower 1/8
|
|
|
|
* 0 | 1 | 1 | 0 | 1 | 2 MB | Lower 1/4
|
|
|
|
* 0 | 1 | 1 | 1 | 0 | 4 MB | Lower 1/2
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
*
|
|
|
|
* Returns negative on errors, 0 on success.
|
|
|
|
*/
|
2015-03-13 15:38:39 +08:00
|
|
|
static int stm_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
|
2014-02-24 18:37:37 +08:00
|
|
|
{
|
2015-08-14 06:46:05 +08:00
|
|
|
struct mtd_info *mtd = &nor->mtd;
|
2015-11-21 02:26:11 +08:00
|
|
|
int status_old, status_new;
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
|
|
|
|
u8 shift = ffs(mask) - 1, pow, val;
|
2016-01-30 03:25:32 +08:00
|
|
|
loff_t lock_len;
|
2016-01-30 03:25:36 +08:00
|
|
|
bool can_be_top = true, can_be_bottom = nor->flags & SNOR_F_HAS_SR_TB;
|
|
|
|
bool use_top;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
status_old = read_sr(nor);
|
2015-11-21 02:26:11 +08:00
|
|
|
if (status_old < 0)
|
|
|
|
return status_old;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2016-01-30 03:25:32 +08:00
|
|
|
/* If nothing in our range is unlocked, we don't need to do anything */
|
|
|
|
if (stm_is_locked_sr(nor, ofs, len, status_old))
|
|
|
|
return 0;
|
|
|
|
|
2016-01-30 03:25:36 +08:00
|
|
|
/* If anything below us is unlocked, we can't use 'bottom' protection */
|
|
|
|
if (!stm_is_locked_sr(nor, 0, ofs, status_old))
|
|
|
|
can_be_bottom = false;
|
|
|
|
|
2016-01-30 03:25:32 +08:00
|
|
|
/* If anything above us is unlocked, we can't use 'top' protection */
|
|
|
|
if (!stm_is_locked_sr(nor, ofs + len, mtd->size - (ofs + len),
|
|
|
|
status_old))
|
2016-01-30 03:25:36 +08:00
|
|
|
can_be_top = false;
|
|
|
|
|
|
|
|
if (!can_be_bottom && !can_be_top)
|
2016-01-30 03:25:32 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-01-30 03:25:36 +08:00
|
|
|
/* Prefer top, if both are valid */
|
|
|
|
use_top = can_be_top;
|
|
|
|
|
2016-01-30 03:25:32 +08:00
|
|
|
/* lock_len: length of region that should end up locked */
|
2016-01-30 03:25:36 +08:00
|
|
|
if (use_top)
|
|
|
|
lock_len = mtd->size - ofs;
|
|
|
|
else
|
|
|
|
lock_len = ofs + len;
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Need smallest pow such that:
|
|
|
|
*
|
|
|
|
* 1 / (2^pow) <= (len / size)
|
|
|
|
*
|
|
|
|
* so (assuming power-of-2 size) we do:
|
|
|
|
*
|
|
|
|
* pow = ceil(log2(size / len)) = log2(size) - floor(log2(len))
|
|
|
|
*/
|
2016-01-30 03:25:32 +08:00
|
|
|
pow = ilog2(mtd->size) - ilog2(lock_len);
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
val = mask - (pow << shift);
|
|
|
|
if (val & ~mask)
|
|
|
|
return -EINVAL;
|
|
|
|
/* Don't "lock" with no region! */
|
|
|
|
if (!(val & mask))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-01-30 03:25:36 +08:00
|
|
|
status_new = (status_old & ~mask & ~SR_TB) | val;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2016-01-30 03:25:33 +08:00
|
|
|
/* Disallow further writes if WP pin is asserted */
|
|
|
|
status_new |= SR_SRWD;
|
|
|
|
|
2016-01-30 03:25:36 +08:00
|
|
|
if (!use_top)
|
|
|
|
status_new |= SR_TB;
|
|
|
|
|
2016-01-30 03:25:31 +08:00
|
|
|
/* Don't bother if they're the same */
|
|
|
|
if (status_new == status_old)
|
|
|
|
return 0;
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/* Only modify protection if it will not unlock other areas */
|
2016-01-30 03:25:31 +08:00
|
|
|
if ((status_new & mask) < (status_old & mask))
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
return -EINVAL;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2017-12-06 02:13:44 +08:00
|
|
|
return write_sr_and_check(nor, status_new, mask);
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
/*
|
|
|
|
* Unlock a region of the flash. See stm_lock() for more info
|
|
|
|
*
|
|
|
|
* Returns negative on errors, 0 on success.
|
|
|
|
*/
|
2015-03-13 15:38:39 +08:00
|
|
|
static int stm_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len)
|
2014-02-24 18:37:37 +08:00
|
|
|
{
|
2015-08-14 06:46:05 +08:00
|
|
|
struct mtd_info *mtd = &nor->mtd;
|
2015-11-21 02:26:11 +08:00
|
|
|
int status_old, status_new;
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
|
|
|
|
u8 shift = ffs(mask) - 1, pow, val;
|
2016-01-30 03:25:32 +08:00
|
|
|
loff_t lock_len;
|
2016-01-30 03:25:36 +08:00
|
|
|
bool can_be_top = true, can_be_bottom = nor->flags & SNOR_F_HAS_SR_TB;
|
|
|
|
bool use_top;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
status_old = read_sr(nor);
|
2015-11-21 02:26:11 +08:00
|
|
|
if (status_old < 0)
|
|
|
|
return status_old;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2016-01-30 03:25:32 +08:00
|
|
|
/* If nothing in our range is locked, we don't need to do anything */
|
|
|
|
if (stm_is_unlocked_sr(nor, ofs, len, status_old))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* If anything below us is locked, we can't use 'top' protection */
|
|
|
|
if (!stm_is_unlocked_sr(nor, 0, ofs, status_old))
|
2016-01-30 03:25:36 +08:00
|
|
|
can_be_top = false;
|
|
|
|
|
|
|
|
/* If anything above us is locked, we can't use 'bottom' protection */
|
|
|
|
if (!stm_is_unlocked_sr(nor, ofs + len, mtd->size - (ofs + len),
|
|
|
|
status_old))
|
|
|
|
can_be_bottom = false;
|
|
|
|
|
|
|
|
if (!can_be_bottom && !can_be_top)
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
return -EINVAL;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2016-01-30 03:25:36 +08:00
|
|
|
/* Prefer top, if both are valid */
|
|
|
|
use_top = can_be_top;
|
|
|
|
|
2016-01-30 03:25:32 +08:00
|
|
|
/* lock_len: length of region that should remain locked */
|
2016-01-30 03:25:36 +08:00
|
|
|
if (use_top)
|
|
|
|
lock_len = mtd->size - (ofs + len);
|
|
|
|
else
|
|
|
|
lock_len = ofs;
|
2016-01-30 03:25:32 +08:00
|
|
|
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
/*
|
|
|
|
* Need largest pow such that:
|
|
|
|
*
|
|
|
|
* 1 / (2^pow) >= (len / size)
|
|
|
|
*
|
|
|
|
* so (assuming power-of-2 size) we do:
|
|
|
|
*
|
|
|
|
* pow = floor(log2(size / len)) = log2(size) - ceil(log2(len))
|
|
|
|
*/
|
2016-01-30 03:25:32 +08:00
|
|
|
pow = ilog2(mtd->size) - order_base_2(lock_len);
|
|
|
|
if (lock_len == 0) {
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
val = 0; /* fully unlocked */
|
|
|
|
} else {
|
|
|
|
val = mask - (pow << shift);
|
|
|
|
/* Some power-of-two sizes are not supported */
|
|
|
|
if (val & ~mask)
|
|
|
|
return -EINVAL;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
2016-01-30 03:25:36 +08:00
|
|
|
status_new = (status_old & ~mask & ~SR_TB) | val;
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
|
2016-01-30 03:25:33 +08:00
|
|
|
/* Don't protect status register if we're fully unlocked */
|
2016-06-25 01:38:14 +08:00
|
|
|
if (lock_len == 0)
|
2016-01-30 03:25:33 +08:00
|
|
|
status_new &= ~SR_SRWD;
|
|
|
|
|
2016-01-30 03:25:36 +08:00
|
|
|
if (!use_top)
|
|
|
|
status_new |= SR_TB;
|
|
|
|
|
2016-01-30 03:25:31 +08:00
|
|
|
/* Don't bother if they're the same */
|
|
|
|
if (status_new == status_old)
|
|
|
|
return 0;
|
|
|
|
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
/* Only modify protection if it will not lock other areas */
|
2016-01-30 03:25:31 +08:00
|
|
|
if ((status_new & mask) > (status_old & mask))
|
mtd: spi-nor: refactor block protection functions
This code was a bit sloppy, would produce a lot of copy-and-paste, and
did not always provide a sensible interface:
* It didn't validate the length for LOCK and the offset for UNLOCK, so
we were essentially discarding half of the user-supplied data and
assuming what they wanted to lock/unlock
* It didn't do very good error checking
* It didn't make use of the fact that this operation works on
power-of-two dimensions
So, rewrite this to do proper bit arithmetic rather than a bunch of
hard-coded condition tables. Now we have:
* More comments on how this was derived
* Notes on what is (and isn't) supported
* A more exendible function, so we could add support for other
protection ranges
* More accurate locking - e.g., suppose the top quadrant is locked (75%
to 100%); then in the following cases, case (a) will succeed but (b)
will not (return -EINVAL):
(a) user requests lock 3rd quadrant (50% to 75%)
(b) user requests lock 3rd quadrant, minus a few blocks (e.g., 50%
to 73%)
Case (b) *should* fail, since we'd have to lock blocks that weren't
requested. But the old implementation didn't know the difference and
would lock the entire second half (50% to 100%)
This refactoring work will also help enable the addition of
mtd_is_locked() support and potentially the support of bottom boot
protection (TB=1).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-09-02 03:57:11 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-12-06 02:13:44 +08:00
|
|
|
return write_sr_and_check(nor, status_new, mask);
|
2015-03-13 15:38:39 +08:00
|
|
|
}
|
|
|
|
|
2015-09-02 03:57:12 +08:00
|
|
|
/*
|
|
|
|
* Check if a region of the flash is (completely) locked. See stm_lock() for
|
|
|
|
* more info.
|
|
|
|
*
|
|
|
|
* Returns 1 if entire region is locked, 0 if any portion is unlocked, and
|
|
|
|
* negative on errors.
|
|
|
|
*/
|
|
|
|
static int stm_is_locked(struct spi_nor *nor, loff_t ofs, uint64_t len)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = read_sr(nor);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
return stm_is_locked_sr(nor, ofs, len, status);
|
|
|
|
}
|
|
|
|
|
2015-03-13 15:38:39 +08:00
|
|
|
static int spi_nor_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
|
|
|
|
{
|
|
|
|
struct spi_nor *nor = mtd_to_spi_nor(mtd);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_LOCK);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = nor->flash_lock(nor, ofs, len);
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_UNLOCK);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-03-13 15:38:39 +08:00
|
|
|
static int spi_nor_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
|
|
|
|
{
|
|
|
|
struct spi_nor *nor = mtd_to_spi_nor(mtd);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_UNLOCK);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = nor->flash_unlock(nor, ofs, len);
|
|
|
|
|
|
|
|
spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_LOCK);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-09-02 03:57:12 +08:00
|
|
|
static int spi_nor_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
|
|
|
|
{
|
|
|
|
struct spi_nor *nor = mtd_to_spi_nor(mtd);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_UNLOCK);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = nor->flash_is_locked(nor, ofs, len);
|
|
|
|
|
|
|
|
spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_LOCK);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-08-28 10:00:46 +08:00
|
|
|
static int macronix_quad_enable(struct spi_nor *nor);
|
|
|
|
|
2014-11-06 14:34:01 +08:00
|
|
|
/* Used when the "_ext_id" is two bytes at most */
|
2014-02-24 18:37:37 +08:00
|
|
|
#define INFO(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags) \
|
2014-11-06 14:34:01 +08:00
|
|
|
.id = { \
|
|
|
|
((_jedec_id) >> 16) & 0xff, \
|
|
|
|
((_jedec_id) >> 8) & 0xff, \
|
|
|
|
(_jedec_id) & 0xff, \
|
|
|
|
((_ext_id) >> 8) & 0xff, \
|
|
|
|
(_ext_id) & 0xff, \
|
|
|
|
}, \
|
|
|
|
.id_len = (!(_jedec_id) ? 0 : (3 + ((_ext_id) ? 2 : 0))), \
|
2014-02-24 18:37:37 +08:00
|
|
|
.sector_size = (_sector_size), \
|
|
|
|
.n_sectors = (_n_sectors), \
|
|
|
|
.page_size = 256, \
|
2015-08-11 03:39:03 +08:00
|
|
|
.flags = (_flags),
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2014-08-12 08:54:56 +08:00
|
|
|
#define INFO6(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags) \
|
|
|
|
.id = { \
|
|
|
|
((_jedec_id) >> 16) & 0xff, \
|
|
|
|
((_jedec_id) >> 8) & 0xff, \
|
|
|
|
(_jedec_id) & 0xff, \
|
|
|
|
((_ext_id) >> 16) & 0xff, \
|
|
|
|
((_ext_id) >> 8) & 0xff, \
|
|
|
|
(_ext_id) & 0xff, \
|
|
|
|
}, \
|
|
|
|
.id_len = 6, \
|
|
|
|
.sector_size = (_sector_size), \
|
|
|
|
.n_sectors = (_n_sectors), \
|
|
|
|
.page_size = 256, \
|
2015-08-11 03:39:03 +08:00
|
|
|
.flags = (_flags),
|
2014-08-12 08:54:56 +08:00
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
#define CAT25_INFO(_sector_size, _n_sectors, _page_size, _addr_width, _flags) \
|
|
|
|
.sector_size = (_sector_size), \
|
|
|
|
.n_sectors = (_n_sectors), \
|
|
|
|
.page_size = (_page_size), \
|
|
|
|
.addr_width = (_addr_width), \
|
2015-08-11 03:39:03 +08:00
|
|
|
.flags = (_flags),
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2016-12-02 19:31:44 +08:00
|
|
|
#define S3AN_INFO(_jedec_id, _n_sectors, _page_size) \
|
|
|
|
.id = { \
|
|
|
|
((_jedec_id) >> 16) & 0xff, \
|
|
|
|
((_jedec_id) >> 8) & 0xff, \
|
|
|
|
(_jedec_id) & 0xff \
|
|
|
|
}, \
|
|
|
|
.id_len = 3, \
|
|
|
|
.sector_size = (8*_page_size), \
|
|
|
|
.n_sectors = (_n_sectors), \
|
|
|
|
.page_size = _page_size, \
|
|
|
|
.addr_width = 3, \
|
|
|
|
.flags = SPI_NOR_NO_FR | SPI_S3AN,
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/* NOTE: double check command sets and memory organization when you add
|
|
|
|
* more nor chips. This current list focusses on newer chips, which
|
|
|
|
* have been converging on command sets which including JEDEC ID.
|
2015-04-25 18:41:30 +08:00
|
|
|
*
|
|
|
|
* All newly added entries should describe *hardware* and should use SECT_4K
|
|
|
|
* (or SECT_4K_PMC) if hardware supports erasing 4 KiB sectors. For usage
|
|
|
|
* scenarios excluding small sectors there is config option that can be
|
|
|
|
* disabled: CONFIG_MTD_SPI_NOR_USE_4K_SECTORS.
|
|
|
|
* For historical (and compatibility) reasons (before we got above config) some
|
|
|
|
* old entries may be missing 4K flag.
|
2014-02-24 18:37:37 +08:00
|
|
|
*/
|
2015-08-11 03:39:03 +08:00
|
|
|
static const struct flash_info spi_nor_ids[] = {
|
2014-02-24 18:37:37 +08:00
|
|
|
/* Atmel -- some are (confusingly) marketed as "DataFlash" */
|
|
|
|
{ "at25fs010", INFO(0x1f6601, 0, 32 * 1024, 4, SECT_4K) },
|
|
|
|
{ "at25fs040", INFO(0x1f6604, 0, 64 * 1024, 8, SECT_4K) },
|
|
|
|
|
|
|
|
{ "at25df041a", INFO(0x1f4401, 0, 64 * 1024, 8, SECT_4K) },
|
2016-07-26 16:37:54 +08:00
|
|
|
{ "at25df321", INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "at25df321a", INFO(0x1f4701, 0, 64 * 1024, 64, SECT_4K) },
|
|
|
|
{ "at25df641", INFO(0x1f4800, 0, 64 * 1024, 128, SECT_4K) },
|
|
|
|
|
|
|
|
{ "at26f004", INFO(0x1f0400, 0, 64 * 1024, 8, SECT_4K) },
|
|
|
|
{ "at26df081a", INFO(0x1f4501, 0, 64 * 1024, 16, SECT_4K) },
|
|
|
|
{ "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32, SECT_4K) },
|
|
|
|
{ "at26df321", INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K) },
|
|
|
|
|
|
|
|
{ "at45db081d", INFO(0x1f2500, 0, 64 * 1024, 16, SECT_4K) },
|
|
|
|
|
|
|
|
/* EON -- en25xxx */
|
|
|
|
{ "en25f32", INFO(0x1c3116, 0, 64 * 1024, 64, SECT_4K) },
|
|
|
|
{ "en25p32", INFO(0x1c2016, 0, 64 * 1024, 64, 0) },
|
|
|
|
{ "en25q32b", INFO(0x1c3016, 0, 64 * 1024, 64, 0) },
|
|
|
|
{ "en25p64", INFO(0x1c2017, 0, 64 * 1024, 128, 0) },
|
|
|
|
{ "en25q64", INFO(0x1c3017, 0, 64 * 1024, 128, SECT_4K) },
|
2018-05-17 10:40:27 +08:00
|
|
|
{ "en25qh32", INFO(0x1c7016, 0, 64 * 1024, 64, 0) },
|
2014-06-12 22:16:46 +08:00
|
|
|
{ "en25qh128", INFO(0x1c7018, 0, 64 * 1024, 256, 0) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "en25qh256", INFO(0x1c7019, 0, 64 * 1024, 512, 0) },
|
2015-04-25 18:41:30 +08:00
|
|
|
{ "en25s64", INFO(0x1c3817, 0, 64 * 1024, 128, SECT_4K) },
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* ESMT */
|
2017-01-03 09:34:30 +08:00
|
|
|
{ "f25l32pa", INFO(0x8c2016, 0, 64 * 1024, 64, SECT_4K | SPI_NOR_HAS_LOCK) },
|
2017-02-15 06:27:13 +08:00
|
|
|
{ "f25l32qa", INFO(0x8c4116, 0, 64 * 1024, 64, SECT_4K | SPI_NOR_HAS_LOCK) },
|
|
|
|
{ "f25l64qa", INFO(0x8c4117, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_HAS_LOCK) },
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* Everspin */
|
2017-10-19 16:12:47 +08:00
|
|
|
{ "mr25h128", CAT25_INFO( 16 * 1024, 1, 256, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "mr25h256", CAT25_INFO( 32 * 1024, 1, 256, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
|
|
|
|
{ "mr25h10", CAT25_INFO(128 * 1024, 1, 256, 3, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
|
2016-10-05 16:22:52 +08:00
|
|
|
{ "mr25h40", CAT25_INFO(512 * 1024, 1, 256, 3, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2014-10-29 17:10:47 +08:00
|
|
|
/* Fujitsu */
|
|
|
|
{ "mb85rs1mt", INFO(0x047f27, 0, 128 * 1024, 1, SPI_NOR_NO_ERASE) },
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/* GigaDevice */
|
2017-01-21 03:25:51 +08:00
|
|
|
{
|
|
|
|
"gd25q16", INFO(0xc84015, 0, 64 * 1024, 32,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
mtd: spi-nor: support dual, quad, and WP for Gigadevice
Gigadevice flash support BP{0,1,2,3,4} bits, where BP3 means the same as
the existing supported TB (Top/Bottom), and BP4 means the same as the
not-yet-supported 4K bit used on other flash (e.g., Winbond). Let's
support lock/unlock with the same feature flags as w25q32dw/w25q64dw.
Tested on gd25lq64c, but I checked datasheets for the other 3, to make
sure.
While I was at it, I noticed that these all support dual and quad as
well. I noted them, but can't test them at the moment, since my test
system only supports standard 1x SPI.
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2016-07-02 06:16:22 +08:00
|
|
|
{
|
|
|
|
"gd25q32", INFO(0xc84016, 0, 64 * 1024, 64,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
2017-09-13 16:25:35 +08:00
|
|
|
{
|
|
|
|
"gd25lq32", INFO(0xc86016, 0, 64 * 1024, 64,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
mtd: spi-nor: support dual, quad, and WP for Gigadevice
Gigadevice flash support BP{0,1,2,3,4} bits, where BP3 means the same as
the existing supported TB (Top/Bottom), and BP4 means the same as the
not-yet-supported 4K bit used on other flash (e.g., Winbond). Let's
support lock/unlock with the same feature flags as w25q32dw/w25q64dw.
Tested on gd25lq64c, but I checked datasheets for the other 3, to make
sure.
While I was at it, I noticed that these all support dual and quad as
well. I noted them, but can't test them at the moment, since my test
system only supports standard 1x SPI.
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2016-07-02 06:16:22 +08:00
|
|
|
{
|
|
|
|
"gd25q64", INFO(0xc84017, 0, 64 * 1024, 128,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"gd25lq64c", INFO(0xc86017, 0, 64 * 1024, 128,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"gd25q128", INFO(0xc84018, 0, 64 * 1024, 256,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
2017-08-28 10:00:46 +08:00
|
|
|
{
|
|
|
|
"gd25q256", INFO(0xc84019, 0, 64 * 1024, 512,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_4B_OPCODES | SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
.quad_enable = macronix_quad_enable,
|
|
|
|
},
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* Intel/Numonyx -- xxxs33b */
|
|
|
|
{ "160s33b", INFO(0x898911, 0, 64 * 1024, 32, 0) },
|
|
|
|
{ "320s33b", INFO(0x898912, 0, 64 * 1024, 64, 0) },
|
|
|
|
{ "640s33b", INFO(0x898913, 0, 64 * 1024, 128, 0) },
|
|
|
|
|
2015-04-08 01:35:02 +08:00
|
|
|
/* ISSI */
|
2017-12-15 15:33:32 +08:00
|
|
|
{ "is25cd512", INFO(0x7f9d20, 0, 32 * 1024, 2, SECT_4K) },
|
|
|
|
{ "is25lq040b", INFO(0x9d4013, 0, 64 * 1024, 8,
|
2017-12-15 15:33:31 +08:00
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2017-12-28 18:03:24 +08:00
|
|
|
{ "is25lp080d", INFO(0x9d6014, 0, 64 * 1024, 16,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2017-12-15 15:33:32 +08:00
|
|
|
{ "is25lp128", INFO(0x9d6018, 0, 64 * 1024, 256,
|
2017-11-19 07:48:23 +08:00
|
|
|
SECT_4K | SPI_NOR_DUAL_READ) },
|
2018-04-07 21:01:05 +08:00
|
|
|
{ "is25lp256", INFO(0x9d6019, 0, 64 * 1024, 512,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ) },
|
2018-05-14 18:15:53 +08:00
|
|
|
{ "is25wp032", INFO(0x9d7016, 0, 64 * 1024, 64,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
|
|
|
{ "is25wp064", INFO(0x9d7017, 0, 64 * 1024, 128,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
|
|
|
{ "is25wp128", INFO(0x9d7018, 0, 64 * 1024, 256,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2015-04-08 01:35:02 +08:00
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/* Macronix */
|
2015-04-08 01:35:01 +08:00
|
|
|
{ "mx25l512e", INFO(0xc22010, 0, 64 * 1024, 1, SECT_4K) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "mx25l2005a", INFO(0xc22012, 0, 64 * 1024, 4, SECT_4K) },
|
|
|
|
{ "mx25l4005a", INFO(0xc22013, 0, 64 * 1024, 8, SECT_4K) },
|
|
|
|
{ "mx25l8005", INFO(0xc22014, 0, 64 * 1024, 16, 0) },
|
|
|
|
{ "mx25l1606e", INFO(0xc22015, 0, 64 * 1024, 32, SECT_4K) },
|
2015-11-05 17:04:23 +08:00
|
|
|
{ "mx25l3205d", INFO(0xc22016, 0, 64 * 1024, 64, SECT_4K) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "mx25l3255e", INFO(0xc29e16, 0, 64 * 1024, 64, SECT_4K) },
|
2015-11-05 17:04:23 +08:00
|
|
|
{ "mx25l6405d", INFO(0xc22017, 0, 64 * 1024, 128, SECT_4K) },
|
2017-03-12 03:01:05 +08:00
|
|
|
{ "mx25u2033e", INFO(0xc22532, 0, 64 * 1024, 4, SECT_4K) },
|
|
|
|
{ "mx25u4035", INFO(0xc22533, 0, 64 * 1024, 8, SECT_4K) },
|
|
|
|
{ "mx25u8035", INFO(0xc22534, 0, 64 * 1024, 16, SECT_4K) },
|
2015-02-06 00:39:03 +08:00
|
|
|
{ "mx25u6435f", INFO(0xc22537, 0, 64 * 1024, 128, SECT_4K) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "mx25l12805d", INFO(0xc22018, 0, 64 * 1024, 256, 0) },
|
|
|
|
{ "mx25l12855e", INFO(0xc22618, 0, 64 * 1024, 256, 0) },
|
2017-04-19 22:00:20 +08:00
|
|
|
{ "mx25l25635e", INFO(0xc22019, 0, 64 * 1024, 512, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2017-04-13 15:23:54 +08:00
|
|
|
{ "mx25u25635f", INFO(0xc22539, 0, 64 * 1024, 512, SECT_4K | SPI_NOR_4B_OPCODES) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "mx25l25655e", INFO(0xc22619, 0, 64 * 1024, 512, 0) },
|
2017-09-18 05:54:16 +08:00
|
|
|
{ "mx66l51235l", INFO(0xc2201a, 0, 64 * 1024, 1024, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
|
2017-06-22 19:20:36 +08:00
|
|
|
{ "mx66u51235f", INFO(0xc2253a, 0, 64 * 1024, 1024, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
|
2017-04-19 22:00:19 +08:00
|
|
|
{ "mx66l1g45g", INFO(0xc2201b, 0, 64 * 1024, 2048, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "mx66l1g55g", INFO(0xc2261b, 0, 64 * 1024, 2048, SPI_NOR_QUAD_READ) },
|
|
|
|
|
|
|
|
/* Micron */
|
2016-07-16 01:03:48 +08:00
|
|
|
{ "n25q016a", INFO(0x20bb15, 0, 64 * 1024, 32, SECT_4K | SPI_NOR_QUAD_READ) },
|
2014-12-17 15:35:45 +08:00
|
|
|
{ "n25q032", INFO(0x20ba16, 0, 64 * 1024, 64, SPI_NOR_QUAD_READ) },
|
2015-10-08 03:10:08 +08:00
|
|
|
{ "n25q032a", INFO(0x20bb16, 0, 64 * 1024, 64, SPI_NOR_QUAD_READ) },
|
2015-06-30 17:53:46 +08:00
|
|
|
{ "n25q064", INFO(0x20ba17, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_QUAD_READ) },
|
2015-08-27 17:52:19 +08:00
|
|
|
{ "n25q064a", INFO(0x20bb17, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_QUAD_READ) },
|
2016-02-29 03:09:18 +08:00
|
|
|
{ "n25q128a11", INFO(0x20bb18, 0, 64 * 1024, 256, SECT_4K | SPI_NOR_QUAD_READ) },
|
|
|
|
{ "n25q128a13", INFO(0x20ba18, 0, 64 * 1024, 256, SECT_4K | SPI_NOR_QUAD_READ) },
|
2017-04-19 22:00:20 +08:00
|
|
|
{ "n25q256a", INFO(0x20ba19, 0, 64 * 1024, 512, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2017-03-23 07:04:14 +08:00
|
|
|
{ "n25q256ax1", INFO(0x20bb19, 0, 64 * 1024, 512, SECT_4K | SPI_NOR_QUAD_READ) },
|
2014-12-17 15:35:45 +08:00
|
|
|
{ "n25q512a", INFO(0x20bb20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
|
|
|
|
{ "n25q512ax3", INFO(0x20ba20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
|
2017-01-07 01:19:01 +08:00
|
|
|
{ "n25q00", INFO(0x20ba21, 0, 64 * 1024, 2048, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ | NO_CHIP_ERASE) },
|
|
|
|
{ "n25q00a", INFO(0x20bb21, 0, 64 * 1024, 2048, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ | NO_CHIP_ERASE) },
|
2018-04-06 03:12:49 +08:00
|
|
|
{ "mt25qu02g", INFO(0x20bb22, 0, 64 * 1024, 4096, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ | NO_CHIP_ERASE) },
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* PMC */
|
|
|
|
{ "pm25lv512", INFO(0, 0, 32 * 1024, 2, SECT_4K_PMC) },
|
|
|
|
{ "pm25lv010", INFO(0, 0, 32 * 1024, 4, SECT_4K_PMC) },
|
|
|
|
{ "pm25lq032", INFO(0x7f9d46, 0, 64 * 1024, 64, SECT_4K) },
|
|
|
|
|
2017-12-21 20:27:30 +08:00
|
|
|
/* Spansion/Cypress -- single (large) sector size only, at least
|
2014-02-24 18:37:37 +08:00
|
|
|
* for the chips listed here (without boot sectors).
|
|
|
|
*/
|
2014-04-22 20:45:32 +08:00
|
|
|
{ "s25sl032p", INFO(0x010215, 0x4d00, 64 * 1024, 64, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2015-08-15 00:42:32 +08:00
|
|
|
{ "s25sl064p", INFO(0x010216, 0x4d00, 64 * 1024, 128, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2017-07-17 23:54:07 +08:00
|
|
|
{ "s25fl256s0", INFO(0x010219, 0x4d00, 256 * 1024, 128, USE_CLSR) },
|
|
|
|
{ "s25fl256s1", INFO(0x010219, 0x4d01, 64 * 1024, 512, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
|
|
|
|
{ "s25fl512s", INFO(0x010220, 0x4d00, 256 * 1024, 256, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "s70fl01gs", INFO(0x010221, 0x4d00, 256 * 1024, 256, 0) },
|
|
|
|
{ "s25sl12800", INFO(0x012018, 0x0300, 256 * 1024, 64, 0) },
|
|
|
|
{ "s25sl12801", INFO(0x012018, 0x0301, 64 * 1024, 256, 0) },
|
2017-07-17 23:54:07 +08:00
|
|
|
{ "s25fl128s", INFO6(0x012018, 0x4d0180, 64 * 1024, 256, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
|
|
|
|
{ "s25fl129p0", INFO(0x012018, 0x4d00, 256 * 1024, 64, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
|
|
|
|
{ "s25fl129p1", INFO(0x012018, 0x4d01, 64 * 1024, 256, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | USE_CLSR) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "s25sl004a", INFO(0x010212, 0, 64 * 1024, 8, 0) },
|
|
|
|
{ "s25sl008a", INFO(0x010213, 0, 64 * 1024, 16, 0) },
|
|
|
|
{ "s25sl016a", INFO(0x010214, 0, 64 * 1024, 32, 0) },
|
|
|
|
{ "s25sl032a", INFO(0x010215, 0, 64 * 1024, 64, 0) },
|
|
|
|
{ "s25sl064a", INFO(0x010216, 0, 64 * 1024, 128, 0) },
|
2015-10-13 14:50:30 +08:00
|
|
|
{ "s25fl004k", INFO(0xef4013, 0, 64 * 1024, 8, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2015-07-10 04:30:57 +08:00
|
|
|
{ "s25fl008k", INFO(0xef4014, 0, 64 * 1024, 16, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
|
|
|
{ "s25fl016k", INFO(0xef4015, 0, 64 * 1024, 32, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "s25fl064k", INFO(0xef4017, 0, 64 * 1024, 128, SECT_4K) },
|
2016-02-11 18:53:57 +08:00
|
|
|
{ "s25fl116k", INFO(0x014015, 0, 64 * 1024, 32, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2015-04-25 18:41:30 +08:00
|
|
|
{ "s25fl132k", INFO(0x014016, 0, 64 * 1024, 64, SECT_4K) },
|
2015-04-25 18:01:35 +08:00
|
|
|
{ "s25fl164k", INFO(0x014017, 0, 64 * 1024, 128, SECT_4K) },
|
2015-10-13 14:51:14 +08:00
|
|
|
{ "s25fl204k", INFO(0x014013, 0, 64 * 1024, 8, SECT_4K | SPI_NOR_DUAL_READ) },
|
2016-10-05 16:59:49 +08:00
|
|
|
{ "s25fl208k", INFO(0x014014, 0, 64 * 1024, 16, SECT_4K | SPI_NOR_DUAL_READ) },
|
2017-06-23 03:58:11 +08:00
|
|
|
{ "s25fl064l", INFO(0x016017, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
|
2017-12-21 20:27:30 +08:00
|
|
|
{ "s25fl128l", INFO(0x016018, 0, 64 * 1024, 256, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
|
|
|
|
{ "s25fl256l", INFO(0x016019, 0, 64 * 1024, 512, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ | SPI_NOR_4B_OPCODES) },
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* SST -- large erase sizes are "overlays", "sectors" are 4K */
|
|
|
|
{ "sst25vf040b", INFO(0xbf258d, 0, 64 * 1024, 8, SECT_4K | SST_WRITE) },
|
|
|
|
{ "sst25vf080b", INFO(0xbf258e, 0, 64 * 1024, 16, SECT_4K | SST_WRITE) },
|
|
|
|
{ "sst25vf016b", INFO(0xbf2541, 0, 64 * 1024, 32, SECT_4K | SST_WRITE) },
|
|
|
|
{ "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64, SECT_4K | SST_WRITE) },
|
|
|
|
{ "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128, SECT_4K) },
|
|
|
|
{ "sst25wf512", INFO(0xbf2501, 0, 64 * 1024, 1, SECT_4K | SST_WRITE) },
|
|
|
|
{ "sst25wf010", INFO(0xbf2502, 0, 64 * 1024, 2, SECT_4K | SST_WRITE) },
|
|
|
|
{ "sst25wf020", INFO(0xbf2503, 0, 64 * 1024, 4, SECT_4K | SST_WRITE) },
|
2015-08-15 01:35:39 +08:00
|
|
|
{ "sst25wf020a", INFO(0x621612, 0, 64 * 1024, 4, SECT_4K) },
|
2015-09-16 17:59:45 +08:00
|
|
|
{ "sst25wf040b", INFO(0x621613, 0, 64 * 1024, 8, SECT_4K) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "sst25wf040", INFO(0xbf2504, 0, 64 * 1024, 8, SECT_4K | SST_WRITE) },
|
2014-10-21 19:37:59 +08:00
|
|
|
{ "sst25wf080", INFO(0xbf2505, 0, 64 * 1024, 16, SECT_4K | SST_WRITE) },
|
2017-08-22 17:51:16 +08:00
|
|
|
{ "sst26vf064b", INFO(0xbf2643, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* ST Microelectronics -- newer production may have feature updates */
|
|
|
|
{ "m25p05", INFO(0x202010, 0, 32 * 1024, 2, 0) },
|
|
|
|
{ "m25p10", INFO(0x202011, 0, 32 * 1024, 4, 0) },
|
|
|
|
{ "m25p20", INFO(0x202012, 0, 64 * 1024, 4, 0) },
|
|
|
|
{ "m25p40", INFO(0x202013, 0, 64 * 1024, 8, 0) },
|
|
|
|
{ "m25p80", INFO(0x202014, 0, 64 * 1024, 16, 0) },
|
|
|
|
{ "m25p16", INFO(0x202015, 0, 64 * 1024, 32, 0) },
|
|
|
|
{ "m25p32", INFO(0x202016, 0, 64 * 1024, 64, 0) },
|
|
|
|
{ "m25p64", INFO(0x202017, 0, 64 * 1024, 128, 0) },
|
|
|
|
{ "m25p128", INFO(0x202018, 0, 256 * 1024, 64, 0) },
|
|
|
|
|
|
|
|
{ "m25p05-nonjedec", INFO(0, 0, 32 * 1024, 2, 0) },
|
|
|
|
{ "m25p10-nonjedec", INFO(0, 0, 32 * 1024, 4, 0) },
|
|
|
|
{ "m25p20-nonjedec", INFO(0, 0, 64 * 1024, 4, 0) },
|
|
|
|
{ "m25p40-nonjedec", INFO(0, 0, 64 * 1024, 8, 0) },
|
|
|
|
{ "m25p80-nonjedec", INFO(0, 0, 64 * 1024, 16, 0) },
|
|
|
|
{ "m25p16-nonjedec", INFO(0, 0, 64 * 1024, 32, 0) },
|
|
|
|
{ "m25p32-nonjedec", INFO(0, 0, 64 * 1024, 64, 0) },
|
|
|
|
{ "m25p64-nonjedec", INFO(0, 0, 64 * 1024, 128, 0) },
|
|
|
|
{ "m25p128-nonjedec", INFO(0, 0, 256 * 1024, 64, 0) },
|
|
|
|
|
|
|
|
{ "m45pe10", INFO(0x204011, 0, 64 * 1024, 2, 0) },
|
|
|
|
{ "m45pe80", INFO(0x204014, 0, 64 * 1024, 16, 0) },
|
|
|
|
{ "m45pe16", INFO(0x204015, 0, 64 * 1024, 32, 0) },
|
|
|
|
|
|
|
|
{ "m25pe20", INFO(0x208012, 0, 64 * 1024, 4, 0) },
|
|
|
|
{ "m25pe80", INFO(0x208014, 0, 64 * 1024, 16, 0) },
|
|
|
|
{ "m25pe16", INFO(0x208015, 0, 64 * 1024, 32, SECT_4K) },
|
|
|
|
|
|
|
|
{ "m25px16", INFO(0x207115, 0, 64 * 1024, 32, SECT_4K) },
|
|
|
|
{ "m25px32", INFO(0x207116, 0, 64 * 1024, 64, SECT_4K) },
|
|
|
|
{ "m25px32-s0", INFO(0x207316, 0, 64 * 1024, 64, SECT_4K) },
|
|
|
|
{ "m25px32-s1", INFO(0x206316, 0, 64 * 1024, 64, SECT_4K) },
|
|
|
|
{ "m25px64", INFO(0x207117, 0, 64 * 1024, 128, 0) },
|
2014-07-28 05:56:08 +08:00
|
|
|
{ "m25px80", INFO(0x207114, 0, 64 * 1024, 16, 0) },
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
|
2015-03-27 06:58:02 +08:00
|
|
|
{ "w25x05", INFO(0xef3010, 0, 64 * 1024, 1, SECT_4K) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "w25x10", INFO(0xef3011, 0, 64 * 1024, 2, SECT_4K) },
|
|
|
|
{ "w25x20", INFO(0xef3012, 0, 64 * 1024, 4, SECT_4K) },
|
|
|
|
{ "w25x40", INFO(0xef3013, 0, 64 * 1024, 8, SECT_4K) },
|
|
|
|
{ "w25x80", INFO(0xef3014, 0, 64 * 1024, 16, SECT_4K) },
|
|
|
|
{ "w25x16", INFO(0xef3015, 0, 64 * 1024, 32, SECT_4K) },
|
2017-08-28 21:11:33 +08:00
|
|
|
{
|
|
|
|
"w25q16dw", INFO(0xef6015, 0, 64 * 1024, 32,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "w25x32", INFO(0xef3016, 0, 64 * 1024, 64, SECT_4K) },
|
2017-03-12 03:01:04 +08:00
|
|
|
{ "w25q20cl", INFO(0xef4012, 0, 64 * 1024, 4, SECT_4K) },
|
|
|
|
{ "w25q20bw", INFO(0xef5012, 0, 64 * 1024, 4, SECT_4K) },
|
|
|
|
{ "w25q20ew", INFO(0xef6012, 0, 64 * 1024, 4, SECT_4K) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "w25q32", INFO(0xef4016, 0, 64 * 1024, 64, SECT_4K) },
|
2016-01-30 03:25:37 +08:00
|
|
|
{
|
|
|
|
"w25q32dw", INFO(0xef6016, 0, 64 * 1024, 64,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
2018-03-08 07:55:57 +08:00
|
|
|
{
|
|
|
|
"w25q32jv", INFO(0xef7016, 0, 64 * 1024, 64,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "w25x64", INFO(0xef3017, 0, 64 * 1024, 128, SECT_4K) },
|
|
|
|
{ "w25q64", INFO(0xef4017, 0, 64 * 1024, 128, SECT_4K) },
|
2016-01-30 03:25:37 +08:00
|
|
|
{
|
|
|
|
"w25q64dw", INFO(0xef6017, 0, 64 * 1024, 128,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"w25q128fw", INFO(0xef6018, 0, 64 * 1024, 256,
|
|
|
|
SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ |
|
|
|
|
SPI_NOR_HAS_LOCK | SPI_NOR_HAS_TB)
|
|
|
|
},
|
2014-02-24 18:37:37 +08:00
|
|
|
{ "w25q80", INFO(0xef5014, 0, 64 * 1024, 16, SECT_4K) },
|
|
|
|
{ "w25q80bl", INFO(0xef4014, 0, 64 * 1024, 16, SECT_4K) },
|
|
|
|
{ "w25q128", INFO(0xef4018, 0, 64 * 1024, 256, SECT_4K) },
|
2017-04-19 22:00:20 +08:00
|
|
|
{ "w25q256", INFO(0xef4019, 0, 64 * 1024, 512, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2017-06-20 22:48:43 +08:00
|
|
|
{ "w25m512jv", INFO(0xef7119, 0, 64 * 1024, 1024,
|
|
|
|
SECT_4K | SPI_NOR_QUAD_READ | SPI_NOR_DUAL_READ) },
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* Catalyst / On Semiconductor -- non-JEDEC */
|
|
|
|
{ "cat25c11", CAT25_INFO( 16, 8, 16, 1, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
|
|
|
|
{ "cat25c03", CAT25_INFO( 32, 8, 16, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
|
|
|
|
{ "cat25c09", CAT25_INFO( 128, 8, 32, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
|
|
|
|
{ "cat25c17", CAT25_INFO( 256, 8, 32, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
|
|
|
|
{ "cat25128", CAT25_INFO(2048, 8, 64, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
|
2016-12-02 19:31:44 +08:00
|
|
|
|
|
|
|
/* Xilinx S3AN Internal Flash */
|
|
|
|
{ "3S50AN", S3AN_INFO(0x1f2200, 64, 264) },
|
|
|
|
{ "3S200AN", S3AN_INFO(0x1f2400, 256, 264) },
|
|
|
|
{ "3S400AN", S3AN_INFO(0x1f2400, 256, 264) },
|
|
|
|
{ "3S700AN", S3AN_INFO(0x1f2500, 512, 264) },
|
|
|
|
{ "3S1400AN", S3AN_INFO(0x1f2600, 512, 528) },
|
2018-04-19 04:25:32 +08:00
|
|
|
|
|
|
|
/* XMC (Wuhan Xinxin Semiconductor Manufacturing Corp.) */
|
|
|
|
{ "XM25QH64A", INFO(0x207017, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
|
|
|
{ "XM25QH128A", INFO(0x207018, 0, 64 * 1024, 256, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
|
2014-02-24 18:37:37 +08:00
|
|
|
{ },
|
|
|
|
};
|
|
|
|
|
2015-08-11 03:39:03 +08:00
|
|
|
static const struct flash_info *spi_nor_read_id(struct spi_nor *nor)
|
2014-02-24 18:37:37 +08:00
|
|
|
{
|
|
|
|
int tmp;
|
2014-11-06 14:34:01 +08:00
|
|
|
u8 id[SPI_NOR_MAX_ID_LEN];
|
2015-08-11 03:39:03 +08:00
|
|
|
const struct flash_info *info;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2014-11-06 14:34:01 +08:00
|
|
|
tmp = nor->read_reg(nor, SPINOR_OP_RDID, id, SPI_NOR_MAX_ID_LEN);
|
2014-02-24 18:37:37 +08:00
|
|
|
if (tmp < 0) {
|
2015-10-31 03:56:22 +08:00
|
|
|
dev_dbg(nor->dev, "error %d reading JEDEC ID\n", tmp);
|
2014-02-24 18:37:37 +08:00
|
|
|
return ERR_PTR(tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (tmp = 0; tmp < ARRAY_SIZE(spi_nor_ids) - 1; tmp++) {
|
2015-08-11 03:39:03 +08:00
|
|
|
info = &spi_nor_ids[tmp];
|
2014-11-06 14:34:01 +08:00
|
|
|
if (info->id_len) {
|
|
|
|
if (!memcmp(info->id, id, info->id_len))
|
2014-02-24 18:37:37 +08:00
|
|
|
return &spi_nor_ids[tmp];
|
|
|
|
}
|
|
|
|
}
|
2015-12-01 03:41:17 +08:00
|
|
|
dev_err(nor->dev, "unrecognized JEDEC id bytes: %02x, %02x, %02x\n",
|
2014-11-06 14:34:01 +08:00
|
|
|
id[0], id[1], id[2]);
|
2014-02-24 18:37:37 +08:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_read(struct mtd_info *mtd, loff_t from, size_t len,
|
|
|
|
size_t *retlen, u_char *buf)
|
|
|
|
{
|
|
|
|
struct spi_nor *nor = mtd_to_spi_nor(mtd);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(nor->dev, "from 0x%08x, len %zd\n", (u32)from, len);
|
|
|
|
|
|
|
|
ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_READ);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2016-05-06 08:31:55 +08:00
|
|
|
while (len) {
|
2016-12-02 19:31:44 +08:00
|
|
|
loff_t addr = from;
|
|
|
|
|
|
|
|
if (nor->flags & SNOR_F_S3AN_ADDR_DEFAULT)
|
|
|
|
addr = spi_nor_s3an_addr_convert(nor, addr);
|
|
|
|
|
|
|
|
ret = nor->read(nor, addr, len, buf);
|
2016-05-06 08:31:55 +08:00
|
|
|
if (ret == 0) {
|
|
|
|
/* We shouldn't see 0-length reads */
|
|
|
|
ret = -EIO;
|
|
|
|
goto read_err;
|
|
|
|
}
|
|
|
|
if (ret < 0)
|
|
|
|
goto read_err;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2016-05-06 08:31:55 +08:00
|
|
|
WARN_ON(ret > len);
|
|
|
|
*retlen += ret;
|
|
|
|
buf += ret;
|
|
|
|
from += ret;
|
|
|
|
len -= ret;
|
|
|
|
}
|
|
|
|
ret = 0;
|
2016-05-06 08:31:47 +08:00
|
|
|
|
2016-05-06 08:31:55 +08:00
|
|
|
read_err:
|
|
|
|
spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_READ);
|
|
|
|
return ret;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sst_write(struct mtd_info *mtd, loff_t to, size_t len,
|
|
|
|
size_t *retlen, const u_char *buf)
|
|
|
|
{
|
|
|
|
struct spi_nor *nor = mtd_to_spi_nor(mtd);
|
|
|
|
size_t actual;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(nor->dev, "to 0x%08x, len %zd\n", (u32)to, len);
|
|
|
|
|
|
|
|
ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_WRITE);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
write_enable(nor);
|
|
|
|
|
|
|
|
nor->sst_write_second = false;
|
|
|
|
|
|
|
|
actual = to % 2;
|
|
|
|
/* Start write from odd address. */
|
|
|
|
if (actual) {
|
2014-04-09 09:15:31 +08:00
|
|
|
nor->program_opcode = SPINOR_OP_BP;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* write one byte. */
|
2016-05-06 08:31:53 +08:00
|
|
|
ret = nor->write(nor, to, 1, buf);
|
2016-05-06 08:31:52 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto sst_write_err;
|
|
|
|
WARN(ret != 1, "While writing 1 byte written %i bytes\n",
|
|
|
|
(int)ret);
|
2014-08-07 09:17:00 +08:00
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
2014-02-24 18:37:37 +08:00
|
|
|
if (ret)
|
2016-05-06 08:31:52 +08:00
|
|
|
goto sst_write_err;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
to += actual;
|
|
|
|
|
|
|
|
/* Write out most of the data here. */
|
|
|
|
for (; actual < len - 1; actual += 2) {
|
2014-04-09 09:15:31 +08:00
|
|
|
nor->program_opcode = SPINOR_OP_AAI_WP;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* write two bytes. */
|
2016-05-06 08:31:53 +08:00
|
|
|
ret = nor->write(nor, to, 2, buf + actual);
|
2016-05-06 08:31:52 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto sst_write_err;
|
|
|
|
WARN(ret != 2, "While writing 2 bytes written %i bytes\n",
|
|
|
|
(int)ret);
|
2014-08-07 09:17:00 +08:00
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
2014-02-24 18:37:37 +08:00
|
|
|
if (ret)
|
2016-05-06 08:31:52 +08:00
|
|
|
goto sst_write_err;
|
2014-02-24 18:37:37 +08:00
|
|
|
to += 2;
|
|
|
|
nor->sst_write_second = true;
|
|
|
|
}
|
|
|
|
nor->sst_write_second = false;
|
|
|
|
|
|
|
|
write_disable(nor);
|
2014-08-07 09:17:00 +08:00
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
2014-02-24 18:37:37 +08:00
|
|
|
if (ret)
|
2016-05-06 08:31:52 +08:00
|
|
|
goto sst_write_err;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
/* Write out trailing byte if it exists. */
|
|
|
|
if (actual != len) {
|
|
|
|
write_enable(nor);
|
|
|
|
|
2014-04-09 09:15:31 +08:00
|
|
|
nor->program_opcode = SPINOR_OP_BP;
|
2016-05-06 08:31:53 +08:00
|
|
|
ret = nor->write(nor, to, 1, buf + actual);
|
2016-05-06 08:31:52 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto sst_write_err;
|
|
|
|
WARN(ret != 1, "While writing 1 byte written %i bytes\n",
|
|
|
|
(int)ret);
|
2014-08-07 09:17:00 +08:00
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
2014-02-24 18:37:37 +08:00
|
|
|
if (ret)
|
2016-05-06 08:31:52 +08:00
|
|
|
goto sst_write_err;
|
2014-02-24 18:37:37 +08:00
|
|
|
write_disable(nor);
|
2016-05-06 08:31:53 +08:00
|
|
|
actual += 1;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
2016-05-06 08:31:52 +08:00
|
|
|
sst_write_err:
|
2016-05-06 08:31:53 +08:00
|
|
|
*retlen += actual;
|
2014-02-24 18:37:37 +08:00
|
|
|
spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_WRITE);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write an address range to the nor chip. Data must be written in
|
|
|
|
* FLASH_PAGESIZE chunks. The address range may be any size provided
|
|
|
|
* it is within the physical boundaries.
|
|
|
|
*/
|
|
|
|
static int spi_nor_write(struct mtd_info *mtd, loff_t to, size_t len,
|
|
|
|
size_t *retlen, const u_char *buf)
|
|
|
|
{
|
|
|
|
struct spi_nor *nor = mtd_to_spi_nor(mtd);
|
2016-05-06 08:31:54 +08:00
|
|
|
size_t page_offset, page_remain, i;
|
|
|
|
ssize_t ret;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
dev_dbg(nor->dev, "to 0x%08x, len %zd\n", (u32)to, len);
|
|
|
|
|
|
|
|
ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_WRITE);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2016-05-06 08:31:54 +08:00
|
|
|
for (i = 0; i < len; ) {
|
|
|
|
ssize_t written;
|
2016-12-02 19:31:44 +08:00
|
|
|
loff_t addr = to + i;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2016-12-02 19:31:44 +08:00
|
|
|
/*
|
|
|
|
* If page_size is a power of two, the offset can be quickly
|
|
|
|
* calculated with an AND operation. On the other cases we
|
|
|
|
* need to do a modulus operation (more expensive).
|
|
|
|
* Power of two numbers have only one bit set and we can use
|
|
|
|
* the instruction hweight32 to detect if we need to do a
|
|
|
|
* modulus (do_div()) or not.
|
|
|
|
*/
|
|
|
|
if (hweight32(nor->page_size) == 1) {
|
|
|
|
page_offset = addr & (nor->page_size - 1);
|
|
|
|
} else {
|
|
|
|
uint64_t aux = addr;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2016-12-02 19:31:44 +08:00
|
|
|
page_offset = do_div(aux, nor->page_size);
|
|
|
|
}
|
2014-02-24 18:37:37 +08:00
|
|
|
/* the size of data remaining on the first page */
|
2016-05-06 08:31:54 +08:00
|
|
|
page_remain = min_t(size_t,
|
|
|
|
nor->page_size - page_offset, len - i);
|
|
|
|
|
2016-12-02 19:31:44 +08:00
|
|
|
if (nor->flags & SNOR_F_S3AN_ADDR_DEFAULT)
|
|
|
|
addr = spi_nor_s3an_addr_convert(nor, addr);
|
|
|
|
|
2016-05-06 08:31:54 +08:00
|
|
|
write_enable(nor);
|
2016-12-02 19:31:44 +08:00
|
|
|
ret = nor->write(nor, addr, page_remain, buf + i);
|
2016-05-06 08:31:52 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto write_err;
|
2016-05-06 08:31:54 +08:00
|
|
|
written = ret;
|
2014-08-07 09:16:56 +08:00
|
|
|
|
2016-05-06 08:31:54 +08:00
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
|
|
|
if (ret)
|
|
|
|
goto write_err;
|
|
|
|
*retlen += written;
|
|
|
|
i += written;
|
|
|
|
if (written != page_remain) {
|
|
|
|
dev_err(nor->dev,
|
|
|
|
"While writing %zu bytes written %zd bytes\n",
|
|
|
|
page_remain, written);
|
|
|
|
ret = -EIO;
|
|
|
|
goto write_err;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
write_err:
|
|
|
|
spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_WRITE);
|
2014-08-07 09:16:56 +08:00
|
|
|
return ret;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
/**
|
|
|
|
* macronix_quad_enable() - set QE bit in Status Register.
|
|
|
|
* @nor: pointer to a 'struct spi_nor'
|
|
|
|
*
|
|
|
|
* Set the Quad Enable (QE) bit in the Status Register.
|
|
|
|
*
|
|
|
|
* bit 6 of the Status Register is the QE bit for Macronix like QSPI memories.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -errno otherwise.
|
|
|
|
*/
|
2014-02-24 18:37:37 +08:00
|
|
|
static int macronix_quad_enable(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
int ret, val;
|
|
|
|
|
|
|
|
val = read_sr(nor);
|
2015-11-21 02:26:11 +08:00
|
|
|
if (val < 0)
|
|
|
|
return val;
|
2016-12-07 00:01:41 +08:00
|
|
|
if (val & SR_QUAD_EN_MX)
|
|
|
|
return 0;
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
write_enable(nor);
|
|
|
|
|
2015-08-19 17:56:43 +08:00
|
|
|
write_sr(nor, val | SR_QUAD_EN_MX);
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2017-05-05 13:33:56 +08:00
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
|
|
|
ret = read_sr(nor);
|
|
|
|
if (!(ret > 0 && (ret & SR_QUAD_EN_MX))) {
|
|
|
|
dev_err(nor->dev, "Macronix Quad bit not set\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write status Register and configuration register with 2 bytes
|
|
|
|
* The first byte will be written to the status register, while the
|
|
|
|
* second byte will be written to the configuration register.
|
2017-01-27 09:36:38 +08:00
|
|
|
* Return negative if error occurred.
|
2014-02-24 18:37:37 +08:00
|
|
|
*/
|
2017-06-26 21:10:00 +08:00
|
|
|
static int write_sr_cr(struct spi_nor *nor, u8 *sr_cr)
|
2014-02-24 18:37:37 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
write_enable(nor);
|
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
ret = nor->write_reg(nor, SPINOR_OP_WRSR, sr_cr, 2);
|
2014-02-24 18:37:37 +08:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(nor->dev,
|
|
|
|
"error while writing configuration register\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-11-23 19:47:40 +08:00
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(nor->dev,
|
|
|
|
"timeout while writing configuration register\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* spansion_quad_enable() - set QE bit in Configuraiton Register.
|
|
|
|
* @nor: pointer to a 'struct spi_nor'
|
|
|
|
*
|
|
|
|
* Set the Quad Enable (QE) bit in the Configuration Register.
|
|
|
|
* This function is kept for legacy purpose because it has been used for a
|
|
|
|
* long time without anybody complaining but it should be considered as
|
|
|
|
* deprecated and maybe buggy.
|
|
|
|
* First, this function doesn't care about the previous values of the Status
|
|
|
|
* and Configuration Registers when it sets the QE bit (bit 1) in the
|
|
|
|
* Configuration Register: all other bits are cleared, which may have unwanted
|
|
|
|
* side effects like removing some block protections.
|
|
|
|
* Secondly, it uses the Read Configuration Register (35h) instruction though
|
|
|
|
* some very old and few memories don't support this instruction. If a pull-up
|
|
|
|
* resistor is present on the MISO/IO1 line, we might still be able to pass the
|
|
|
|
* "read back" test because the QSPI memory doesn't recognize the command,
|
|
|
|
* so leaves the MISO/IO1 line state unchanged, hence read_cr() returns 0xFF.
|
|
|
|
*
|
|
|
|
* bit 1 of the Configuration Register is the QE bit for Spansion like QSPI
|
|
|
|
* memories.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -errno otherwise.
|
|
|
|
*/
|
|
|
|
static int spansion_quad_enable(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
u8 sr_cr[2] = {0, CR_QUAD_EN_SPAN};
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = write_sr_cr(nor, sr_cr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/* read back and check it */
|
|
|
|
ret = read_cr(nor);
|
|
|
|
if (!(ret > 0 && (ret & CR_QUAD_EN_SPAN))) {
|
|
|
|
dev_err(nor->dev, "Spansion Quad bit not set\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
/**
|
|
|
|
* spansion_no_read_cr_quad_enable() - set QE bit in Configuration Register.
|
|
|
|
* @nor: pointer to a 'struct spi_nor'
|
|
|
|
*
|
|
|
|
* Set the Quad Enable (QE) bit in the Configuration Register.
|
|
|
|
* This function should be used with QSPI memories not supporting the Read
|
|
|
|
* Configuration Register (35h) instruction.
|
|
|
|
*
|
|
|
|
* bit 1 of the Configuration Register is the QE bit for Spansion like QSPI
|
|
|
|
* memories.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -errno otherwise.
|
|
|
|
*/
|
|
|
|
static int spansion_no_read_cr_quad_enable(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
u8 sr_cr[2];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Keep the current value of the Status Register. */
|
|
|
|
ret = read_sr(nor);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(nor->dev, "error while reading status register\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
sr_cr[0] = ret;
|
|
|
|
sr_cr[1] = CR_QUAD_EN_SPAN;
|
|
|
|
|
|
|
|
return write_sr_cr(nor, sr_cr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* spansion_read_cr_quad_enable() - set QE bit in Configuration Register.
|
|
|
|
* @nor: pointer to a 'struct spi_nor'
|
|
|
|
*
|
|
|
|
* Set the Quad Enable (QE) bit in the Configuration Register.
|
|
|
|
* This function should be used with QSPI memories supporting the Read
|
|
|
|
* Configuration Register (35h) instruction.
|
|
|
|
*
|
|
|
|
* bit 1 of the Configuration Register is the QE bit for Spansion like QSPI
|
|
|
|
* memories.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -errno otherwise.
|
|
|
|
*/
|
|
|
|
static int spansion_read_cr_quad_enable(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
struct device *dev = nor->dev;
|
|
|
|
u8 sr_cr[2];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Check current Quad Enable bit value. */
|
|
|
|
ret = read_cr(nor);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "error while reading configuration register\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret & CR_QUAD_EN_SPAN)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
sr_cr[1] = ret | CR_QUAD_EN_SPAN;
|
|
|
|
|
|
|
|
/* Keep the current value of the Status Register. */
|
|
|
|
ret = read_sr(nor);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "error while reading status register\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
sr_cr[0] = ret;
|
|
|
|
|
|
|
|
ret = write_sr_cr(nor, sr_cr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Read back and check it. */
|
|
|
|
ret = read_cr(nor);
|
|
|
|
if (!(ret > 0 && (ret & CR_QUAD_EN_SPAN))) {
|
|
|
|
dev_err(nor->dev, "Spansion Quad bit not set\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sr2_bit7_quad_enable() - set QE bit in Status Register 2.
|
|
|
|
* @nor: pointer to a 'struct spi_nor'
|
|
|
|
*
|
|
|
|
* Set the Quad Enable (QE) bit in the Status Register 2.
|
|
|
|
*
|
|
|
|
* This is one of the procedures to set the QE bit described in the SFDP
|
|
|
|
* (JESD216 rev B) specification but no manufacturer using this procedure has
|
|
|
|
* been identified yet, hence the name of the function.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -errno otherwise.
|
|
|
|
*/
|
|
|
|
static int sr2_bit7_quad_enable(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
u8 sr2;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* Check current Quad Enable bit value. */
|
|
|
|
ret = nor->read_reg(nor, SPINOR_OP_RDSR2, &sr2, 1);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (sr2 & SR2_QUAD_EN_BIT7)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Update the Quad Enable bit. */
|
|
|
|
sr2 |= SR2_QUAD_EN_BIT7;
|
|
|
|
|
|
|
|
write_enable(nor);
|
|
|
|
|
|
|
|
ret = nor->write_reg(nor, SPINOR_OP_WRSR2, &sr2, 1);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(nor->dev, "error while writing status register 2\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = spi_nor_wait_till_ready(nor);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(nor->dev, "timeout while writing status register 2\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Read back and check it. */
|
|
|
|
ret = nor->read_reg(nor, SPINOR_OP_RDSR2, &sr2, 1);
|
|
|
|
if (!(ret > 0 && (sr2 & SR2_QUAD_EN_BIT7))) {
|
|
|
|
dev_err(nor->dev, "SR2 Quad bit not set\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
static int spi_nor_check(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
if (!nor->dev || !nor->read || !nor->write ||
|
2015-11-11 04:15:27 +08:00
|
|
|
!nor->read_reg || !nor->write_reg) {
|
2014-02-24 18:37:37 +08:00
|
|
|
pr_err("spi-nor: please fill all the necessary fields!\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-12-02 19:31:44 +08:00
|
|
|
static int s3an_nor_scan(const struct flash_info *info, struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u8 val;
|
|
|
|
|
|
|
|
ret = nor->read_reg(nor, SPINOR_OP_XRDSR, &val, 1);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(nor->dev, "error %d reading XRDSR\n", (int) ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
nor->erase_opcode = SPINOR_OP_XSE;
|
|
|
|
nor->program_opcode = SPINOR_OP_XPP;
|
|
|
|
nor->read_opcode = SPINOR_OP_READ;
|
|
|
|
nor->flags |= SNOR_F_NO_OP_CHIP_ERASE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This flashes have a page size of 264 or 528 bytes (known as
|
|
|
|
* Default addressing mode). It can be changed to a more standard
|
|
|
|
* Power of two mode where the page size is 256/512. This comes
|
|
|
|
* with a price: there is 3% less of space, the data is corrupted
|
|
|
|
* and the page size cannot be changed back to default addressing
|
|
|
|
* mode.
|
|
|
|
*
|
|
|
|
* The current addressing mode can be read from the XRDSR register
|
|
|
|
* and should not be changed, because is a destructive operation.
|
|
|
|
*/
|
|
|
|
if (val & XSR_PAGESIZE) {
|
|
|
|
/* Flash in Power of 2 mode */
|
|
|
|
nor->page_size = (nor->page_size == 264) ? 256 : 512;
|
|
|
|
nor->mtd.writebufsize = nor->page_size;
|
|
|
|
nor->mtd.size = 8 * nor->page_size * info->n_sectors;
|
|
|
|
nor->mtd.erasesize = 8 * nor->page_size;
|
|
|
|
} else {
|
|
|
|
/* Flash in Default addressing mode */
|
|
|
|
nor->flags |= SNOR_F_S3AN_ADDR_DEFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
struct spi_nor_read_command {
|
|
|
|
u8 num_mode_clocks;
|
|
|
|
u8 num_wait_states;
|
|
|
|
u8 opcode;
|
|
|
|
enum spi_nor_protocol proto;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct spi_nor_pp_command {
|
|
|
|
u8 opcode;
|
|
|
|
enum spi_nor_protocol proto;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum spi_nor_read_command_index {
|
|
|
|
SNOR_CMD_READ,
|
|
|
|
SNOR_CMD_READ_FAST,
|
2017-04-26 04:08:48 +08:00
|
|
|
SNOR_CMD_READ_1_1_1_DTR,
|
2017-04-26 04:08:46 +08:00
|
|
|
|
|
|
|
/* Dual SPI */
|
|
|
|
SNOR_CMD_READ_1_1_2,
|
|
|
|
SNOR_CMD_READ_1_2_2,
|
|
|
|
SNOR_CMD_READ_2_2_2,
|
2017-04-26 04:08:48 +08:00
|
|
|
SNOR_CMD_READ_1_2_2_DTR,
|
2017-04-26 04:08:46 +08:00
|
|
|
|
|
|
|
/* Quad SPI */
|
|
|
|
SNOR_CMD_READ_1_1_4,
|
|
|
|
SNOR_CMD_READ_1_4_4,
|
|
|
|
SNOR_CMD_READ_4_4_4,
|
2017-04-26 04:08:48 +08:00
|
|
|
SNOR_CMD_READ_1_4_4_DTR,
|
2017-04-26 04:08:46 +08:00
|
|
|
|
2017-04-26 04:08:49 +08:00
|
|
|
/* Octo SPI */
|
|
|
|
SNOR_CMD_READ_1_1_8,
|
|
|
|
SNOR_CMD_READ_1_8_8,
|
|
|
|
SNOR_CMD_READ_8_8_8,
|
|
|
|
SNOR_CMD_READ_1_8_8_DTR,
|
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
SNOR_CMD_READ_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
enum spi_nor_pp_command_index {
|
|
|
|
SNOR_CMD_PP,
|
|
|
|
|
|
|
|
/* Quad SPI */
|
|
|
|
SNOR_CMD_PP_1_1_4,
|
|
|
|
SNOR_CMD_PP_1_4_4,
|
|
|
|
SNOR_CMD_PP_4_4_4,
|
|
|
|
|
2017-04-26 04:08:49 +08:00
|
|
|
/* Octo SPI */
|
|
|
|
SNOR_CMD_PP_1_1_8,
|
|
|
|
SNOR_CMD_PP_1_8_8,
|
|
|
|
SNOR_CMD_PP_8_8_8,
|
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
SNOR_CMD_PP_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
struct spi_nor_flash_parameter {
|
|
|
|
u64 size;
|
|
|
|
u32 page_size;
|
|
|
|
|
|
|
|
struct spi_nor_hwcaps hwcaps;
|
|
|
|
struct spi_nor_read_command reads[SNOR_CMD_READ_MAX];
|
|
|
|
struct spi_nor_pp_command page_programs[SNOR_CMD_PP_MAX];
|
|
|
|
|
|
|
|
int (*quad_enable)(struct spi_nor *nor);
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
spi_nor_set_read_settings(struct spi_nor_read_command *read,
|
|
|
|
u8 num_mode_clocks,
|
|
|
|
u8 num_wait_states,
|
|
|
|
u8 opcode,
|
|
|
|
enum spi_nor_protocol proto)
|
|
|
|
{
|
|
|
|
read->num_mode_clocks = num_mode_clocks;
|
|
|
|
read->num_wait_states = num_wait_states;
|
|
|
|
read->opcode = opcode;
|
|
|
|
read->proto = proto;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
spi_nor_set_pp_settings(struct spi_nor_pp_command *pp,
|
|
|
|
u8 opcode,
|
|
|
|
enum spi_nor_protocol proto)
|
|
|
|
{
|
|
|
|
pp->opcode = opcode;
|
|
|
|
pp->proto = proto;
|
|
|
|
}
|
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
/*
|
|
|
|
* Serial Flash Discoverable Parameters (SFDP) parsing.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* spi_nor_read_sfdp() - read Serial Flash Discoverable Parameters.
|
|
|
|
* @nor: pointer to a 'struct spi_nor'
|
|
|
|
* @addr: offset in the SFDP area to start reading data from
|
|
|
|
* @len: number of bytes to read
|
2017-09-07 05:45:02 +08:00
|
|
|
* @buf: buffer where the SFDP data are copied into (dma-safe memory)
|
2017-06-26 21:10:00 +08:00
|
|
|
*
|
|
|
|
* Whatever the actual numbers of bytes for address and dummy cycles are
|
|
|
|
* for (Fast) Read commands, the Read SFDP (5Ah) instruction is always
|
|
|
|
* followed by a 3-byte address and 8 dummy clock cycles.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -errno otherwise.
|
|
|
|
*/
|
|
|
|
static int spi_nor_read_sfdp(struct spi_nor *nor, u32 addr,
|
|
|
|
size_t len, void *buf)
|
|
|
|
{
|
|
|
|
u8 addr_width, read_opcode, read_dummy;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
read_opcode = nor->read_opcode;
|
|
|
|
addr_width = nor->addr_width;
|
|
|
|
read_dummy = nor->read_dummy;
|
|
|
|
|
|
|
|
nor->read_opcode = SPINOR_OP_RDSFDP;
|
|
|
|
nor->addr_width = 3;
|
|
|
|
nor->read_dummy = 8;
|
|
|
|
|
|
|
|
while (len) {
|
|
|
|
ret = nor->read(nor, addr, len, (u8 *)buf);
|
|
|
|
if (!ret || ret > len) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto read_err;
|
|
|
|
}
|
|
|
|
if (ret < 0)
|
|
|
|
goto read_err;
|
|
|
|
|
|
|
|
buf += ret;
|
|
|
|
addr += ret;
|
|
|
|
len -= ret;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
read_err:
|
|
|
|
nor->read_opcode = read_opcode;
|
|
|
|
nor->addr_width = addr_width;
|
|
|
|
nor->read_dummy = read_dummy;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-09-07 05:45:02 +08:00
|
|
|
/**
|
|
|
|
* spi_nor_read_sfdp_dma_unsafe() - read Serial Flash Discoverable Parameters.
|
|
|
|
* @nor: pointer to a 'struct spi_nor'
|
|
|
|
* @addr: offset in the SFDP area to start reading data from
|
|
|
|
* @len: number of bytes to read
|
|
|
|
* @buf: buffer where the SFDP data are copied into
|
|
|
|
*
|
|
|
|
* Wrap spi_nor_read_sfdp() using a kmalloc'ed bounce buffer as @buf is now not
|
|
|
|
* guaranteed to be dma-safe.
|
|
|
|
*
|
|
|
|
* Return: -ENOMEM if kmalloc() fails, the return code of spi_nor_read_sfdp()
|
|
|
|
* otherwise.
|
|
|
|
*/
|
|
|
|
static int spi_nor_read_sfdp_dma_unsafe(struct spi_nor *nor, u32 addr,
|
|
|
|
size_t len, void *buf)
|
|
|
|
{
|
|
|
|
void *dma_safe_buf;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dma_safe_buf = kmalloc(len, GFP_KERNEL);
|
|
|
|
if (!dma_safe_buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = spi_nor_read_sfdp(nor, addr, len, dma_safe_buf);
|
|
|
|
memcpy(buf, dma_safe_buf, len);
|
|
|
|
kfree(dma_safe_buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
struct sfdp_parameter_header {
|
|
|
|
u8 id_lsb;
|
|
|
|
u8 minor;
|
|
|
|
u8 major;
|
|
|
|
u8 length; /* in double words */
|
|
|
|
u8 parameter_table_pointer[3]; /* byte address */
|
|
|
|
u8 id_msb;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define SFDP_PARAM_HEADER_ID(p) (((p)->id_msb << 8) | (p)->id_lsb)
|
|
|
|
#define SFDP_PARAM_HEADER_PTP(p) \
|
|
|
|
(((p)->parameter_table_pointer[2] << 16) | \
|
|
|
|
((p)->parameter_table_pointer[1] << 8) | \
|
|
|
|
((p)->parameter_table_pointer[0] << 0))
|
|
|
|
|
|
|
|
#define SFDP_BFPT_ID 0xff00 /* Basic Flash Parameter Table */
|
|
|
|
#define SFDP_SECTOR_MAP_ID 0xff81 /* Sector Map Table */
|
|
|
|
|
|
|
|
#define SFDP_SIGNATURE 0x50444653U
|
|
|
|
#define SFDP_JESD216_MAJOR 1
|
|
|
|
#define SFDP_JESD216_MINOR 0
|
|
|
|
#define SFDP_JESD216A_MINOR 5
|
|
|
|
#define SFDP_JESD216B_MINOR 6
|
|
|
|
|
|
|
|
struct sfdp_header {
|
|
|
|
u32 signature; /* Ox50444653U <=> "SFDP" */
|
|
|
|
u8 minor;
|
|
|
|
u8 major;
|
|
|
|
u8 nph; /* 0-base number of parameter headers */
|
|
|
|
u8 unused;
|
|
|
|
|
|
|
|
/* Basic Flash Parameter Table. */
|
|
|
|
struct sfdp_parameter_header bfpt_header;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Basic Flash Parameter Table */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* JESD216 rev B defines a Basic Flash Parameter Table of 16 DWORDs.
|
|
|
|
* They are indexed from 1 but C arrays are indexed from 0.
|
|
|
|
*/
|
|
|
|
#define BFPT_DWORD(i) ((i) - 1)
|
|
|
|
#define BFPT_DWORD_MAX 16
|
|
|
|
|
|
|
|
/* The first version of JESB216 defined only 9 DWORDs. */
|
|
|
|
#define BFPT_DWORD_MAX_JESD216 9
|
|
|
|
|
|
|
|
/* 1st DWORD. */
|
|
|
|
#define BFPT_DWORD1_FAST_READ_1_1_2 BIT(16)
|
|
|
|
#define BFPT_DWORD1_ADDRESS_BYTES_MASK GENMASK(18, 17)
|
|
|
|
#define BFPT_DWORD1_ADDRESS_BYTES_3_ONLY (0x0UL << 17)
|
|
|
|
#define BFPT_DWORD1_ADDRESS_BYTES_3_OR_4 (0x1UL << 17)
|
|
|
|
#define BFPT_DWORD1_ADDRESS_BYTES_4_ONLY (0x2UL << 17)
|
|
|
|
#define BFPT_DWORD1_DTR BIT(19)
|
|
|
|
#define BFPT_DWORD1_FAST_READ_1_2_2 BIT(20)
|
|
|
|
#define BFPT_DWORD1_FAST_READ_1_4_4 BIT(21)
|
|
|
|
#define BFPT_DWORD1_FAST_READ_1_1_4 BIT(22)
|
|
|
|
|
|
|
|
/* 5th DWORD. */
|
|
|
|
#define BFPT_DWORD5_FAST_READ_2_2_2 BIT(0)
|
|
|
|
#define BFPT_DWORD5_FAST_READ_4_4_4 BIT(4)
|
|
|
|
|
|
|
|
/* 11th DWORD. */
|
|
|
|
#define BFPT_DWORD11_PAGE_SIZE_SHIFT 4
|
|
|
|
#define BFPT_DWORD11_PAGE_SIZE_MASK GENMASK(7, 4)
|
|
|
|
|
|
|
|
/* 15th DWORD. */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* (from JESD216 rev B)
|
|
|
|
* Quad Enable Requirements (QER):
|
|
|
|
* - 000b: Device does not have a QE bit. Device detects 1-1-4 and 1-4-4
|
|
|
|
* reads based on instruction. DQ3/HOLD# functions are hold during
|
|
|
|
* instruction phase.
|
|
|
|
* - 001b: QE is bit 1 of status register 2. It is set via Write Status with
|
|
|
|
* two data bytes where bit 1 of the second byte is one.
|
|
|
|
* [...]
|
|
|
|
* Writing only one byte to the status register has the side-effect of
|
|
|
|
* clearing status register 2, including the QE bit. The 100b code is
|
|
|
|
* used if writing one byte to the status register does not modify
|
|
|
|
* status register 2.
|
|
|
|
* - 010b: QE is bit 6 of status register 1. It is set via Write Status with
|
|
|
|
* one data byte where bit 6 is one.
|
|
|
|
* [...]
|
|
|
|
* - 011b: QE is bit 7 of status register 2. It is set via Write status
|
|
|
|
* register 2 instruction 3Eh with one data byte where bit 7 is one.
|
|
|
|
* [...]
|
|
|
|
* The status register 2 is read using instruction 3Fh.
|
|
|
|
* - 100b: QE is bit 1 of status register 2. It is set via Write Status with
|
|
|
|
* two data bytes where bit 1 of the second byte is one.
|
|
|
|
* [...]
|
|
|
|
* In contrast to the 001b code, writing one byte to the status
|
|
|
|
* register does not modify status register 2.
|
|
|
|
* - 101b: QE is bit 1 of status register 2. Status register 1 is read using
|
|
|
|
* Read Status instruction 05h. Status register2 is read using
|
|
|
|
* instruction 35h. QE is set via Writ Status instruction 01h with
|
|
|
|
* two data bytes where bit 1 of the second byte is one.
|
|
|
|
* [...]
|
|
|
|
*/
|
|
|
|
#define BFPT_DWORD15_QER_MASK GENMASK(22, 20)
|
|
|
|
#define BFPT_DWORD15_QER_NONE (0x0UL << 20) /* Micron */
|
|
|
|
#define BFPT_DWORD15_QER_SR2_BIT1_BUGGY (0x1UL << 20)
|
|
|
|
#define BFPT_DWORD15_QER_SR1_BIT6 (0x2UL << 20) /* Macronix */
|
|
|
|
#define BFPT_DWORD15_QER_SR2_BIT7 (0x3UL << 20)
|
|
|
|
#define BFPT_DWORD15_QER_SR2_BIT1_NO_RD (0x4UL << 20)
|
|
|
|
#define BFPT_DWORD15_QER_SR2_BIT1 (0x5UL << 20) /* Spansion */
|
|
|
|
|
|
|
|
struct sfdp_bfpt {
|
|
|
|
u32 dwords[BFPT_DWORD_MAX];
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Fast Read settings. */
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
spi_nor_set_read_settings_from_bfpt(struct spi_nor_read_command *read,
|
|
|
|
u16 half,
|
|
|
|
enum spi_nor_protocol proto)
|
|
|
|
{
|
|
|
|
read->num_mode_clocks = (half >> 5) & 0x07;
|
|
|
|
read->num_wait_states = (half >> 0) & 0x1f;
|
|
|
|
read->opcode = (half >> 8) & 0xff;
|
|
|
|
read->proto = proto;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct sfdp_bfpt_read {
|
|
|
|
/* The Fast Read x-y-z hardware capability in params->hwcaps.mask. */
|
|
|
|
u32 hwcaps;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The <supported_bit> bit in <supported_dword> BFPT DWORD tells us
|
|
|
|
* whether the Fast Read x-y-z command is supported.
|
|
|
|
*/
|
|
|
|
u32 supported_dword;
|
|
|
|
u32 supported_bit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The half-word at offset <setting_shift> in <setting_dword> BFPT DWORD
|
|
|
|
* encodes the op code, the number of mode clocks and the number of wait
|
|
|
|
* states to be used by Fast Read x-y-z command.
|
|
|
|
*/
|
|
|
|
u32 settings_dword;
|
|
|
|
u32 settings_shift;
|
|
|
|
|
|
|
|
/* The SPI protocol for this Fast Read x-y-z command. */
|
|
|
|
enum spi_nor_protocol proto;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct sfdp_bfpt_read sfdp_bfpt_reads[] = {
|
|
|
|
/* Fast Read 1-1-2 */
|
|
|
|
{
|
|
|
|
SNOR_HWCAPS_READ_1_1_2,
|
|
|
|
BFPT_DWORD(1), BIT(16), /* Supported bit */
|
|
|
|
BFPT_DWORD(4), 0, /* Settings */
|
|
|
|
SNOR_PROTO_1_1_2,
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Fast Read 1-2-2 */
|
|
|
|
{
|
|
|
|
SNOR_HWCAPS_READ_1_2_2,
|
|
|
|
BFPT_DWORD(1), BIT(20), /* Supported bit */
|
|
|
|
BFPT_DWORD(4), 16, /* Settings */
|
|
|
|
SNOR_PROTO_1_2_2,
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Fast Read 2-2-2 */
|
|
|
|
{
|
|
|
|
SNOR_HWCAPS_READ_2_2_2,
|
|
|
|
BFPT_DWORD(5), BIT(0), /* Supported bit */
|
|
|
|
BFPT_DWORD(6), 16, /* Settings */
|
|
|
|
SNOR_PROTO_2_2_2,
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Fast Read 1-1-4 */
|
|
|
|
{
|
|
|
|
SNOR_HWCAPS_READ_1_1_4,
|
|
|
|
BFPT_DWORD(1), BIT(22), /* Supported bit */
|
|
|
|
BFPT_DWORD(3), 16, /* Settings */
|
|
|
|
SNOR_PROTO_1_1_4,
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Fast Read 1-4-4 */
|
|
|
|
{
|
|
|
|
SNOR_HWCAPS_READ_1_4_4,
|
|
|
|
BFPT_DWORD(1), BIT(21), /* Supported bit */
|
|
|
|
BFPT_DWORD(3), 0, /* Settings */
|
|
|
|
SNOR_PROTO_1_4_4,
|
|
|
|
},
|
|
|
|
|
|
|
|
/* Fast Read 4-4-4 */
|
|
|
|
{
|
|
|
|
SNOR_HWCAPS_READ_4_4_4,
|
|
|
|
BFPT_DWORD(5), BIT(4), /* Supported bit */
|
|
|
|
BFPT_DWORD(7), 16, /* Settings */
|
|
|
|
SNOR_PROTO_4_4_4,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
struct sfdp_bfpt_erase {
|
|
|
|
/*
|
|
|
|
* The half-word at offset <shift> in DWORD <dwoard> encodes the
|
|
|
|
* op code and erase sector size to be used by Sector Erase commands.
|
|
|
|
*/
|
|
|
|
u32 dword;
|
|
|
|
u32 shift;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct sfdp_bfpt_erase sfdp_bfpt_erases[] = {
|
|
|
|
/* Erase Type 1 in DWORD8 bits[15:0] */
|
|
|
|
{BFPT_DWORD(8), 0},
|
|
|
|
|
|
|
|
/* Erase Type 2 in DWORD8 bits[31:16] */
|
|
|
|
{BFPT_DWORD(8), 16},
|
|
|
|
|
|
|
|
/* Erase Type 3 in DWORD9 bits[15:0] */
|
|
|
|
{BFPT_DWORD(9), 0},
|
|
|
|
|
|
|
|
/* Erase Type 4 in DWORD9 bits[31:16] */
|
|
|
|
{BFPT_DWORD(9), 16},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int spi_nor_hwcaps_read2cmd(u32 hwcaps);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* spi_nor_parse_bfpt() - read and parse the Basic Flash Parameter Table.
|
|
|
|
* @nor: pointer to a 'struct spi_nor'
|
|
|
|
* @bfpt_header: pointer to the 'struct sfdp_parameter_header' describing
|
|
|
|
* the Basic Flash Parameter Table length and version
|
|
|
|
* @params: pointer to the 'struct spi_nor_flash_parameter' to be
|
|
|
|
* filled
|
|
|
|
*
|
|
|
|
* The Basic Flash Parameter Table is the main and only mandatory table as
|
|
|
|
* defined by the SFDP (JESD216) specification.
|
|
|
|
* It provides us with the total size (memory density) of the data array and
|
|
|
|
* the number of address bytes for Fast Read, Page Program and Sector Erase
|
|
|
|
* commands.
|
|
|
|
* For Fast READ commands, it also gives the number of mode clock cycles and
|
|
|
|
* wait states (regrouped in the number of dummy clock cycles) for each
|
|
|
|
* supported instruction op code.
|
|
|
|
* For Page Program, the page size is now available since JESD216 rev A, however
|
|
|
|
* the supported instruction op codes are still not provided.
|
|
|
|
* For Sector Erase commands, this table stores the supported instruction op
|
|
|
|
* codes and the associated sector sizes.
|
|
|
|
* Finally, the Quad Enable Requirements (QER) are also available since JESD216
|
|
|
|
* rev A. The QER bits encode the manufacturer dependent procedure to be
|
|
|
|
* executed to set the Quad Enable (QE) bit in some internal register of the
|
|
|
|
* Quad SPI memory. Indeed the QE bit, when it exists, must be set before
|
|
|
|
* sending any Quad SPI command to the memory. Actually, setting the QE bit
|
|
|
|
* tells the memory to reassign its WP# and HOLD#/RESET# pins to functions IO2
|
|
|
|
* and IO3 hence enabling 4 (Quad) I/O lines.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -errno otherwise.
|
|
|
|
*/
|
|
|
|
static int spi_nor_parse_bfpt(struct spi_nor *nor,
|
|
|
|
const struct sfdp_parameter_header *bfpt_header,
|
|
|
|
struct spi_nor_flash_parameter *params)
|
|
|
|
{
|
|
|
|
struct mtd_info *mtd = &nor->mtd;
|
|
|
|
struct sfdp_bfpt bfpt;
|
|
|
|
size_t len;
|
|
|
|
int i, cmd, err;
|
|
|
|
u32 addr;
|
|
|
|
u16 half;
|
|
|
|
|
|
|
|
/* JESD216 Basic Flash Parameter Table length is at least 9 DWORDs. */
|
|
|
|
if (bfpt_header->length < BFPT_DWORD_MAX_JESD216)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Read the Basic Flash Parameter Table. */
|
|
|
|
len = min_t(size_t, sizeof(bfpt),
|
|
|
|
bfpt_header->length * sizeof(u32));
|
|
|
|
addr = SFDP_PARAM_HEADER_PTP(bfpt_header);
|
|
|
|
memset(&bfpt, 0, sizeof(bfpt));
|
2017-09-07 05:45:02 +08:00
|
|
|
err = spi_nor_read_sfdp_dma_unsafe(nor, addr, len, &bfpt);
|
2017-06-26 21:10:00 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* Fix endianness of the BFPT DWORDs. */
|
|
|
|
for (i = 0; i < BFPT_DWORD_MAX; i++)
|
|
|
|
bfpt.dwords[i] = le32_to_cpu(bfpt.dwords[i]);
|
|
|
|
|
|
|
|
/* Number of address bytes. */
|
|
|
|
switch (bfpt.dwords[BFPT_DWORD(1)] & BFPT_DWORD1_ADDRESS_BYTES_MASK) {
|
|
|
|
case BFPT_DWORD1_ADDRESS_BYTES_3_ONLY:
|
|
|
|
nor->addr_width = 3;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BFPT_DWORD1_ADDRESS_BYTES_4_ONLY:
|
|
|
|
nor->addr_width = 4;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Flash Memory Density (in bits). */
|
|
|
|
params->size = bfpt.dwords[BFPT_DWORD(2)];
|
|
|
|
if (params->size & BIT(31)) {
|
|
|
|
params->size &= ~BIT(31);
|
2017-09-12 21:10:35 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Prevent overflows on params->size. Anyway, a NOR of 2^64
|
|
|
|
* bits is unlikely to exist so this error probably means
|
|
|
|
* the BFPT we are reading is corrupted/wrong.
|
|
|
|
*/
|
|
|
|
if (params->size > 63)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
params->size = 1ULL << params->size;
|
|
|
|
} else {
|
|
|
|
params->size++;
|
|
|
|
}
|
|
|
|
params->size >>= 3; /* Convert to bytes. */
|
|
|
|
|
|
|
|
/* Fast Read settings. */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(sfdp_bfpt_reads); i++) {
|
|
|
|
const struct sfdp_bfpt_read *rd = &sfdp_bfpt_reads[i];
|
|
|
|
struct spi_nor_read_command *read;
|
|
|
|
|
|
|
|
if (!(bfpt.dwords[rd->supported_dword] & rd->supported_bit)) {
|
|
|
|
params->hwcaps.mask &= ~rd->hwcaps;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
params->hwcaps.mask |= rd->hwcaps;
|
|
|
|
cmd = spi_nor_hwcaps_read2cmd(rd->hwcaps);
|
|
|
|
read = ¶ms->reads[cmd];
|
|
|
|
half = bfpt.dwords[rd->settings_dword] >> rd->settings_shift;
|
|
|
|
spi_nor_set_read_settings_from_bfpt(read, half, rd->proto);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Sector Erase settings. */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(sfdp_bfpt_erases); i++) {
|
|
|
|
const struct sfdp_bfpt_erase *er = &sfdp_bfpt_erases[i];
|
|
|
|
u32 erasesize;
|
|
|
|
u8 opcode;
|
|
|
|
|
|
|
|
half = bfpt.dwords[er->dword] >> er->shift;
|
|
|
|
erasesize = half & 0xff;
|
|
|
|
|
|
|
|
/* erasesize == 0 means this Erase Type is not supported. */
|
|
|
|
if (!erasesize)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
erasesize = 1U << erasesize;
|
|
|
|
opcode = (half >> 8) & 0xff;
|
|
|
|
#ifdef CONFIG_MTD_SPI_NOR_USE_4K_SECTORS
|
|
|
|
if (erasesize == SZ_4K) {
|
|
|
|
nor->erase_opcode = opcode;
|
|
|
|
mtd->erasesize = erasesize;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (!mtd->erasesize || mtd->erasesize < erasesize) {
|
|
|
|
nor->erase_opcode = opcode;
|
|
|
|
mtd->erasesize = erasesize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Stop here if not JESD216 rev A or later. */
|
|
|
|
if (bfpt_header->length < BFPT_DWORD_MAX)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Page size: this field specifies 'N' so the page size = 2^N bytes. */
|
|
|
|
params->page_size = bfpt.dwords[BFPT_DWORD(11)];
|
|
|
|
params->page_size &= BFPT_DWORD11_PAGE_SIZE_MASK;
|
|
|
|
params->page_size >>= BFPT_DWORD11_PAGE_SIZE_SHIFT;
|
|
|
|
params->page_size = 1U << params->page_size;
|
|
|
|
|
|
|
|
/* Quad Enable Requirements. */
|
|
|
|
switch (bfpt.dwords[BFPT_DWORD(15)] & BFPT_DWORD15_QER_MASK) {
|
|
|
|
case BFPT_DWORD15_QER_NONE:
|
|
|
|
params->quad_enable = NULL;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BFPT_DWORD15_QER_SR2_BIT1_BUGGY:
|
|
|
|
case BFPT_DWORD15_QER_SR2_BIT1_NO_RD:
|
|
|
|
params->quad_enable = spansion_no_read_cr_quad_enable;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BFPT_DWORD15_QER_SR1_BIT6:
|
|
|
|
params->quad_enable = macronix_quad_enable;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BFPT_DWORD15_QER_SR2_BIT7:
|
|
|
|
params->quad_enable = sr2_bit7_quad_enable;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BFPT_DWORD15_QER_SR2_BIT1:
|
|
|
|
params->quad_enable = spansion_read_cr_quad_enable;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* spi_nor_parse_sfdp() - parse the Serial Flash Discoverable Parameters.
|
|
|
|
* @nor: pointer to a 'struct spi_nor'
|
|
|
|
* @params: pointer to the 'struct spi_nor_flash_parameter' to be
|
|
|
|
* filled
|
|
|
|
*
|
|
|
|
* The Serial Flash Discoverable Parameters are described by the JEDEC JESD216
|
|
|
|
* specification. This is a standard which tends to supported by almost all
|
|
|
|
* (Q)SPI memory manufacturers. Those hard-coded tables allow us to learn at
|
|
|
|
* runtime the main parameters needed to perform basic SPI flash operations such
|
|
|
|
* as Fast Read, Page Program or Sector Erase commands.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -errno otherwise.
|
|
|
|
*/
|
|
|
|
static int spi_nor_parse_sfdp(struct spi_nor *nor,
|
|
|
|
struct spi_nor_flash_parameter *params)
|
|
|
|
{
|
|
|
|
const struct sfdp_parameter_header *param_header, *bfpt_header;
|
|
|
|
struct sfdp_parameter_header *param_headers = NULL;
|
|
|
|
struct sfdp_header header;
|
|
|
|
struct device *dev = nor->dev;
|
|
|
|
size_t psize;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
/* Get the SFDP header. */
|
2017-09-07 05:45:02 +08:00
|
|
|
err = spi_nor_read_sfdp_dma_unsafe(nor, 0, sizeof(header), &header);
|
2017-06-26 21:10:00 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* Check the SFDP header version. */
|
|
|
|
if (le32_to_cpu(header.signature) != SFDP_SIGNATURE ||
|
2017-09-17 22:13:52 +08:00
|
|
|
header.major != SFDP_JESD216_MAJOR)
|
2017-06-26 21:10:00 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify that the first and only mandatory parameter header is a
|
|
|
|
* Basic Flash Parameter Table header as specified in JESD216.
|
|
|
|
*/
|
|
|
|
bfpt_header = &header.bfpt_header;
|
|
|
|
if (SFDP_PARAM_HEADER_ID(bfpt_header) != SFDP_BFPT_ID ||
|
|
|
|
bfpt_header->major != SFDP_JESD216_MAJOR)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate memory then read all parameter headers with a single
|
|
|
|
* Read SFDP command. These parameter headers will actually be parsed
|
|
|
|
* twice: a first time to get the latest revision of the basic flash
|
|
|
|
* parameter table, then a second time to handle the supported optional
|
|
|
|
* tables.
|
|
|
|
* Hence we read the parameter headers once for all to reduce the
|
|
|
|
* processing time. Also we use kmalloc() instead of devm_kmalloc()
|
|
|
|
* because we don't need to keep these parameter headers: the allocated
|
|
|
|
* memory is always released with kfree() before exiting this function.
|
|
|
|
*/
|
|
|
|
if (header.nph) {
|
|
|
|
psize = header.nph * sizeof(*param_headers);
|
|
|
|
|
|
|
|
param_headers = kmalloc(psize, GFP_KERNEL);
|
|
|
|
if (!param_headers)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
err = spi_nor_read_sfdp(nor, sizeof(header),
|
|
|
|
psize, param_headers);
|
|
|
|
if (err < 0) {
|
|
|
|
dev_err(dev, "failed to read SFDP parameter headers\n");
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check other parameter headers to get the latest revision of
|
|
|
|
* the basic flash parameter table.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < header.nph; i++) {
|
|
|
|
param_header = ¶m_headers[i];
|
|
|
|
|
|
|
|
if (SFDP_PARAM_HEADER_ID(param_header) == SFDP_BFPT_ID &&
|
|
|
|
param_header->major == SFDP_JESD216_MAJOR &&
|
|
|
|
(param_header->minor > bfpt_header->minor ||
|
|
|
|
(param_header->minor == bfpt_header->minor &&
|
|
|
|
param_header->length > bfpt_header->length)))
|
|
|
|
bfpt_header = param_header;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = spi_nor_parse_bfpt(nor, bfpt_header, params);
|
|
|
|
if (err)
|
|
|
|
goto exit;
|
|
|
|
|
|
|
|
/* Parse other parameter headers. */
|
|
|
|
for (i = 0; i < header.nph; i++) {
|
|
|
|
param_header = ¶m_headers[i];
|
|
|
|
|
|
|
|
switch (SFDP_PARAM_HEADER_ID(param_header)) {
|
|
|
|
case SFDP_SECTOR_MAP_ID:
|
|
|
|
dev_info(dev, "non-uniform erase sector maps are not supported yet.\n");
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
|
|
|
kfree(param_headers);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
static int spi_nor_init_params(struct spi_nor *nor,
|
|
|
|
const struct flash_info *info,
|
|
|
|
struct spi_nor_flash_parameter *params)
|
|
|
|
{
|
|
|
|
/* Set legacy flash parameters as default. */
|
|
|
|
memset(params, 0, sizeof(*params));
|
|
|
|
|
|
|
|
/* Set SPI NOR sizes. */
|
|
|
|
params->size = info->sector_size * info->n_sectors;
|
|
|
|
params->page_size = info->page_size;
|
|
|
|
|
|
|
|
/* (Fast) Read settings. */
|
|
|
|
params->hwcaps.mask |= SNOR_HWCAPS_READ;
|
|
|
|
spi_nor_set_read_settings(¶ms->reads[SNOR_CMD_READ],
|
|
|
|
0, 0, SPINOR_OP_READ,
|
|
|
|
SNOR_PROTO_1_1_1);
|
|
|
|
|
|
|
|
if (!(info->flags & SPI_NOR_NO_FR)) {
|
|
|
|
params->hwcaps.mask |= SNOR_HWCAPS_READ_FAST;
|
|
|
|
spi_nor_set_read_settings(¶ms->reads[SNOR_CMD_READ_FAST],
|
|
|
|
0, 8, SPINOR_OP_READ_FAST,
|
|
|
|
SNOR_PROTO_1_1_1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info->flags & SPI_NOR_DUAL_READ) {
|
|
|
|
params->hwcaps.mask |= SNOR_HWCAPS_READ_1_1_2;
|
|
|
|
spi_nor_set_read_settings(¶ms->reads[SNOR_CMD_READ_1_1_2],
|
|
|
|
0, 8, SPINOR_OP_READ_1_1_2,
|
|
|
|
SNOR_PROTO_1_1_2);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info->flags & SPI_NOR_QUAD_READ) {
|
|
|
|
params->hwcaps.mask |= SNOR_HWCAPS_READ_1_1_4;
|
|
|
|
spi_nor_set_read_settings(¶ms->reads[SNOR_CMD_READ_1_1_4],
|
|
|
|
0, 8, SPINOR_OP_READ_1_1_4,
|
|
|
|
SNOR_PROTO_1_1_4);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Page Program settings. */
|
|
|
|
params->hwcaps.mask |= SNOR_HWCAPS_PP;
|
|
|
|
spi_nor_set_pp_settings(¶ms->page_programs[SNOR_CMD_PP],
|
|
|
|
SPINOR_OP_PP, SNOR_PROTO_1_1_1);
|
|
|
|
|
|
|
|
/* Select the procedure to set the Quad Enable bit. */
|
|
|
|
if (params->hwcaps.mask & (SNOR_HWCAPS_READ_QUAD |
|
|
|
|
SNOR_HWCAPS_PP_QUAD)) {
|
|
|
|
switch (JEDEC_MFR(info)) {
|
|
|
|
case SNOR_MFR_MACRONIX:
|
|
|
|
params->quad_enable = macronix_quad_enable;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SNOR_MFR_MICRON:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2017-06-26 21:10:00 +08:00
|
|
|
/* Kept only for backward compatibility purpose. */
|
2017-04-26 04:08:46 +08:00
|
|
|
params->quad_enable = spansion_quad_enable;
|
|
|
|
break;
|
|
|
|
}
|
2017-08-28 09:58:29 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Some manufacturer like GigaDevice may use different
|
|
|
|
* bit to set QE on different memories, so the MFR can't
|
|
|
|
* indicate the quad_enable method for this case, we need
|
|
|
|
* set it in flash info list.
|
|
|
|
*/
|
|
|
|
if (info->quad_enable)
|
|
|
|
params->quad_enable = info->quad_enable;
|
2017-04-26 04:08:46 +08:00
|
|
|
}
|
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
/* Override the parameters with data read from SFDP tables. */
|
|
|
|
nor->addr_width = 0;
|
|
|
|
nor->mtd.erasesize = 0;
|
|
|
|
if ((info->flags & (SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ)) &&
|
|
|
|
!(info->flags & SPI_NOR_SKIP_SFDP)) {
|
|
|
|
struct spi_nor_flash_parameter sfdp_params;
|
|
|
|
|
|
|
|
memcpy(&sfdp_params, params, sizeof(sfdp_params));
|
|
|
|
if (spi_nor_parse_sfdp(nor, &sfdp_params)) {
|
|
|
|
nor->addr_width = 0;
|
|
|
|
nor->mtd.erasesize = 0;
|
|
|
|
} else {
|
|
|
|
memcpy(params, &sfdp_params, sizeof(*params));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_hwcaps2cmd(u32 hwcaps, const int table[][2], size_t size)
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++)
|
|
|
|
if (table[i][0] == (int)hwcaps)
|
|
|
|
return table[i][1];
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_hwcaps_read2cmd(u32 hwcaps)
|
|
|
|
{
|
|
|
|
static const int hwcaps_read2cmd[][2] = {
|
|
|
|
{ SNOR_HWCAPS_READ, SNOR_CMD_READ },
|
|
|
|
{ SNOR_HWCAPS_READ_FAST, SNOR_CMD_READ_FAST },
|
2017-04-26 04:08:48 +08:00
|
|
|
{ SNOR_HWCAPS_READ_1_1_1_DTR, SNOR_CMD_READ_1_1_1_DTR },
|
2017-04-26 04:08:46 +08:00
|
|
|
{ SNOR_HWCAPS_READ_1_1_2, SNOR_CMD_READ_1_1_2 },
|
|
|
|
{ SNOR_HWCAPS_READ_1_2_2, SNOR_CMD_READ_1_2_2 },
|
|
|
|
{ SNOR_HWCAPS_READ_2_2_2, SNOR_CMD_READ_2_2_2 },
|
2017-04-26 04:08:48 +08:00
|
|
|
{ SNOR_HWCAPS_READ_1_2_2_DTR, SNOR_CMD_READ_1_2_2_DTR },
|
2017-04-26 04:08:46 +08:00
|
|
|
{ SNOR_HWCAPS_READ_1_1_4, SNOR_CMD_READ_1_1_4 },
|
|
|
|
{ SNOR_HWCAPS_READ_1_4_4, SNOR_CMD_READ_1_4_4 },
|
|
|
|
{ SNOR_HWCAPS_READ_4_4_4, SNOR_CMD_READ_4_4_4 },
|
2017-04-26 04:08:48 +08:00
|
|
|
{ SNOR_HWCAPS_READ_1_4_4_DTR, SNOR_CMD_READ_1_4_4_DTR },
|
2017-04-26 04:08:49 +08:00
|
|
|
{ SNOR_HWCAPS_READ_1_1_8, SNOR_CMD_READ_1_1_8 },
|
|
|
|
{ SNOR_HWCAPS_READ_1_8_8, SNOR_CMD_READ_1_8_8 },
|
|
|
|
{ SNOR_HWCAPS_READ_8_8_8, SNOR_CMD_READ_8_8_8 },
|
|
|
|
{ SNOR_HWCAPS_READ_1_8_8_DTR, SNOR_CMD_READ_1_8_8_DTR },
|
2017-04-26 04:08:46 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
return spi_nor_hwcaps2cmd(hwcaps, hwcaps_read2cmd,
|
|
|
|
ARRAY_SIZE(hwcaps_read2cmd));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_hwcaps_pp2cmd(u32 hwcaps)
|
|
|
|
{
|
|
|
|
static const int hwcaps_pp2cmd[][2] = {
|
|
|
|
{ SNOR_HWCAPS_PP, SNOR_CMD_PP },
|
|
|
|
{ SNOR_HWCAPS_PP_1_1_4, SNOR_CMD_PP_1_1_4 },
|
|
|
|
{ SNOR_HWCAPS_PP_1_4_4, SNOR_CMD_PP_1_4_4 },
|
|
|
|
{ SNOR_HWCAPS_PP_4_4_4, SNOR_CMD_PP_4_4_4 },
|
2017-04-26 04:08:49 +08:00
|
|
|
{ SNOR_HWCAPS_PP_1_1_8, SNOR_CMD_PP_1_1_8 },
|
|
|
|
{ SNOR_HWCAPS_PP_1_8_8, SNOR_CMD_PP_1_8_8 },
|
|
|
|
{ SNOR_HWCAPS_PP_8_8_8, SNOR_CMD_PP_8_8_8 },
|
2017-04-26 04:08:46 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
return spi_nor_hwcaps2cmd(hwcaps, hwcaps_pp2cmd,
|
|
|
|
ARRAY_SIZE(hwcaps_pp2cmd));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_select_read(struct spi_nor *nor,
|
|
|
|
const struct spi_nor_flash_parameter *params,
|
|
|
|
u32 shared_hwcaps)
|
|
|
|
{
|
|
|
|
int cmd, best_match = fls(shared_hwcaps & SNOR_HWCAPS_READ_MASK) - 1;
|
|
|
|
const struct spi_nor_read_command *read;
|
|
|
|
|
|
|
|
if (best_match < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
cmd = spi_nor_hwcaps_read2cmd(BIT(best_match));
|
|
|
|
if (cmd < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
read = ¶ms->reads[cmd];
|
|
|
|
nor->read_opcode = read->opcode;
|
|
|
|
nor->read_proto = read->proto;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the spi-nor framework, we don't need to make the difference
|
|
|
|
* between mode clock cycles and wait state clock cycles.
|
|
|
|
* Indeed, the value of the mode clock cycles is used by a QSPI
|
|
|
|
* flash memory to know whether it should enter or leave its 0-4-4
|
|
|
|
* (Continuous Read / XIP) mode.
|
|
|
|
* eXecution In Place is out of the scope of the mtd sub-system.
|
|
|
|
* Hence we choose to merge both mode and wait state clock cycles
|
|
|
|
* into the so called dummy clock cycles.
|
|
|
|
*/
|
|
|
|
nor->read_dummy = read->num_mode_clocks + read->num_wait_states;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_select_pp(struct spi_nor *nor,
|
|
|
|
const struct spi_nor_flash_parameter *params,
|
|
|
|
u32 shared_hwcaps)
|
|
|
|
{
|
|
|
|
int cmd, best_match = fls(shared_hwcaps & SNOR_HWCAPS_PP_MASK) - 1;
|
|
|
|
const struct spi_nor_pp_command *pp;
|
|
|
|
|
|
|
|
if (best_match < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
cmd = spi_nor_hwcaps_pp2cmd(BIT(best_match));
|
|
|
|
if (cmd < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
pp = ¶ms->page_programs[cmd];
|
|
|
|
nor->program_opcode = pp->opcode;
|
|
|
|
nor->write_proto = pp->proto;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_select_erase(struct spi_nor *nor,
|
|
|
|
const struct flash_info *info)
|
|
|
|
{
|
|
|
|
struct mtd_info *mtd = &nor->mtd;
|
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
/* Do nothing if already configured from SFDP. */
|
|
|
|
if (mtd->erasesize)
|
|
|
|
return 0;
|
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
#ifdef CONFIG_MTD_SPI_NOR_USE_4K_SECTORS
|
|
|
|
/* prefer "small sector" erase if possible */
|
|
|
|
if (info->flags & SECT_4K) {
|
|
|
|
nor->erase_opcode = SPINOR_OP_BE_4K;
|
|
|
|
mtd->erasesize = 4096;
|
|
|
|
} else if (info->flags & SECT_4K_PMC) {
|
|
|
|
nor->erase_opcode = SPINOR_OP_BE_4K_PMC;
|
|
|
|
mtd->erasesize = 4096;
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
nor->erase_opcode = SPINOR_OP_SE;
|
|
|
|
mtd->erasesize = info->sector_size;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_setup(struct spi_nor *nor, const struct flash_info *info,
|
|
|
|
const struct spi_nor_flash_parameter *params,
|
|
|
|
const struct spi_nor_hwcaps *hwcaps)
|
|
|
|
{
|
|
|
|
u32 ignored_mask, shared_mask;
|
|
|
|
bool enable_quad_io;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Keep only the hardware capabilities supported by both the SPI
|
|
|
|
* controller and the SPI flash memory.
|
|
|
|
*/
|
|
|
|
shared_mask = hwcaps->mask & params->hwcaps.mask;
|
|
|
|
|
|
|
|
/* SPI n-n-n protocols are not supported yet. */
|
|
|
|
ignored_mask = (SNOR_HWCAPS_READ_2_2_2 |
|
|
|
|
SNOR_HWCAPS_READ_4_4_4 |
|
2017-04-26 04:08:49 +08:00
|
|
|
SNOR_HWCAPS_READ_8_8_8 |
|
|
|
|
SNOR_HWCAPS_PP_4_4_4 |
|
|
|
|
SNOR_HWCAPS_PP_8_8_8);
|
2017-04-26 04:08:46 +08:00
|
|
|
if (shared_mask & ignored_mask) {
|
|
|
|
dev_dbg(nor->dev,
|
|
|
|
"SPI n-n-n protocols are not supported yet.\n");
|
|
|
|
shared_mask &= ~ignored_mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Select the (Fast) Read command. */
|
|
|
|
err = spi_nor_select_read(nor, params, shared_mask);
|
|
|
|
if (err) {
|
|
|
|
dev_err(nor->dev,
|
|
|
|
"can't select read settings supported by both the SPI controller and memory.\n");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Select the Page Program command. */
|
|
|
|
err = spi_nor_select_pp(nor, params, shared_mask);
|
|
|
|
if (err) {
|
|
|
|
dev_err(nor->dev,
|
|
|
|
"can't select write settings supported by both the SPI controller and memory.\n");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Select the Sector Erase command. */
|
|
|
|
err = spi_nor_select_erase(nor, info);
|
|
|
|
if (err) {
|
|
|
|
dev_err(nor->dev,
|
|
|
|
"can't select erase settings supported by both the SPI controller and memory.\n");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable Quad I/O if needed. */
|
|
|
|
enable_quad_io = (spi_nor_get_protocol_width(nor->read_proto) == 4 ||
|
|
|
|
spi_nor_get_protocol_width(nor->write_proto) == 4);
|
2017-08-23 04:45:21 +08:00
|
|
|
if (enable_quad_io && params->quad_enable)
|
|
|
|
nor->quad_enable = params->quad_enable;
|
|
|
|
else
|
|
|
|
nor->quad_enable = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int spi_nor_init(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Atmel, SST, Intel/Numonyx, and others serial NOR tend to power up
|
|
|
|
* with the software protection bits set
|
|
|
|
*/
|
|
|
|
if (JEDEC_MFR(nor->info) == SNOR_MFR_ATMEL ||
|
|
|
|
JEDEC_MFR(nor->info) == SNOR_MFR_INTEL ||
|
|
|
|
JEDEC_MFR(nor->info) == SNOR_MFR_SST ||
|
|
|
|
nor->info->flags & SPI_NOR_HAS_LOCK) {
|
|
|
|
write_enable(nor);
|
|
|
|
write_sr(nor, 0);
|
|
|
|
spi_nor_wait_till_ready(nor);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nor->quad_enable) {
|
|
|
|
err = nor->quad_enable(nor);
|
2017-04-26 04:08:46 +08:00
|
|
|
if (err) {
|
|
|
|
dev_err(nor->dev, "quad mode not supported\n");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-23 04:45:21 +08:00
|
|
|
if ((nor->addr_width == 4) &&
|
|
|
|
(JEDEC_MFR(nor->info) != SNOR_MFR_SPANSION) &&
|
mtd: spi-nor: only apply reset hacks to broken hardware
Commit 59b356ffd0b0 ("mtd: m25p80: restore the status of SPI flash when
exiting") is the latest from a long history of attempts to add reboot
handling to handle stateful addressing modes on SPI flash. Some prior
mostly-related discussions:
http://lists.infradead.org/pipermail/linux-mtd/2013-March/046343.html
[PATCH 1/3] mtd: m25p80: utilize dedicated 4-byte addressing commands
http://lists.infradead.org/pipermail/barebox/2014-September/020682.html
[RFC] MTD m25p80 3-byte addressing and boot problem
http://lists.infradead.org/pipermail/linux-mtd/2015-February/057683.html
[PATCH 2/2] m25p80: if supported put chip to deep power down if not used
Previously, attempts to add reboot-time software reset handling were
rejected, but the latest attempt was not.
Quick summary of the problem:
Some systems (e.g., boot ROM or bootloader) assume that they can read
initial boot code from their SPI flash using 3-byte addressing. If the
flash is left in 4-byte mode after reset, these systems won't boot. The
above patch provided a shutdown/remove hook to attempt to reset the
addressing mode before we reboot. Notably, this patch misses out on
huge classes of unexpected reboots (e.g., crashes, watchdog resets).
Unfortunately, it is essentially impossible to solve this problem 100%:
if your system doesn't know how to reset the SPI flash to power-on
defaults at initialization time, no amount of software can really rescue
you -- there will always be a chance of some unexpected reset that
leaves your flash in an addressing mode that your boot sequence didn't
expect.
While it is not directly harmful to perform hacks like the
aforementioned commit on all 4-byte addressing flash, a
properly-designed system should not need the hack -- and in fact,
providing this hack may mask the fact that a given system is indeed
broken. So this patch attempts to apply this unsound hack more narrowly,
providing a strong suggestion to developers and system designers that
this is truly a hack. With luck, system designers can catch their errors
early on in their development cycle, rather than applying this hack long
term. But apparently enough systems are out in the wild that we still
have to provide this hack.
Document a new device tree property to denote systems that do not have a
proper hardware (or software) reset mechanism, and apply the hack (with
a loud warning) only in this case.
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Boris Brezillon <boris.brezillon@bootlin.com>
2018-07-28 02:33:13 +08:00
|
|
|
!(nor->info->flags & SPI_NOR_4B_OPCODES)) {
|
|
|
|
/*
|
|
|
|
* If the RESET# pin isn't hooked up properly, or the system
|
|
|
|
* otherwise doesn't perform a reset command in the boot
|
|
|
|
* sequence, it's impossible to 100% protect against unexpected
|
|
|
|
* reboots (e.g., crashes). Warn the user (or hopefully, system
|
|
|
|
* designer) that this is bad.
|
|
|
|
*/
|
|
|
|
WARN_ONCE(nor->flags & SNOR_F_BROKEN_RESET,
|
|
|
|
"enabling reset hack; may not recover from unexpected reboots\n");
|
2017-08-23 04:45:21 +08:00
|
|
|
set_4byte(nor, nor->info, 1);
|
mtd: spi-nor: only apply reset hacks to broken hardware
Commit 59b356ffd0b0 ("mtd: m25p80: restore the status of SPI flash when
exiting") is the latest from a long history of attempts to add reboot
handling to handle stateful addressing modes on SPI flash. Some prior
mostly-related discussions:
http://lists.infradead.org/pipermail/linux-mtd/2013-March/046343.html
[PATCH 1/3] mtd: m25p80: utilize dedicated 4-byte addressing commands
http://lists.infradead.org/pipermail/barebox/2014-September/020682.html
[RFC] MTD m25p80 3-byte addressing and boot problem
http://lists.infradead.org/pipermail/linux-mtd/2015-February/057683.html
[PATCH 2/2] m25p80: if supported put chip to deep power down if not used
Previously, attempts to add reboot-time software reset handling were
rejected, but the latest attempt was not.
Quick summary of the problem:
Some systems (e.g., boot ROM or bootloader) assume that they can read
initial boot code from their SPI flash using 3-byte addressing. If the
flash is left in 4-byte mode after reset, these systems won't boot. The
above patch provided a shutdown/remove hook to attempt to reset the
addressing mode before we reboot. Notably, this patch misses out on
huge classes of unexpected reboots (e.g., crashes, watchdog resets).
Unfortunately, it is essentially impossible to solve this problem 100%:
if your system doesn't know how to reset the SPI flash to power-on
defaults at initialization time, no amount of software can really rescue
you -- there will always be a chance of some unexpected reset that
leaves your flash in an addressing mode that your boot sequence didn't
expect.
While it is not directly harmful to perform hacks like the
aforementioned commit on all 4-byte addressing flash, a
properly-designed system should not need the hack -- and in fact,
providing this hack may mask the fact that a given system is indeed
broken. So this patch attempts to apply this unsound hack more narrowly,
providing a strong suggestion to developers and system designers that
this is truly a hack. With luck, system designers can catch their errors
early on in their development cycle, rather than applying this hack long
term. But apparently enough systems are out in the wild that we still
have to provide this hack.
Document a new device tree property to denote systems that do not have a
proper hardware (or software) reset mechanism, and apply the hack (with
a loud warning) only in this case.
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Boris Brezillon <boris.brezillon@bootlin.com>
2018-07-28 02:33:13 +08:00
|
|
|
}
|
2017-08-23 04:45:21 +08:00
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-08-23 04:45:22 +08:00
|
|
|
/* mtd resume handler */
|
|
|
|
static void spi_nor_resume(struct mtd_info *mtd)
|
|
|
|
{
|
|
|
|
struct spi_nor *nor = mtd_to_spi_nor(mtd);
|
|
|
|
struct device *dev = nor->dev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* re-initialize the nor chip */
|
|
|
|
ret = spi_nor_init(nor);
|
|
|
|
if (ret)
|
|
|
|
dev_err(dev, "resume() failed\n");
|
|
|
|
}
|
|
|
|
|
2017-12-06 10:53:41 +08:00
|
|
|
void spi_nor_restore(struct spi_nor *nor)
|
|
|
|
{
|
|
|
|
/* restore the addressing mode */
|
|
|
|
if ((nor->addr_width == 4) &&
|
|
|
|
(JEDEC_MFR(nor->info) != SNOR_MFR_SPANSION) &&
|
mtd: spi-nor: only apply reset hacks to broken hardware
Commit 59b356ffd0b0 ("mtd: m25p80: restore the status of SPI flash when
exiting") is the latest from a long history of attempts to add reboot
handling to handle stateful addressing modes on SPI flash. Some prior
mostly-related discussions:
http://lists.infradead.org/pipermail/linux-mtd/2013-March/046343.html
[PATCH 1/3] mtd: m25p80: utilize dedicated 4-byte addressing commands
http://lists.infradead.org/pipermail/barebox/2014-September/020682.html
[RFC] MTD m25p80 3-byte addressing and boot problem
http://lists.infradead.org/pipermail/linux-mtd/2015-February/057683.html
[PATCH 2/2] m25p80: if supported put chip to deep power down if not used
Previously, attempts to add reboot-time software reset handling were
rejected, but the latest attempt was not.
Quick summary of the problem:
Some systems (e.g., boot ROM or bootloader) assume that they can read
initial boot code from their SPI flash using 3-byte addressing. If the
flash is left in 4-byte mode after reset, these systems won't boot. The
above patch provided a shutdown/remove hook to attempt to reset the
addressing mode before we reboot. Notably, this patch misses out on
huge classes of unexpected reboots (e.g., crashes, watchdog resets).
Unfortunately, it is essentially impossible to solve this problem 100%:
if your system doesn't know how to reset the SPI flash to power-on
defaults at initialization time, no amount of software can really rescue
you -- there will always be a chance of some unexpected reset that
leaves your flash in an addressing mode that your boot sequence didn't
expect.
While it is not directly harmful to perform hacks like the
aforementioned commit on all 4-byte addressing flash, a
properly-designed system should not need the hack -- and in fact,
providing this hack may mask the fact that a given system is indeed
broken. So this patch attempts to apply this unsound hack more narrowly,
providing a strong suggestion to developers and system designers that
this is truly a hack. With luck, system designers can catch their errors
early on in their development cycle, rather than applying this hack long
term. But apparently enough systems are out in the wild that we still
have to provide this hack.
Document a new device tree property to denote systems that do not have a
proper hardware (or software) reset mechanism, and apply the hack (with
a loud warning) only in this case.
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Boris Brezillon <boris.brezillon@bootlin.com>
2018-07-28 02:33:13 +08:00
|
|
|
!(nor->info->flags & SPI_NOR_4B_OPCODES) &&
|
|
|
|
(nor->flags & SNOR_F_BROKEN_RESET))
|
2017-12-06 10:53:41 +08:00
|
|
|
set_4byte(nor, nor->info, 0);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(spi_nor_restore);
|
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
int spi_nor_scan(struct spi_nor *nor, const char *name,
|
|
|
|
const struct spi_nor_hwcaps *hwcaps)
|
2014-02-24 18:37:37 +08:00
|
|
|
{
|
2017-04-26 04:08:46 +08:00
|
|
|
struct spi_nor_flash_parameter params;
|
2015-08-11 03:39:03 +08:00
|
|
|
const struct flash_info *info = NULL;
|
2014-02-24 18:37:37 +08:00
|
|
|
struct device *dev = nor->dev;
|
2015-08-14 06:46:05 +08:00
|
|
|
struct mtd_info *mtd = &nor->mtd;
|
2015-10-31 11:33:24 +08:00
|
|
|
struct device_node *np = spi_nor_get_flash_node(nor);
|
2014-02-24 18:37:37 +08:00
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ret = spi_nor_check(nor);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
/* Reset SPI protocol for all commands. */
|
|
|
|
nor->reg_proto = SNOR_PROTO_1_1_1;
|
|
|
|
nor->read_proto = SNOR_PROTO_1_1_1;
|
|
|
|
nor->write_proto = SNOR_PROTO_1_1_1;
|
|
|
|
|
mtd: m25p80: allow arbitrary OF matching for "jedec,spi-nor"
When we added the "jedec,spi-nor" compatible string for use in this
driver, we added it as a modalias option. The modalias can be derived in
different ways for platform devices vs. device tree (of_*) matching. But
for device tree matching (the primary target of this identifier string),
the modalias is determined from the first entry in the 'compatible'
property. IOW, the following properties would bind to this driver:
// Option (a), modalias = "spi-nor"
compatible = "jedec,spi-nor";
// Option (b), modalias = "spi-nor"
compatible = "idontknowwhatimdoing,spi-nor";
But the following would not:
// Option (c), modalias = "shinynewdevice"
compatible = "myvendor,shinynewdevice", "jedec,spi-nor";
So, we'd like to match (a) and (c) (even when we don't have an explicit
entry for "shinynewdevice"), and we'd rather not allow (b).
To do this, we
(1) always (for devices without specific platform data) pass the
modalias to the spi-nor library;
(2) rework the spi-nor library to not reject "bad" names, and
instead just fall back to autodetection; and
(3) add the .of_match_table to properly catch all "jedec,spi-nor".
This allows (a) and (c) without warnings, and rejects (b).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-05-20 05:38:22 +08:00
|
|
|
if (name)
|
2015-08-11 03:39:03 +08:00
|
|
|
info = spi_nor_match_id(name);
|
mtd: m25p80: allow arbitrary OF matching for "jedec,spi-nor"
When we added the "jedec,spi-nor" compatible string for use in this
driver, we added it as a modalias option. The modalias can be derived in
different ways for platform devices vs. device tree (of_*) matching. But
for device tree matching (the primary target of this identifier string),
the modalias is determined from the first entry in the 'compatible'
property. IOW, the following properties would bind to this driver:
// Option (a), modalias = "spi-nor"
compatible = "jedec,spi-nor";
// Option (b), modalias = "spi-nor"
compatible = "idontknowwhatimdoing,spi-nor";
But the following would not:
// Option (c), modalias = "shinynewdevice"
compatible = "myvendor,shinynewdevice", "jedec,spi-nor";
So, we'd like to match (a) and (c) (even when we don't have an explicit
entry for "shinynewdevice"), and we'd rather not allow (b).
To do this, we
(1) always (for devices without specific platform data) pass the
modalias to the spi-nor library;
(2) rework the spi-nor library to not reject "bad" names, and
instead just fall back to autodetection; and
(3) add the .of_match_table to properly catch all "jedec,spi-nor".
This allows (a) and (c) without warnings, and rejects (b).
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
2015-05-20 05:38:22 +08:00
|
|
|
/* Try to auto-detect if chip name wasn't specified or not found */
|
2015-08-11 03:39:03 +08:00
|
|
|
if (!info)
|
|
|
|
info = spi_nor_read_id(nor);
|
|
|
|
if (IS_ERR_OR_NULL(info))
|
2014-09-29 17:47:54 +08:00
|
|
|
return -ENOENT;
|
|
|
|
|
2014-12-01 16:42:16 +08:00
|
|
|
/*
|
|
|
|
* If caller has specified name of flash model that can normally be
|
|
|
|
* detected using JEDEC, let's verify it.
|
|
|
|
*/
|
|
|
|
if (name && info->id_len) {
|
2015-08-11 03:39:03 +08:00
|
|
|
const struct flash_info *jinfo;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2015-08-11 03:39:03 +08:00
|
|
|
jinfo = spi_nor_read_id(nor);
|
|
|
|
if (IS_ERR(jinfo)) {
|
|
|
|
return PTR_ERR(jinfo);
|
|
|
|
} else if (jinfo != info) {
|
2014-02-24 18:37:37 +08:00
|
|
|
/*
|
|
|
|
* JEDEC knows better, so overwrite platform ID. We
|
|
|
|
* can't trust partitions any longer, but we'll let
|
|
|
|
* mtd apply them anyway, since some partitions may be
|
|
|
|
* marked read-only, and we don't want to lose that
|
|
|
|
* information, even if it's not 100% accurate.
|
|
|
|
*/
|
|
|
|
dev_warn(dev, "found %s, expected %s\n",
|
2015-08-11 03:39:03 +08:00
|
|
|
jinfo->name, info->name);
|
|
|
|
info = jinfo;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_init(&nor->lock);
|
|
|
|
|
2016-12-02 19:31:44 +08:00
|
|
|
/*
|
|
|
|
* Make sure the XSR_RDY flag is set before calling
|
|
|
|
* spi_nor_wait_till_ready(). Xilinx S3AN share MFR
|
|
|
|
* with Atmel spi-nor
|
|
|
|
*/
|
|
|
|
if (info->flags & SPI_S3AN)
|
|
|
|
nor->flags |= SNOR_F_READY_XSR_RDY;
|
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
/* Parse the Serial Flash Discoverable Parameters table. */
|
|
|
|
ret = spi_nor_init_params(nor, info, ¶ms);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2014-09-29 04:36:54 +08:00
|
|
|
if (!mtd->name)
|
2014-02-24 18:37:37 +08:00
|
|
|
mtd->name = dev_name(dev);
|
2015-08-14 06:46:03 +08:00
|
|
|
mtd->priv = nor;
|
2014-02-24 18:37:37 +08:00
|
|
|
mtd->type = MTD_NORFLASH;
|
|
|
|
mtd->writesize = 1;
|
|
|
|
mtd->flags = MTD_CAP_NORFLASH;
|
2017-04-26 04:08:46 +08:00
|
|
|
mtd->size = params.size;
|
2014-02-24 18:37:37 +08:00
|
|
|
mtd->_erase = spi_nor_erase;
|
|
|
|
mtd->_read = spi_nor_read;
|
2017-08-23 04:45:22 +08:00
|
|
|
mtd->_resume = spi_nor_resume;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2015-09-02 03:57:14 +08:00
|
|
|
/* NOR protection support for STmicro/Micron chips and similar */
|
2016-01-30 03:25:35 +08:00
|
|
|
if (JEDEC_MFR(info) == SNOR_MFR_MICRON ||
|
|
|
|
info->flags & SPI_NOR_HAS_LOCK) {
|
2015-03-13 15:38:39 +08:00
|
|
|
nor->flash_lock = stm_lock;
|
|
|
|
nor->flash_unlock = stm_unlock;
|
2015-09-02 03:57:12 +08:00
|
|
|
nor->flash_is_locked = stm_is_locked;
|
2015-03-13 15:38:39 +08:00
|
|
|
}
|
|
|
|
|
2015-09-02 03:57:12 +08:00
|
|
|
if (nor->flash_lock && nor->flash_unlock && nor->flash_is_locked) {
|
2014-02-24 18:37:37 +08:00
|
|
|
mtd->_lock = spi_nor_lock;
|
|
|
|
mtd->_unlock = spi_nor_unlock;
|
2015-09-02 03:57:12 +08:00
|
|
|
mtd->_is_locked = spi_nor_is_locked;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* sst nor chips use AAI word program */
|
|
|
|
if (info->flags & SST_WRITE)
|
|
|
|
mtd->_write = sst_write;
|
|
|
|
else
|
|
|
|
mtd->_write = spi_nor_write;
|
|
|
|
|
2014-09-10 15:26:16 +08:00
|
|
|
if (info->flags & USE_FSR)
|
|
|
|
nor->flags |= SNOR_F_USE_FSR;
|
2016-01-30 03:25:36 +08:00
|
|
|
if (info->flags & SPI_NOR_HAS_TB)
|
|
|
|
nor->flags |= SNOR_F_HAS_SR_TB;
|
2017-01-07 01:19:00 +08:00
|
|
|
if (info->flags & NO_CHIP_ERASE)
|
|
|
|
nor->flags |= SNOR_F_NO_OP_CHIP_ERASE;
|
2017-07-17 23:54:07 +08:00
|
|
|
if (info->flags & USE_CLSR)
|
|
|
|
nor->flags |= SNOR_F_USE_CLSR;
|
2014-04-29 23:29:51 +08:00
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
if (info->flags & SPI_NOR_NO_ERASE)
|
|
|
|
mtd->flags |= MTD_NO_ERASE;
|
|
|
|
|
|
|
|
mtd->dev.parent = dev;
|
2017-04-26 04:08:46 +08:00
|
|
|
nor->page_size = params.page_size;
|
2014-02-24 18:37:37 +08:00
|
|
|
mtd->writebufsize = nor->page_size;
|
|
|
|
|
|
|
|
if (np) {
|
|
|
|
/* If we were instantiated by DT, use it */
|
|
|
|
if (of_property_read_bool(np, "m25p,fast-read"))
|
2017-04-26 04:08:46 +08:00
|
|
|
params.hwcaps.mask |= SNOR_HWCAPS_READ_FAST;
|
2014-02-24 18:37:37 +08:00
|
|
|
else
|
2017-04-26 04:08:46 +08:00
|
|
|
params.hwcaps.mask &= ~SNOR_HWCAPS_READ_FAST;
|
2014-02-24 18:37:37 +08:00
|
|
|
} else {
|
|
|
|
/* If we weren't instantiated by DT, default to fast-read */
|
2017-04-26 04:08:46 +08:00
|
|
|
params.hwcaps.mask |= SNOR_HWCAPS_READ_FAST;
|
2014-02-24 18:37:37 +08:00
|
|
|
}
|
|
|
|
|
mtd: spi-nor: only apply reset hacks to broken hardware
Commit 59b356ffd0b0 ("mtd: m25p80: restore the status of SPI flash when
exiting") is the latest from a long history of attempts to add reboot
handling to handle stateful addressing modes on SPI flash. Some prior
mostly-related discussions:
http://lists.infradead.org/pipermail/linux-mtd/2013-March/046343.html
[PATCH 1/3] mtd: m25p80: utilize dedicated 4-byte addressing commands
http://lists.infradead.org/pipermail/barebox/2014-September/020682.html
[RFC] MTD m25p80 3-byte addressing and boot problem
http://lists.infradead.org/pipermail/linux-mtd/2015-February/057683.html
[PATCH 2/2] m25p80: if supported put chip to deep power down if not used
Previously, attempts to add reboot-time software reset handling were
rejected, but the latest attempt was not.
Quick summary of the problem:
Some systems (e.g., boot ROM or bootloader) assume that they can read
initial boot code from their SPI flash using 3-byte addressing. If the
flash is left in 4-byte mode after reset, these systems won't boot. The
above patch provided a shutdown/remove hook to attempt to reset the
addressing mode before we reboot. Notably, this patch misses out on
huge classes of unexpected reboots (e.g., crashes, watchdog resets).
Unfortunately, it is essentially impossible to solve this problem 100%:
if your system doesn't know how to reset the SPI flash to power-on
defaults at initialization time, no amount of software can really rescue
you -- there will always be a chance of some unexpected reset that
leaves your flash in an addressing mode that your boot sequence didn't
expect.
While it is not directly harmful to perform hacks like the
aforementioned commit on all 4-byte addressing flash, a
properly-designed system should not need the hack -- and in fact,
providing this hack may mask the fact that a given system is indeed
broken. So this patch attempts to apply this unsound hack more narrowly,
providing a strong suggestion to developers and system designers that
this is truly a hack. With luck, system designers can catch their errors
early on in their development cycle, rather than applying this hack long
term. But apparently enough systems are out in the wild that we still
have to provide this hack.
Document a new device tree property to denote systems that do not have a
proper hardware (or software) reset mechanism, and apply the hack (with
a loud warning) only in this case.
Signed-off-by: Brian Norris <computersforpeace@gmail.com>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Boris Brezillon <boris.brezillon@bootlin.com>
2018-07-28 02:33:13 +08:00
|
|
|
if (of_property_read_bool(np, "broken-flash-reset"))
|
|
|
|
nor->flags |= SNOR_F_BROKEN_RESET;
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
/* Some devices cannot do fast-read, no matter what DT tells us */
|
|
|
|
if (info->flags & SPI_NOR_NO_FR)
|
2017-04-26 04:08:46 +08:00
|
|
|
params.hwcaps.mask &= ~SNOR_HWCAPS_READ_FAST;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2017-04-26 04:08:46 +08:00
|
|
|
/*
|
|
|
|
* Configure the SPI memory:
|
|
|
|
* - select op codes for (Fast) Read, Page Program and Sector Erase.
|
|
|
|
* - set the number of dummy cycles (mode cycles + wait states).
|
|
|
|
* - set the SPI protocols for register and memory accesses.
|
|
|
|
* - set the Quad Enable bit if needed (required by SPI x-y-4 protos).
|
|
|
|
*/
|
|
|
|
ret = spi_nor_setup(nor, info, ¶ms, hwcaps);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2017-06-26 21:10:00 +08:00
|
|
|
if (nor->addr_width) {
|
|
|
|
/* already configured from SFDP */
|
|
|
|
} else if (info->addr_width) {
|
2014-02-24 18:37:37 +08:00
|
|
|
nor->addr_width = info->addr_width;
|
2017-06-26 21:10:00 +08:00
|
|
|
} else if (mtd->size > 0x1000000) {
|
2014-02-24 18:37:37 +08:00
|
|
|
/* enable 4-byte addressing if the device exceeds 16MiB */
|
|
|
|
nor->addr_width = 4;
|
2016-10-27 18:03:57 +08:00
|
|
|
if (JEDEC_MFR(info) == SNOR_MFR_SPANSION ||
|
|
|
|
info->flags & SPI_NOR_4B_OPCODES)
|
|
|
|
spi_nor_set_4byte_opcodes(nor, info);
|
2014-02-24 18:37:37 +08:00
|
|
|
} else {
|
|
|
|
nor->addr_width = 3;
|
|
|
|
}
|
|
|
|
|
2015-11-11 04:15:27 +08:00
|
|
|
if (nor->addr_width > SPI_NOR_MAX_ADDR_WIDTH) {
|
|
|
|
dev_err(dev, "address width is too large: %u\n",
|
|
|
|
nor->addr_width);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-12-02 19:31:44 +08:00
|
|
|
if (info->flags & SPI_S3AN) {
|
|
|
|
ret = s3an_nor_scan(info, nor);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-08-23 04:45:21 +08:00
|
|
|
/* Send all the required SPI flash commands to initialize device */
|
|
|
|
nor->info = info;
|
|
|
|
ret = spi_nor_init(nor);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2015-08-11 03:39:03 +08:00
|
|
|
dev_info(dev, "%s (%lld Kbytes)\n", info->name,
|
2014-02-24 18:37:37 +08:00
|
|
|
(long long)mtd->size >> 10);
|
|
|
|
|
|
|
|
dev_dbg(dev,
|
|
|
|
"mtd .name = %s, .size = 0x%llx (%lldMiB), "
|
|
|
|
".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
|
|
|
|
mtd->name, (long long)mtd->size, (long long)(mtd->size >> 20),
|
|
|
|
mtd->erasesize, mtd->erasesize / 1024, mtd->numeraseregions);
|
|
|
|
|
|
|
|
if (mtd->numeraseregions)
|
|
|
|
for (i = 0; i < mtd->numeraseregions; i++)
|
|
|
|
dev_dbg(dev,
|
|
|
|
"mtd.eraseregions[%d] = { .offset = 0x%llx, "
|
|
|
|
".erasesize = 0x%.8x (%uKiB), "
|
|
|
|
".numblocks = %d }\n",
|
|
|
|
i, (long long)mtd->eraseregions[i].offset,
|
|
|
|
mtd->eraseregions[i].erasesize,
|
|
|
|
mtd->eraseregions[i].erasesize / 1024,
|
|
|
|
mtd->eraseregions[i].numblocks);
|
|
|
|
return 0;
|
|
|
|
}
|
2014-04-09 09:22:57 +08:00
|
|
|
EXPORT_SYMBOL_GPL(spi_nor_scan);
|
2014-02-24 18:37:37 +08:00
|
|
|
|
2015-08-11 03:39:03 +08:00
|
|
|
static const struct flash_info *spi_nor_match_id(const char *name)
|
2014-02-24 18:37:40 +08:00
|
|
|
{
|
2015-08-11 03:39:03 +08:00
|
|
|
const struct flash_info *id = spi_nor_ids;
|
2014-02-24 18:37:40 +08:00
|
|
|
|
2015-09-03 07:34:35 +08:00
|
|
|
while (id->name) {
|
2014-02-24 18:37:40 +08:00
|
|
|
if (!strcmp(name, id->name))
|
|
|
|
return id;
|
|
|
|
id++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-02-24 18:37:37 +08:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_AUTHOR("Huang Shijie <shijie8@gmail.com>");
|
|
|
|
MODULE_AUTHOR("Mike Lavender");
|
|
|
|
MODULE_DESCRIPTION("framework for SPI NOR");
|