Rename spi_flash_validate_params to spi_flash_scan as this code not only deals with params setup but also configure all spi_flash attributes.

And also moved all flash related code into spi_flash_scan for future functionality addition.

Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_probe.c | 145 +++++++++++++++++++++++---------------------- 1 file changed, 75 insertions(+), 70 deletions(-)

diff --git a/drivers/mtd/spi/sf_probe.c b/drivers/mtd/spi/sf_probe.c index a619182..0e20088 100644 --- a/drivers/mtd/spi/sf_probe.c +++ b/drivers/mtd/spi/sf_probe.c @@ -130,13 +130,42 @@ bank_end: } #endif

-static int spi_flash_validate_params(struct spi_slave *spi, u8 *idcode, +#if CONFIG_IS_ENABLED(OF_CONTROL) +int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash) +{ + fdt_addr_t addr; + fdt_size_t size; + int node; + + /* If there is no node, do nothing */ + node = fdtdec_next_compatible(blob, 0, COMPAT_GENERIC_SPI_FLASH); + if (node < 0) + return 0; + + addr = fdtdec_get_addr_size(blob, node, "memory-map", &size); + if (addr == FDT_ADDR_T_NONE) { + debug("%s: Cannot decode address\n", __func__); + return 0; + } + + if (flash->size != size) { + debug("%s: Memory map must cover entire device\n", __func__); + return -1; + } + flash->memory_map = map_sysmem(addr, size); + + return 0; +} +#endif /* CONFIG_IS_ENABLED(OF_CONTROL) */ + +static int spi_flash_scan(struct spi_slave *spi, u8 *idcode, struct spi_flash *flash) { const struct spi_flash_params *params; u8 cmd; u16 jedec = idcode[1] << 8 | idcode[2]; u16 ext_jedec = idcode[3] << 8 | idcode[4]; + int ret;

/* Validate params from spi_flash_params table */ params = spi_flash_params_table; @@ -158,6 +187,13 @@ static int spi_flash_validate_params(struct spi_slave *spi, u8 *idcode, return -EPROTONOSUPPORT; }

+ /* Flash powers up read-only, so clear BP# bits */ +#if defined(CONFIG_SPI_FLASH_ATMEL) || \ + defined(CONFIG_SPI_FLASH_MACRONIX) || \ + defined(CONFIG_SPI_FLASH_SST) + spi_flash_cmd_write_status(flash, 0); +#endif + /* Assign spi data */ flash->spi = spi; flash->name = params->name; @@ -253,6 +289,17 @@ static int spi_flash_validate_params(struct spi_slave *spi, u8 *idcode, /* Go for default supported write cmd */ flash->write_cmd = CMD_PAGE_PROGRAM;

+ /* Set the quad enable bit - only for quad commands */ + if ((flash->read_cmd == CMD_READ_QUAD_OUTPUT_FAST) || + (flash->read_cmd == CMD_READ_QUAD_IO_FAST) || + (flash->write_cmd == CMD_QUAD_PAGE_PROGRAM)) { + ret = spi_flash_set_qeb(flash, idcode[0]); + if (ret) { + debug("SF: Fail to set QEB for %02x\n", idcode[0]); + return -EINVAL; + } + } + /* Read dummy_byte: dummy byte is determined based on the * dummy cycles of a particular command. * Fast commands - dummy_byte = dummy_cycles/8 @@ -279,48 +326,41 @@ static int spi_flash_validate_params(struct spi_slave *spi, u8 *idcode,

/* Configure the BAR - discover bank cmds and read current bank */ #ifdef CONFIG_SPI_FLASH_BAR - int ret = spi_flash_read_bank(flash, idcode[0]); + ret = spi_flash_read_bank(flash, idcode[0]); if (ret < 0) return ret; #endif

- /* Flash powers up read-only, so clear BP# bits */ -#if defined(CONFIG_SPI_FLASH_ATMEL) || \ - defined(CONFIG_SPI_FLASH_MACRONIX) || \ - defined(CONFIG_SPI_FLASH_SST) - spi_flash_cmd_write_status(flash, 0); -#endif - - return 0; -} - #if CONFIG_IS_ENABLED(OF_CONTROL) -int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash) -{ - fdt_addr_t addr; - fdt_size_t size; - int node; - - /* If there is no node, do nothing */ - node = fdtdec_next_compatible(blob, 0, COMPAT_GENERIC_SPI_FLASH); - if (node < 0) - return 0; - - addr = fdtdec_get_addr_size(blob, node, "memory-map", &size); - if (addr == FDT_ADDR_T_NONE) { - debug("%s: Cannot decode address\n", __func__); - return 0; + ret = spi_flash_decode_fdt(gd->fdt_blob, flash); + if (ret) { + debug("SF: FDT decode error\n"); + return -EINVAL; } +#endif

- if (flash->size != size) { - debug("%s: Memory map must cover entire device\n", __func__); - return -1; +#ifndef CONFIG_SPL_BUILD + printf("SF: Detected %s with page size ", flash->name); + print_size(flash->page_size, ", erase size "); + print_size(flash->erase_size, ", total "); + print_size(flash->size, ""); + if (flash->memory_map) + printf(", mapped at %p", flash->memory_map); + puts("\n"); +#endif + +#ifndef CONFIG_SPI_FLASH_BAR + if (((flash->dual_flash == SF_SINGLE_FLASH) && + (flash->size > SPI_FLASH_16MB_BOUN)) || + ((flash->dual_flash > SF_SINGLE_FLASH) && + (flash->size > SPI_FLASH_16MB_BOUN << 1))) { + puts("SF: Warning - Only lower 16MiB accessible,"); + puts(" Full access #define CONFIG_SPI_FLASH_BAR\n"); } - flash->memory_map = map_sysmem(addr, size); +#endif

- return 0; + return ret; } -#endif /* CONFIG_IS_ENABLED(OF_CONTROL) */

/** * spi_flash_probe_slave() - Probe for a SPI flash device on a bus @@ -359,47 +399,12 @@ int spi_flash_probe_slave(struct spi_slave *spi, struct spi_flash *flash) print_buffer(0, idcode, 1, sizeof(idcode), 0); #endif

- if (spi_flash_validate_params(spi, idcode, flash)) { + ret = spi_flash_scan(spi, idcode, flash); + if (ret) { ret = -EINVAL; goto err_read_id; }

- /* Set the quad enable bit - only for quad commands */ - if ((flash->read_cmd == CMD_READ_QUAD_OUTPUT_FAST) || - (flash->read_cmd == CMD_READ_QUAD_IO_FAST) || - (flash->write_cmd == CMD_QUAD_PAGE_PROGRAM)) { - if (spi_flash_set_qeb(flash, idcode[0])) { - debug("SF: Fail to set QEB for %02x\n", idcode[0]); - ret = -EINVAL; - goto err_read_id; - } - } - -#if CONFIG_IS_ENABLED(OF_CONTROL) - if (spi_flash_decode_fdt(gd->fdt_blob, flash)) { - debug("SF: FDT decode error\n"); - ret = -EINVAL; - goto err_read_id; - } -#endif -#ifndef CONFIG_SPL_BUILD - printf("SF: Detected %s with page size ", flash->name); - print_size(flash->page_size, ", erase size "); - print_size(flash->erase_size, ", total "); - print_size(flash->size, ""); - if (flash->memory_map) - printf(", mapped at %p", flash->memory_map); - puts("\n"); -#endif -#ifndef CONFIG_SPI_FLASH_BAR - if (((flash->dual_flash == SF_SINGLE_FLASH) && - (flash->size > SPI_FLASH_16MB_BOUN)) || - ((flash->dual_flash > SF_SINGLE_FLASH) && - (flash->size > SPI_FLASH_16MB_BOUN << 1))) { - puts("SF: Warning - Only lower 16MiB accessible,"); - puts(" Full access #define CONFIG_SPI_FLASH_BAR\n"); - } -#endif #ifdef CONFIG_SPI_FLASH_MTD ret = spi_flash_mtd_register(flash); #endif

Intension is that sf_ops should deals all spi_flash related stuff and sf_probe (which should renamed future) should be an interface layer for spi_flash versus spi drivers.

sf_ops => spi_flash interface sf_probe => interface layer vs spi_flash(sf_probe) to spi drivers

Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_internal.h | 14 ++ drivers/mtd/spi/sf_ops.c | 343 ++++++++++++++++++++++++++++++++++++++++++ drivers/mtd/spi/sf_probe.c | 342 ----------------------------------------- 3 files changed, 357 insertions(+), 342 deletions(-)

diff --git a/drivers/mtd/spi/sf_internal.h b/drivers/mtd/spi/sf_internal.h index 85c8a89..f3eb6f3 100644 --- a/drivers/mtd/spi/sf_internal.h +++ b/drivers/mtd/spi/sf_internal.h @@ -245,4 +245,18 @@ int spi_flash_mtd_register(struct spi_flash *flash); void spi_flash_mtd_unregister(void); #endif

+/** + * spi_flash_scan - scan the SPI FLASH + * @spi: the spi slave structure + * @idcode: idcode of spi flash + * @flash: the spi flash structure + * + * The drivers can use this fuction to scan the SPI FLASH. + * In the scanning, it will try to get all the necessary information to + * fill the spi_flash{}. + * + * Return: 0 for success, others for failure. + */ +int spi_flash_scan(struct spi_slave *spi, u8 *idcode, struct spi_flash *flash); + #endif /* _SF_INTERNAL_H_ */ diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 3a56d7f..306db8f 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -11,6 +11,7 @@ #include <common.h> #include <errno.h> #include <malloc.h> +#include <mapmem.h> #include <spi.h> #include <spi_flash.h> #include <watchdog.h> @@ -19,6 +20,8 @@

#include "sf_internal.h"

+DECLARE_GLOBAL_DATA_PTR; + static void spi_flash_addr(u32 addr, u8 *cmd) { /* cmd[0] is actual command */ @@ -757,3 +760,343 @@ int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len) return 0; } #endif + + +/* Read commands array */ +static u8 spi_read_cmds_array[] = { + CMD_READ_ARRAY_SLOW, + CMD_READ_ARRAY_FAST, + CMD_READ_DUAL_OUTPUT_FAST, + CMD_READ_DUAL_IO_FAST, + CMD_READ_QUAD_OUTPUT_FAST, + CMD_READ_QUAD_IO_FAST, +}; + +#ifdef CONFIG_SPI_FLASH_MACRONIX +static int spi_flash_set_qeb_mxic(struct spi_flash *flash) +{ + u8 qeb_status; + int ret; + + ret = spi_flash_cmd_read_status(flash, &qeb_status); + if (ret < 0) + return ret; + + if (qeb_status & STATUS_QEB_MXIC) { + debug("SF: mxic: QEB is already set\n"); + } else { + ret = spi_flash_cmd_write_status(flash, STATUS_QEB_MXIC); + if (ret < 0) + return ret; + } + + return ret; +} +#endif + +#if defined(CONFIG_SPI_FLASH_SPANSION) || defined(CONFIG_SPI_FLASH_WINBOND) +static int spi_flash_set_qeb_winspan(struct spi_flash *flash) +{ + u8 qeb_status; + int ret; + + ret = spi_flash_cmd_read_config(flash, &qeb_status); + if (ret < 0) + return ret; + + if (qeb_status & STATUS_QEB_WINSPAN) { + debug("SF: winspan: QEB is already set\n"); + } else { + ret = spi_flash_cmd_write_config(flash, STATUS_QEB_WINSPAN); + if (ret < 0) + return ret; + } + + return ret; +} +#endif + +static int spi_flash_set_qeb(struct spi_flash *flash, u8 idcode0) +{ + switch (idcode0) { +#ifdef CONFIG_SPI_FLASH_MACRONIX + case SPI_FLASH_CFI_MFR_MACRONIX: + return spi_flash_set_qeb_mxic(flash); +#endif +#if defined(CONFIG_SPI_FLASH_SPANSION) || defined(CONFIG_SPI_FLASH_WINBOND) + case SPI_FLASH_CFI_MFR_SPANSION: + case SPI_FLASH_CFI_MFR_WINBOND: + return spi_flash_set_qeb_winspan(flash); +#endif +#ifdef CONFIG_SPI_FLASH_STMICRO + case SPI_FLASH_CFI_MFR_STMICRO: + debug("SF: QEB is volatile for %02x flash\n", idcode0); + return 0; +#endif + default: + printf("SF: Need set QEB func for %02x flash\n", idcode0); + return -1; + } +} + +#ifdef CONFIG_SPI_FLASH_BAR +static int spi_flash_read_bank(struct spi_flash *flash, u8 idcode0) +{ + u8 curr_bank = 0; + int ret; + + if (flash->size <= SPI_FLASH_16MB_BOUN) + goto bank_end; + + switch (idcode0) { + case SPI_FLASH_CFI_MFR_SPANSION: + flash->bank_read_cmd = CMD_BANKADDR_BRRD; + flash->bank_write_cmd = CMD_BANKADDR_BRWR; + default: + flash->bank_read_cmd = CMD_EXTNADDR_RDEAR; + flash->bank_write_cmd = CMD_EXTNADDR_WREAR; + } + + ret = spi_flash_read_common(flash, &flash->bank_read_cmd, 1, + &curr_bank, 1); + if (ret) { + debug("SF: fail to read bank addr register\n"); + return ret; + } + +bank_end: + flash->bank_curr = curr_bank; + return 0; +} +#endif + +#if CONFIG_IS_ENABLED(OF_CONTROL) +int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash) +{ + fdt_addr_t addr; + fdt_size_t size; + int node; + + /* If there is no node, do nothing */ + node = fdtdec_next_compatible(blob, 0, COMPAT_GENERIC_SPI_FLASH); + if (node < 0) + return 0; + + addr = fdtdec_get_addr_size(blob, node, "memory-map", &size); + if (addr == FDT_ADDR_T_NONE) { + debug("%s: Cannot decode address\n", __func__); + return 0; + } + + if (flash->size != size) { + debug("%s: Memory map must cover entire device\n", __func__); + return -1; + } + flash->memory_map = map_sysmem(addr, size); + + return 0; +} +#endif /* CONFIG_IS_ENABLED(OF_CONTROL) */ + +int spi_flash_scan(struct spi_slave *spi, u8 *idcode, struct spi_flash *flash) +{ + const struct spi_flash_params *params; + u8 cmd; + u16 jedec = idcode[1] << 8 | idcode[2]; + u16 ext_jedec = idcode[3] << 8 | idcode[4]; + int ret; + + /* Validate params from spi_flash_params table */ + params = spi_flash_params_table; + for (; params->name != NULL; params++) { + if ((params->jedec >> 16) == idcode[0]) { + if ((params->jedec & 0xFFFF) == jedec) { + if (params->ext_jedec == 0) + break; + else if (params->ext_jedec == ext_jedec) + break; + } + } + } + + if (!params->name) { + printf("SF: Unsupported flash IDs: "); + printf("manuf %02x, jedec %04x, ext_jedec %04x\n", + idcode[0], jedec, ext_jedec); + return -EPROTONOSUPPORT; + } + + /* Flash powers up read-only, so clear BP# bits */ +#if defined(CONFIG_SPI_FLASH_ATMEL) || \ + defined(CONFIG_SPI_FLASH_MACRONIX) || \ + defined(CONFIG_SPI_FLASH_SST) + spi_flash_cmd_write_status(flash, 0); +#endif + + /* Assign spi data */ + flash->spi = spi; + flash->name = params->name; + flash->memory_map = spi->memory_map; + flash->dual_flash = flash->spi->option; + + /* Assign spi flash flags */ + if (params->flags & SST_WR) + flash->flags |= SNOR_F_SST_WR; + + /* Assign spi_flash ops */ +#ifndef CONFIG_DM_SPI_FLASH + flash->write = spi_flash_cmd_write_ops; +#if defined(CONFIG_SPI_FLASH_SST) + if (flash->flags & SNOR_F_SST_WR) { + if (flash->spi->op_mode_tx & SPI_OPM_TX_BP) + flash->write = sst_write_bp; + else + flash->write = sst_write_wp; + } +#endif + flash->erase = spi_flash_cmd_erase_ops; + flash->read = spi_flash_cmd_read_ops; +#endif + + /* lock hooks are flash specific - assign them based on idcode0 */ + switch (idcode[0]) { +#if defined(CONFIG_SPI_FLASH_STMICRO) || defined(CONFIG_SPI_FLASH_SST) + case SPI_FLASH_CFI_MFR_STMICRO: + case SPI_FLASH_CFI_MFR_SST: + flash->flash_lock = stm_lock; + flash->flash_unlock = stm_unlock; + flash->flash_is_locked = stm_is_locked; +#endif + break; + default: + debug("SF: Lock ops not supported for %02x flash\n", idcode[0]); + } + + /* Compute the flash size */ + flash->shift = (flash->dual_flash & SF_DUAL_PARALLEL_FLASH) ? 1 : 0; + /* + * The Spansion S25FL032P and S25FL064P have 256b pages, yet use the + * 0x4d00 Extended JEDEC code. The rest of the Spansion flashes with + * the 0x4d00 Extended JEDEC code have 512b pages. All of the others + * have 256b pages. + */ + if (ext_jedec == 0x4d00) { + if ((jedec == 0x0215) || (jedec == 0x216)) + flash->page_size = 256; + else + flash->page_size = 512; + } else { + flash->page_size = 256; + } + flash->page_size <<= flash->shift; + flash->sector_size = params->sector_size << flash->shift; + flash->size = flash->sector_size * params->nr_sectors << flash->shift; +#ifdef CONFIG_SF_DUAL_FLASH + if (flash->dual_flash & SF_DUAL_STACKED_FLASH) + flash->size <<= 1; +#endif + + /* Compute erase sector and command */ + if (params->flags & SECT_4K) { + flash->erase_cmd = CMD_ERASE_4K; + flash->erase_size = 4096 << flash->shift; + } else if (params->flags & SECT_32K) { + flash->erase_cmd = CMD_ERASE_32K; + flash->erase_size = 32768 << flash->shift; + } else { + flash->erase_cmd = CMD_ERASE_64K; + flash->erase_size = flash->sector_size; + } + + /* Now erase size becomes valid sector size */ + flash->sector_size = flash->erase_size; + + /* Look for the fastest read cmd */ + cmd = fls(params->e_rd_cmd & flash->spi->op_mode_rx); + if (cmd) { + cmd = spi_read_cmds_array[cmd - 1]; + flash->read_cmd = cmd; + } else { + /* Go for default supported read cmd */ + flash->read_cmd = CMD_READ_ARRAY_FAST; + } + + /* Not require to look for fastest only two write cmds yet */ + if (params->flags & WR_QPP && flash->spi->op_mode_tx & SPI_OPM_TX_QPP) + flash->write_cmd = CMD_QUAD_PAGE_PROGRAM; + else + /* Go for default supported write cmd */ + flash->write_cmd = CMD_PAGE_PROGRAM; + + /* Set the quad enable bit - only for quad commands */ + if ((flash->read_cmd == CMD_READ_QUAD_OUTPUT_FAST) || + (flash->read_cmd == CMD_READ_QUAD_IO_FAST) || + (flash->write_cmd == CMD_QUAD_PAGE_PROGRAM)) { + ret = spi_flash_set_qeb(flash, idcode[0]); + if (ret) { + debug("SF: Fail to set QEB for %02x\n", idcode[0]); + return -EINVAL; + } + } + + /* Read dummy_byte: dummy byte is determined based on the + * dummy cycles of a particular command. + * Fast commands - dummy_byte = dummy_cycles/8 + * I/O commands- dummy_byte = (dummy_cycles * no.of lines)/8 + * For I/O commands except cmd[0] everything goes on no.of lines + * based on particular command but incase of fast commands except + * data all go on single line irrespective of command. + */ + switch (flash->read_cmd) { + case CMD_READ_QUAD_IO_FAST: + flash->dummy_byte = 2; + break; + case CMD_READ_ARRAY_SLOW: + flash->dummy_byte = 0; + break; + default: + flash->dummy_byte = 1; + } + +#ifdef CONFIG_SPI_FLASH_STMICRO + if (params->flags & E_FSR) + flash->flags |= SNOR_F_USE_FSR; +#endif + + /* Configure the BAR - discover bank cmds and read current bank */ +#ifdef CONFIG_SPI_FLASH_BAR + ret = spi_flash_read_bank(flash, idcode[0]); + if (ret < 0) + return ret; +#endif + +#if CONFIG_IS_ENABLED(OF_CONTROL) + ret = spi_flash_decode_fdt(gd->fdt_blob, flash); + if (ret) { + debug("SF: FDT decode error\n"); + return -EINVAL; + } +#endif + +#ifndef CONFIG_SPL_BUILD + printf("SF: Detected %s with page size ", flash->name); + print_size(flash->page_size, ", erase size "); + print_size(flash->erase_size, ", total "); + print_size(flash->size, ""); + if (flash->memory_map) + printf(", mapped at %p", flash->memory_map); + puts("\n"); +#endif + +#ifndef CONFIG_SPI_FLASH_BAR + if (((flash->dual_flash == SF_SINGLE_FLASH) && + (flash->size > SPI_FLASH_16MB_BOUN)) || + ((flash->dual_flash > SF_SINGLE_FLASH) && + (flash->size > SPI_FLASH_16MB_BOUN << 1))) { + puts("SF: Warning - Only lower 16MiB accessible,"); + puts(" Full access #define CONFIG_SPI_FLASH_BAR\n"); + } +#endif + + return ret; +} diff --git a/drivers/mtd/spi/sf_probe.c b/drivers/mtd/spi/sf_probe.c index 0e20088..994559d 100644 --- a/drivers/mtd/spi/sf_probe.c +++ b/drivers/mtd/spi/sf_probe.c @@ -20,348 +20,6 @@

#include "sf_internal.h"

-DECLARE_GLOBAL_DATA_PTR; - -/* Read commands array */ -static u8 spi_read_cmds_array[] = { - CMD_READ_ARRAY_SLOW, - CMD_READ_ARRAY_FAST, - CMD_READ_DUAL_OUTPUT_FAST, - CMD_READ_DUAL_IO_FAST, - CMD_READ_QUAD_OUTPUT_FAST, - CMD_READ_QUAD_IO_FAST, -}; - -#ifdef CONFIG_SPI_FLASH_MACRONIX -static int spi_flash_set_qeb_mxic(struct spi_flash *flash) -{ - u8 qeb_status; - int ret; - - ret = spi_flash_cmd_read_status(flash, &qeb_status); - if (ret < 0) - return ret; - - if (qeb_status & STATUS_QEB_MXIC) { - debug("SF: mxic: QEB is already set\n"); - } else { - ret = spi_flash_cmd_write_status(flash, STATUS_QEB_MXIC); - if (ret < 0) - return ret; - } - - return ret; -} -#endif - -#if defined(CONFIG_SPI_FLASH_SPANSION) || defined(CONFIG_SPI_FLASH_WINBOND) -static int spi_flash_set_qeb_winspan(struct spi_flash *flash) -{ - u8 qeb_status; - int ret; - - ret = spi_flash_cmd_read_config(flash, &qeb_status); - if (ret < 0) - return ret; - - if (qeb_status & STATUS_QEB_WINSPAN) { - debug("SF: winspan: QEB is already set\n"); - } else { - ret = spi_flash_cmd_write_config(flash, STATUS_QEB_WINSPAN); - if (ret < 0) - return ret; - } - - return ret; -} -#endif - -static int spi_flash_set_qeb(struct spi_flash *flash, u8 idcode0) -{ - switch (idcode0) { -#ifdef CONFIG_SPI_FLASH_MACRONIX - case SPI_FLASH_CFI_MFR_MACRONIX: - return spi_flash_set_qeb_mxic(flash); -#endif -#if defined(CONFIG_SPI_FLASH_SPANSION) || defined(CONFIG_SPI_FLASH_WINBOND) - case SPI_FLASH_CFI_MFR_SPANSION: - case SPI_FLASH_CFI_MFR_WINBOND: - return spi_flash_set_qeb_winspan(flash); -#endif -#ifdef CONFIG_SPI_FLASH_STMICRO - case SPI_FLASH_CFI_MFR_STMICRO: - debug("SF: QEB is volatile for %02x flash\n", idcode0); - return 0; -#endif - default: - printf("SF: Need set QEB func for %02x flash\n", idcode0); - return -1; - } -} - -#ifdef CONFIG_SPI_FLASH_BAR -static int spi_flash_read_bank(struct spi_flash *flash, u8 idcode0) -{ - u8 curr_bank = 0; - int ret; - - if (flash->size <= SPI_FLASH_16MB_BOUN) - goto bank_end; - - switch (idcode0) { - case SPI_FLASH_CFI_MFR_SPANSION: - flash->bank_read_cmd = CMD_BANKADDR_BRRD; - flash->bank_write_cmd = CMD_BANKADDR_BRWR; - default: - flash->bank_read_cmd = CMD_EXTNADDR_RDEAR; - flash->bank_write_cmd = CMD_EXTNADDR_WREAR; - } - - ret = spi_flash_read_common(flash, &flash->bank_read_cmd, 1, - &curr_bank, 1); - if (ret) { - debug("SF: fail to read bank addr register\n"); - return ret; - } - -bank_end: - flash->bank_curr = curr_bank; - return 0; -} -#endif - -#if CONFIG_IS_ENABLED(OF_CONTROL) -int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash) -{ - fdt_addr_t addr; - fdt_size_t size; - int node; - - /* If there is no node, do nothing */ - node = fdtdec_next_compatible(blob, 0, COMPAT_GENERIC_SPI_FLASH); - if (node < 0) - return 0; - - addr = fdtdec_get_addr_size(blob, node, "memory-map", &size); - if (addr == FDT_ADDR_T_NONE) { - debug("%s: Cannot decode address\n", __func__); - return 0; - } - - if (flash->size != size) { - debug("%s: Memory map must cover entire device\n", __func__); - return -1; - } - flash->memory_map = map_sysmem(addr, size); - - return 0; -} -#endif /* CONFIG_IS_ENABLED(OF_CONTROL) */ - -static int spi_flash_scan(struct spi_slave *spi, u8 *idcode, - struct spi_flash *flash) -{ - const struct spi_flash_params *params; - u8 cmd; - u16 jedec = idcode[1] << 8 | idcode[2]; - u16 ext_jedec = idcode[3] << 8 | idcode[4]; - int ret; - - /* Validate params from spi_flash_params table */ - params = spi_flash_params_table; - for (; params->name != NULL; params++) { - if ((params->jedec >> 16) == idcode[0]) { - if ((params->jedec & 0xFFFF) == jedec) { - if (params->ext_jedec == 0) - break; - else if (params->ext_jedec == ext_jedec) - break; - } - } - } - - if (!params->name) { - printf("SF: Unsupported flash IDs: "); - printf("manuf %02x, jedec %04x, ext_jedec %04x\n", - idcode[0], jedec, ext_jedec); - return -EPROTONOSUPPORT; - } - - /* Flash powers up read-only, so clear BP# bits */ -#if defined(CONFIG_SPI_FLASH_ATMEL) || \ - defined(CONFIG_SPI_FLASH_MACRONIX) || \ - defined(CONFIG_SPI_FLASH_SST) - spi_flash_cmd_write_status(flash, 0); -#endif - - /* Assign spi data */ - flash->spi = spi; - flash->name = params->name; - flash->memory_map = spi->memory_map; - flash->dual_flash = flash->spi->option; - - /* Assign spi flash flags */ - if (params->flags & SST_WR) - flash->flags |= SNOR_F_SST_WR; - - /* Assign spi_flash ops */ -#ifndef CONFIG_DM_SPI_FLASH - flash->write = spi_flash_cmd_write_ops; -#if defined(CONFIG_SPI_FLASH_SST) - if (flash->flags & SNOR_F_SST_WR) { - if (flash->spi->op_mode_tx & SPI_OPM_TX_BP) - flash->write = sst_write_bp; - else - flash->write = sst_write_wp; - } -#endif - flash->erase = spi_flash_cmd_erase_ops; - flash->read = spi_flash_cmd_read_ops; -#endif - - /* lock hooks are flash specific - assign them based on idcode0 */ - switch (idcode[0]) { -#if defined(CONFIG_SPI_FLASH_STMICRO) || defined(CONFIG_SPI_FLASH_SST) - case SPI_FLASH_CFI_MFR_STMICRO: - case SPI_FLASH_CFI_MFR_SST: - flash->flash_lock = stm_lock; - flash->flash_unlock = stm_unlock; - flash->flash_is_locked = stm_is_locked; -#endif - break; - default: - debug("SF: Lock ops not supported for %02x flash\n", idcode[0]); - } - - /* Compute the flash size */ - flash->shift = (flash->dual_flash & SF_DUAL_PARALLEL_FLASH) ? 1 : 0; - /* - * The Spansion S25FL032P and S25FL064P have 256b pages, yet use the - * 0x4d00 Extended JEDEC code. The rest of the Spansion flashes with - * the 0x4d00 Extended JEDEC code have 512b pages. All of the others - * have 256b pages. - */ - if (ext_jedec == 0x4d00) { - if ((jedec == 0x0215) || (jedec == 0x216)) - flash->page_size = 256; - else - flash->page_size = 512; - } else { - flash->page_size = 256; - } - flash->page_size <<= flash->shift; - flash->sector_size = params->sector_size << flash->shift; - flash->size = flash->sector_size * params->nr_sectors << flash->shift; -#ifdef CONFIG_SF_DUAL_FLASH - if (flash->dual_flash & SF_DUAL_STACKED_FLASH) - flash->size <<= 1; -#endif - - /* Compute erase sector and command */ - if (params->flags & SECT_4K) { - flash->erase_cmd = CMD_ERASE_4K; - flash->erase_size = 4096 << flash->shift; - } else if (params->flags & SECT_32K) { - flash->erase_cmd = CMD_ERASE_32K; - flash->erase_size = 32768 << flash->shift; - } else { - flash->erase_cmd = CMD_ERASE_64K; - flash->erase_size = flash->sector_size; - } - - /* Now erase size becomes valid sector size */ - flash->sector_size = flash->erase_size; - - /* Look for the fastest read cmd */ - cmd = fls(params->e_rd_cmd & flash->spi->op_mode_rx); - if (cmd) { - cmd = spi_read_cmds_array[cmd - 1]; - flash->read_cmd = cmd; - } else { - /* Go for default supported read cmd */ - flash->read_cmd = CMD_READ_ARRAY_FAST; - } - - /* Not require to look for fastest only two write cmds yet */ - if (params->flags & WR_QPP && flash->spi->op_mode_tx & SPI_OPM_TX_QPP) - flash->write_cmd = CMD_QUAD_PAGE_PROGRAM; - else - /* Go for default supported write cmd */ - flash->write_cmd = CMD_PAGE_PROGRAM; - - /* Set the quad enable bit - only for quad commands */ - if ((flash->read_cmd == CMD_READ_QUAD_OUTPUT_FAST) || - (flash->read_cmd == CMD_READ_QUAD_IO_FAST) || - (flash->write_cmd == CMD_QUAD_PAGE_PROGRAM)) { - ret = spi_flash_set_qeb(flash, idcode[0]); - if (ret) { - debug("SF: Fail to set QEB for %02x\n", idcode[0]); - return -EINVAL; - } - } - - /* Read dummy_byte: dummy byte is determined based on the - * dummy cycles of a particular command. - * Fast commands - dummy_byte = dummy_cycles/8 - * I/O commands- dummy_byte = (dummy_cycles * no.of lines)/8 - * For I/O commands except cmd[0] everything goes on no.of lines - * based on particular command but incase of fast commands except - * data all go on single line irrespective of command. - */ - switch (flash->read_cmd) { - case CMD_READ_QUAD_IO_FAST: - flash->dummy_byte = 2; - break; - case CMD_READ_ARRAY_SLOW: - flash->dummy_byte = 0; - break; - default: - flash->dummy_byte = 1; - } - -#ifdef CONFIG_SPI_FLASH_STMICRO - if (params->flags & E_FSR) - flash->flags |= SNOR_F_USE_FSR; -#endif - - /* Configure the BAR - discover bank cmds and read current bank */ -#ifdef CONFIG_SPI_FLASH_BAR - ret = spi_flash_read_bank(flash, idcode[0]); - if (ret < 0) - return ret; -#endif - -#if CONFIG_IS_ENABLED(OF_CONTROL) - ret = spi_flash_decode_fdt(gd->fdt_blob, flash); - if (ret) { - debug("SF: FDT decode error\n"); - return -EINVAL; - } -#endif - -#ifndef CONFIG_SPL_BUILD - printf("SF: Detected %s with page size ", flash->name); - print_size(flash->page_size, ", erase size "); - print_size(flash->erase_size, ", total "); - print_size(flash->size, ""); - if (flash->memory_map) - printf(", mapped at %p", flash->memory_map); - puts("\n"); -#endif - -#ifndef CONFIG_SPI_FLASH_BAR - if (((flash->dual_flash == SF_SINGLE_FLASH) && - (flash->size > SPI_FLASH_16MB_BOUN)) || - ((flash->dual_flash > SF_SINGLE_FLASH) && - (flash->size > SPI_FLASH_16MB_BOUN << 1))) { - puts("SF: Warning - Only lower 16MiB accessible,"); - puts(" Full access #define CONFIG_SPI_FLASH_BAR\n"); - } -#endif - - return ret; -} - /** * spi_flash_probe_slave() - Probe for a SPI flash device on a bus *

read_id code is related to spi_flash stuff hence moved to sf_ops.

Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_internal.h | 3 +-- drivers/mtd/spi/sf_ops.c | 21 ++++++++++++++++++--- drivers/mtd/spi/sf_probe.c | 15 +-------------- 3 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/drivers/mtd/spi/sf_internal.h b/drivers/mtd/spi/sf_internal.h index f3eb6f3..670429f 100644 --- a/drivers/mtd/spi/sf_internal.h +++ b/drivers/mtd/spi/sf_internal.h @@ -248,7 +248,6 @@ void spi_flash_mtd_unregister(void); /** * spi_flash_scan - scan the SPI FLASH * @spi: the spi slave structure - * @idcode: idcode of spi flash * @flash: the spi flash structure * * The drivers can use this fuction to scan the SPI FLASH. @@ -257,6 +256,6 @@ void spi_flash_mtd_unregister(void); * * Return: 0 for success, others for failure. */ -int spi_flash_scan(struct spi_slave *spi, u8 *idcode, struct spi_flash *flash); +int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash);

#endif /* _SF_INTERNAL_H_ */ diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 306db8f..54c6468 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -898,14 +898,29 @@ int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash) } #endif /* CONFIG_IS_ENABLED(OF_CONTROL) */

-int spi_flash_scan(struct spi_slave *spi, u8 *idcode, struct spi_flash *flash) +int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash) { const struct spi_flash_params *params; + u16 jedec, ext_jedec; + u8 idcode[5]; u8 cmd; - u16 jedec = idcode[1] << 8 | idcode[2]; - u16 ext_jedec = idcode[3] << 8 | idcode[4]; int ret;

+ /* Read the ID codes */ + ret = spi_flash_cmd(spi, CMD_READ_ID, idcode, sizeof(idcode)); + if (ret) { + printf("SF: Failed to get idcodes\n"); + return -EINVAL; + } + +#ifdef DEBUG + printf("SF: Got idcodes\n"); + print_buffer(0, idcode, 1, sizeof(idcode), 0); +#endif + + jedec = idcode[1] << 8 | idcode[2]; + ext_jedec = idcode[3] << 8 | idcode[4]; + /* Validate params from spi_flash_params table */ params = spi_flash_params_table; for (; params->name != NULL; params++) { diff --git a/drivers/mtd/spi/sf_probe.c b/drivers/mtd/spi/sf_probe.c index 994559d..e35b917 100644 --- a/drivers/mtd/spi/sf_probe.c +++ b/drivers/mtd/spi/sf_probe.c @@ -29,7 +29,6 @@ */ int spi_flash_probe_slave(struct spi_slave *spi, struct spi_flash *flash) { - u8 idcode[5]; int ret;

/* Setup spi_slave */ @@ -45,19 +44,7 @@ int spi_flash_probe_slave(struct spi_slave *spi, struct spi_flash *flash) return ret; }

- /* Read the ID codes */ - ret = spi_flash_cmd(spi, CMD_READ_ID, idcode, sizeof(idcode)); - if (ret) { - printf("SF: Failed to get idcodes\n"); - goto err_read_id; - } - -#ifdef DEBUG - printf("SF: Got idcodes\n"); - print_buffer(0, idcode, 1, sizeof(idcode), 0); -#endif - - ret = spi_flash_scan(spi, idcode, flash); + ret = spi_flash_scan(spi, flash); if (ret) { ret = -EINVAL; goto err_read_id;

- Move bar read code below the bar write hance both at once place, hence it easy for #ifdef macro only once and readable. - Move read_cmd_array at top

Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_ops.c | 80 +++++++++++++++++++++++------------------------- 1 file changed, 39 insertions(+), 41 deletions(-)

diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 54c6468..8d6040e 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -30,6 +30,16 @@ static void spi_flash_addr(u32 addr, u8 *cmd) cmd[3] = addr >> 0; }

+/* Read commands array */ +static u8 spi_read_cmds_array[] = { + CMD_READ_ARRAY_SLOW, + CMD_READ_ARRAY_FAST, + CMD_READ_DUAL_OUTPUT_FAST, + CMD_READ_DUAL_IO_FAST, + CMD_READ_QUAD_OUTPUT_FAST, + CMD_READ_QUAD_IO_FAST, +}; + int spi_flash_cmd_read_status(struct spi_flash *flash, u8 *rs) { int ret; @@ -133,6 +143,35 @@ bar_end: flash->bank_curr = bank_sel; return flash->bank_curr; } + +static int spi_flash_read_bank(struct spi_flash *flash, u8 idcode0) +{ + u8 curr_bank = 0; + int ret; + + if (flash->size <= SPI_FLASH_16MB_BOUN) + goto bank_end; + + switch (idcode0) { + case SPI_FLASH_CFI_MFR_SPANSION: + flash->bank_read_cmd = CMD_BANKADDR_BRRD; + flash->bank_write_cmd = CMD_BANKADDR_BRWR; + default: + flash->bank_read_cmd = CMD_EXTNADDR_RDEAR; + flash->bank_write_cmd = CMD_EXTNADDR_WREAR; + } + + ret = spi_flash_read_common(flash, &flash->bank_read_cmd, 1, + &curr_bank, 1); + if (ret) { + debug("SF: fail to read bank addr register\n"); + return ret; + } + +bank_end: + flash->bank_curr = curr_bank; + return 0; +} #endif

#ifdef CONFIG_SF_DUAL_FLASH @@ -762,16 +801,6 @@ int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len) #endif

-/* Read commands array */ -static u8 spi_read_cmds_array[] = { - CMD_READ_ARRAY_SLOW, - CMD_READ_ARRAY_FAST, - CMD_READ_DUAL_OUTPUT_FAST, - CMD_READ_DUAL_IO_FAST, - CMD_READ_QUAD_OUTPUT_FAST, - CMD_READ_QUAD_IO_FAST, -}; - #ifdef CONFIG_SPI_FLASH_MACRONIX static int spi_flash_set_qeb_mxic(struct spi_flash *flash) { @@ -839,37 +868,6 @@ static int spi_flash_set_qeb(struct spi_flash *flash, u8 idcode0) } }

-#ifdef CONFIG_SPI_FLASH_BAR -static int spi_flash_read_bank(struct spi_flash *flash, u8 idcode0) -{ - u8 curr_bank = 0; - int ret; - - if (flash->size <= SPI_FLASH_16MB_BOUN) - goto bank_end; - - switch (idcode0) { - case SPI_FLASH_CFI_MFR_SPANSION: - flash->bank_read_cmd = CMD_BANKADDR_BRRD; - flash->bank_write_cmd = CMD_BANKADDR_BRWR; - default: - flash->bank_read_cmd = CMD_EXTNADDR_RDEAR; - flash->bank_write_cmd = CMD_EXTNADDR_WREAR; - } - - ret = spi_flash_read_common(flash, &flash->bank_read_cmd, 1, - &curr_bank, 1); - if (ret) { - debug("SF: fail to read bank addr register\n"); - return ret; - } - -bank_end: - flash->bank_curr = curr_bank; - return 0; -} -#endif - #if CONFIG_IS_ENABLED(OF_CONTROL) int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash) {

Use static for file-scope functions and removed them from header files.

Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_internal.h | 18 ------------------ drivers/mtd/spi/sf_ops.c | 11 ++++++----- 2 files changed, 6 insertions(+), 23 deletions(-)

diff --git a/drivers/mtd/spi/sf_internal.h b/drivers/mtd/spi/sf_internal.h index 670429f..8f586ee 100644 --- a/drivers/mtd/spi/sf_internal.h +++ b/drivers/mtd/spi/sf_internal.h @@ -171,12 +171,6 @@ int spi_flash_cmd_write(struct spi_slave *spi, const u8 *cmd, size_t cmd_len, /* Flash erase(sectors) operation, support all possible erase commands */ int spi_flash_cmd_erase_ops(struct spi_flash *flash, u32 offset, size_t len);

-/* Read the status register */ -int spi_flash_cmd_read_status(struct spi_flash *flash, u8 *rs); - -/* Program the status register */ -int spi_flash_cmd_write_status(struct spi_flash *flash, u8 ws); - /* Lock stmicro spi flash region */ int stm_lock(struct spi_flash *flash, u32 ofs, size_t len);

@@ -186,12 +180,6 @@ int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len); /* Check if a stmicro spi flash region is completely locked */ int stm_is_locked(struct spi_flash *flash, u32 ofs, size_t len);

-/* Read the config register */ -int spi_flash_cmd_read_config(struct spi_flash *flash, u8 *rc); - -/* Program the config register */ -int spi_flash_cmd_write_config(struct spi_flash *flash, u8 wc); - /* Enable writing on the SPI flash */ static inline int spi_flash_cmd_write_enable(struct spi_flash *flash) { @@ -205,12 +193,6 @@ static inline int spi_flash_cmd_write_disable(struct spi_flash *flash) }

/* - * Send the read status command to the device and wait for the wip - * (write-in-progress) bit to clear itself. - */ -int spi_flash_cmd_wait_ready(struct spi_flash *flash, unsigned long timeout); - -/* * Used for spi_flash write operation * - SPI claim * - spi_flash_cmd_write_enable diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 8d6040e..23a6adb 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -40,7 +40,7 @@ static u8 spi_read_cmds_array[] = { CMD_READ_QUAD_IO_FAST, };

-int spi_flash_cmd_read_status(struct spi_flash *flash, u8 *rs) +static int spi_flash_cmd_read_status(struct spi_flash *flash, u8 *rs) { int ret; u8 cmd; @@ -69,7 +69,7 @@ static int read_fsr(struct spi_flash *flash, u8 *fsr) return 0; }

-int spi_flash_cmd_write_status(struct spi_flash *flash, u8 ws) +static int spi_flash_cmd_write_status(struct spi_flash *flash, u8 ws) { u8 cmd; int ret; @@ -85,7 +85,7 @@ int spi_flash_cmd_write_status(struct spi_flash *flash, u8 ws) }

#if defined(CONFIG_SPI_FLASH_SPANSION) || defined(CONFIG_SPI_FLASH_WINBOND) -int spi_flash_cmd_read_config(struct spi_flash *flash, u8 *rc) +static int spi_flash_cmd_read_config(struct spi_flash *flash, u8 *rc) { int ret; u8 cmd; @@ -100,7 +100,7 @@ int spi_flash_cmd_read_config(struct spi_flash *flash, u8 *rc) return 0; }

-int spi_flash_cmd_write_config(struct spi_flash *flash, u8 wc) +static int spi_flash_cmd_write_config(struct spi_flash *flash, u8 wc) { u8 data[2]; u8 cmd; @@ -238,7 +238,8 @@ static int spi_flash_ready(struct spi_flash *flash) return sr && fsr; }

-int spi_flash_cmd_wait_ready(struct spi_flash *flash, unsigned long timeout) +static int spi_flash_cmd_wait_ready(struct spi_flash *flash, + unsigned long timeout) { int timebase, ret;

Most of the register access function are static, so used simple name to represent each.

Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_ops.c | 52 ++++++++++++++++++++++++------------------------ 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 23a6adb..853759e 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -40,7 +40,7 @@ static u8 spi_read_cmds_array[] = { CMD_READ_QUAD_IO_FAST, };

-static int spi_flash_cmd_read_status(struct spi_flash *flash, u8 *rs) +static int read_sr(struct spi_flash *flash, u8 *rs) { int ret; u8 cmd; @@ -69,7 +69,7 @@ static int read_fsr(struct spi_flash *flash, u8 *fsr) return 0; }

-static int spi_flash_cmd_write_status(struct spi_flash *flash, u8 ws) +static int write_sr(struct spi_flash *flash, u8 ws) { u8 cmd; int ret; @@ -85,7 +85,7 @@ static int spi_flash_cmd_write_status(struct spi_flash *flash, u8 ws) }

#if defined(CONFIG_SPI_FLASH_SPANSION) || defined(CONFIG_SPI_FLASH_WINBOND) -static int spi_flash_cmd_read_config(struct spi_flash *flash, u8 *rc) +static int read_cr(struct spi_flash *flash, u8 *rc) { int ret; u8 cmd; @@ -100,13 +100,13 @@ static int spi_flash_cmd_read_config(struct spi_flash *flash, u8 *rc) return 0; }

-static int spi_flash_cmd_write_config(struct spi_flash *flash, u8 wc) +static int write_cr(struct spi_flash *flash, u8 wc) { u8 data[2]; u8 cmd; int ret;

- ret = spi_flash_cmd_read_status(flash, &data[0]); + ret = read_sr(flash, &data[0]); if (ret < 0) return ret;

@@ -123,7 +123,7 @@ static int spi_flash_cmd_write_config(struct spi_flash *flash, u8 wc) #endif

#ifdef CONFIG_SPI_FLASH_BAR -static int spi_flash_write_bank(struct spi_flash *flash, u32 offset) +static int spi_flash_write_bar(struct spi_flash *flash, u32 offset) { u8 cmd, bank_sel; int ret; @@ -144,7 +144,7 @@ bar_end: return flash->bank_curr; }

-static int spi_flash_read_bank(struct spi_flash *flash, u8 idcode0) +static int spi_flash_read_bar(struct spi_flash *flash, u8 idcode0) { u8 curr_bank = 0; int ret; @@ -175,7 +175,7 @@ bank_end: #endif

#ifdef CONFIG_SF_DUAL_FLASH -static void spi_flash_dual_flash(struct spi_flash *flash, u32 *addr) +static void spi_flash_dual(struct spi_flash *flash, u32 *addr) { switch (flash->dual_flash) { case SF_DUAL_STACKED_FLASH: @@ -201,7 +201,7 @@ static int spi_flash_sr_ready(struct spi_flash *flash) u8 sr; int ret;

- ret = spi_flash_cmd_read_status(flash, &sr); + ret = read_sr(flash, &sr); if (ret < 0) return ret;

@@ -325,10 +325,10 @@ int spi_flash_cmd_erase_ops(struct spi_flash *flash, u32 offset, size_t len)

#ifdef CONFIG_SF_DUAL_FLASH if (flash->dual_flash > SF_SINGLE_FLASH) - spi_flash_dual_flash(flash, &erase_addr); + spi_flash_dual(flash, &erase_addr); #endif #ifdef CONFIG_SPI_FLASH_BAR - ret = spi_flash_write_bank(flash, erase_addr); + ret = spi_flash_write_bar(flash, erase_addr); if (ret < 0) return ret; #endif @@ -375,10 +375,10 @@ int spi_flash_cmd_write_ops(struct spi_flash *flash, u32 offset,

#ifdef CONFIG_SF_DUAL_FLASH if (flash->dual_flash > SF_SINGLE_FLASH) - spi_flash_dual_flash(flash, &write_addr); + spi_flash_dual(flash, &write_addr); #endif #ifdef CONFIG_SPI_FLASH_BAR - ret = spi_flash_write_bank(flash, write_addr); + ret = spi_flash_write_bar(flash, write_addr); if (ret < 0) return ret; #endif @@ -470,10 +470,10 @@ int spi_flash_cmd_read_ops(struct spi_flash *flash, u32 offset,

#ifdef CONFIG_SF_DUAL_FLASH if (flash->dual_flash > SF_SINGLE_FLASH) - spi_flash_dual_flash(flash, &read_addr); + spi_flash_dual(flash, &read_addr); #endif #ifdef CONFIG_SPI_FLASH_BAR - ret = spi_flash_write_bank(flash, read_addr); + ret = spi_flash_write_bar(flash, read_addr); if (ret < 0) return ret; bank_sel = flash->bank_curr; @@ -671,7 +671,7 @@ int stm_is_locked(struct spi_flash *flash, u32 ofs, size_t len) int status; u8 sr;

- status = spi_flash_cmd_read_status(flash, &sr); + status = read_sr(flash, &sr); if (status < 0) return status;

@@ -708,7 +708,7 @@ int stm_lock(struct spi_flash *flash, u32 ofs, size_t len) u8 shift = ffs(mask) - 1, pow, val; int ret;

- ret = spi_flash_cmd_read_status(flash, &status_old); + ret = read_sr(flash, &status_old); if (ret < 0) return ret;

@@ -745,7 +745,7 @@ int stm_lock(struct spi_flash *flash, u32 ofs, size_t len) if ((status_new & mask) <= (status_old & mask)) return -EINVAL;

- spi_flash_cmd_write_status(flash, status_new); + write_sr(flash, status_new);

return 0; } @@ -762,7 +762,7 @@ int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len) u8 shift = ffs(mask) - 1, pow, val; int ret;

- ret = spi_flash_cmd_read_status(flash, &status_old); + ret = read_sr(flash, &status_old); if (ret < 0) return ret;

@@ -795,7 +795,7 @@ int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len) if ((status_new & mask) >= (status_old & mask)) return -EINVAL;

- spi_flash_cmd_write_status(flash, status_new); + write_sr(flash, status_new);

return 0; } @@ -808,14 +808,14 @@ static int spi_flash_set_qeb_mxic(struct spi_flash *flash) u8 qeb_status; int ret;

- ret = spi_flash_cmd_read_status(flash, &qeb_status); + ret = read_sr(flash, &qeb_status); if (ret < 0) return ret;

if (qeb_status & STATUS_QEB_MXIC) { debug("SF: mxic: QEB is already set\n"); } else { - ret = spi_flash_cmd_write_status(flash, STATUS_QEB_MXIC); + ret = write_sr(flash, STATUS_QEB_MXIC); if (ret < 0) return ret; } @@ -830,14 +830,14 @@ static int spi_flash_set_qeb_winspan(struct spi_flash *flash) u8 qeb_status; int ret;

- ret = spi_flash_cmd_read_config(flash, &qeb_status); + ret = read_cr(flash, &qeb_status); if (ret < 0) return ret;

if (qeb_status & STATUS_QEB_WINSPAN) { debug("SF: winspan: QEB is already set\n"); } else { - ret = spi_flash_cmd_write_config(flash, STATUS_QEB_WINSPAN); + ret = write_cr(flash, STATUS_QEB_WINSPAN); if (ret < 0) return ret; } @@ -944,7 +944,7 @@ int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash) #if defined(CONFIG_SPI_FLASH_ATMEL) || \ defined(CONFIG_SPI_FLASH_MACRONIX) || \ defined(CONFIG_SPI_FLASH_SST) - spi_flash_cmd_write_status(flash, 0); + write_sr(flash, 0); #endif

/* Assign spi data */ @@ -1079,7 +1079,7 @@ int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash)

/* Configure the BAR - discover bank cmds and read current bank */ #ifdef CONFIG_SPI_FLASH_BAR - ret = spi_flash_read_bank(flash, idcode[0]); + ret = spi_flash_read_bar(flash, idcode[0]); if (ret < 0) return ret; #endif

flash operations are defined as static and reuse them with function-pointers so call them with generic function pounters instead of calling like normal functions.

Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_ops.c | 2 -- drivers/mtd/spi/sf_probe.c | 15 +++------------ include/spi_flash.h | 13 ------------- 3 files changed, 3 insertions(+), 27 deletions(-)

diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 853759e..ab21f02 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -958,7 +958,6 @@ int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash) flash->flags |= SNOR_F_SST_WR;

/* Assign spi_flash ops */ -#ifndef CONFIG_DM_SPI_FLASH flash->write = spi_flash_cmd_write_ops; #if defined(CONFIG_SPI_FLASH_SST) if (flash->flags & SNOR_F_SST_WR) { @@ -970,7 +969,6 @@ int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash) #endif flash->erase = spi_flash_cmd_erase_ops; flash->read = spi_flash_cmd_read_ops; -#endif

/* lock hooks are flash specific - assign them based on idcode0 */ switch (idcode[0]) { diff --git a/drivers/mtd/spi/sf_probe.c b/drivers/mtd/spi/sf_probe.c index e35b917..678b81c 100644 --- a/drivers/mtd/spi/sf_probe.c +++ b/drivers/mtd/spi/sf_probe.c @@ -120,7 +120,7 @@ static int spi_flash_std_read(struct udevice *dev, u32 offset, size_t len, { struct spi_flash *flash = dev_get_uclass_priv(dev);

- return spi_flash_cmd_read_ops(flash, offset, len, buf); + return flash->read(flash, offset, len, buf); }

int spi_flash_std_write(struct udevice *dev, u32 offset, size_t len, @@ -128,23 +128,14 @@ int spi_flash_std_write(struct udevice *dev, u32 offset, size_t len, { struct spi_flash *flash = dev_get_uclass_priv(dev);

-#if defined(CONFIG_SPI_FLASH_SST) - if (flash->flags & SNOR_F_SST_WR) { - if (flash->spi->op_mode_tx & SPI_OPM_TX_BP) - return sst_write_bp(flash, offset, len, buf); - else - return sst_write_wp(flash, offset, len, buf); - } -#endif - - return spi_flash_cmd_write_ops(flash, offset, len, buf); + return flash->write(flash, offset, len, buf); }

int spi_flash_std_erase(struct udevice *dev, u32 offset, size_t len) { struct spi_flash *flash = dev_get_uclass_priv(dev);

- return spi_flash_cmd_erase_ops(flash, offset, len); + return flash->erase(flash, offset, len); }

int spi_flash_std_probe(struct udevice *dev) diff --git a/include/spi_flash.h b/include/spi_flash.h index f25b3e7..721b358 100644 --- a/include/spi_flash.h +++ b/include/spi_flash.h @@ -94,23 +94,10 @@ struct spi_flash { int (*flash_lock)(struct spi_flash *flash, u32 ofs, size_t len); int (*flash_unlock)(struct spi_flash *flash, u32 ofs, size_t len); int (*flash_is_locked)(struct spi_flash *flash, u32 ofs, size_t len); -#ifndef CONFIG_DM_SPI_FLASH - /* - * These are not strictly needed for driver model, but keep them here - * while the transition is in progress. - * - * Normally each driver would provide its own operations, but for - * SPI flash most chips use the same algorithms. One approach is - * to create a 'common' SPI flash device which knows how to talk - * to most devices, and then allow other drivers to be used instead - * if required, perhaps with a way of scanning through the list to - * find the driver that matches the device. - */ int (*read)(struct spi_flash *flash, u32 offset, size_t len, void *buf); int (*write)(struct spi_flash *flash, u32 offset, size_t len, const void *buf); int (*erase)(struct spi_flash *flash, u32 offset, size_t len); -#endif };

struct dm_spi_flash_ops {

spi_flash_probe_tail code looks not in proper shape to add more functionalities. hence refactorized so-that it's more readable and hence we may extend more functionalies to it.

Cc: Bin Meng bmeng.cn@gmail.com Cc: Troy Kisky troy.kisky@boundarydevices.com Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_internal.h | 3 +- drivers/mtd/spi/sf_ops.c | 7 ++-- drivers/mtd/spi/sf_probe.c | 74 ++++++++++++++++++------------------------- 3 files changed, 34 insertions(+), 50 deletions(-)

diff --git a/drivers/mtd/spi/sf_internal.h b/drivers/mtd/spi/sf_internal.h index acf76e1..fda49e9 100644 --- a/drivers/mtd/spi/sf_internal.h +++ b/drivers/mtd/spi/sf_internal.h @@ -209,7 +209,6 @@ void spi_flash_mtd_unregister(void);

/** * spi_flash_scan - scan the SPI FLASH - * @spi: the spi slave structure * @flash: the spi flash structure * * The drivers can use this fuction to scan the SPI FLASH. @@ -218,6 +217,6 @@ void spi_flash_mtd_unregister(void); * * Return: 0 for success, others for failure. */ -int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash); +int spi_flash_scan(struct spi_flash *flash);

#endif /* _SF_INTERNAL_H_ */ diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 1ee8a7c..3705534 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -896,7 +896,7 @@ int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash) } #endif /* CONFIG_IS_ENABLED(OF_CONTROL) */

-int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash) +int spi_flash_scan(struct spi_flash *flash) { const struct spi_flash_params *params; u16 jedec, ext_jedec; @@ -905,7 +905,7 @@ int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash) int ret;

/* Read the ID codes */ - ret = spi_flash_cmd(spi, CMD_READ_ID, idcode, sizeof(idcode)); + ret = spi_flash_cmd(flash->spi, CMD_READ_ID, idcode, sizeof(idcode)); if (ret) { printf("SF: Failed to get idcodes\n"); return -EINVAL; @@ -946,9 +946,8 @@ int spi_flash_scan(struct spi_slave *spi, struct spi_flash *flash) write_sr(flash, 0);

/* Assign spi data */ - flash->spi = spi; flash->name = params->name; - flash->memory_map = spi->memory_map; + flash->memory_map = flash->spi->memory_map; flash->dual_flash = flash->spi->option;

/* Assign spi flash flags */ diff --git a/drivers/mtd/spi/sf_probe.c b/drivers/mtd/spi/sf_probe.c index 60856f9..ea24fa0 100644 --- a/drivers/mtd/spi/sf_probe.c +++ b/drivers/mtd/spi/sf_probe.c @@ -17,49 +17,11 @@

#include "sf_internal.h"

-/** - * spi_flash_probe_slave() - Probe for a SPI flash device on a bus - * - * @spi: Bus to probe - * @flashp: Pointer to place to put flash info, which may be NULL if the - * space should be allocated - */ -int spi_flash_probe_slave(struct spi_slave *spi, struct spi_flash *flash) -{ - int ret; - - /* Setup spi_slave */ - if (!spi) { - printf("SF: Failed to set up slave\n"); - return -ENODEV; - } - - /* Claim spi bus */ - ret = spi_claim_bus(spi); - if (ret) { - debug("SF: Failed to claim SPI bus: %d\n", ret); - return ret; - } - - ret = spi_flash_scan(spi, flash); - if (ret) { - ret = -EINVAL; - goto err_read_id; - } - -#ifdef CONFIG_SPI_FLASH_MTD - ret = spi_flash_mtd_register(flash); -#endif - -err_read_id: - spi_release_bus(spi); - return ret; -} - #ifndef CONFIG_DM_SPI_FLASH struct spi_flash *spi_flash_probe_tail(struct spi_slave *bus) { struct spi_flash *flash; + int ret;

/* Allocate space if needed (not used by sf-uclass */ flash = calloc(1, sizeof(*flash)); @@ -68,13 +30,37 @@ struct spi_flash *spi_flash_probe_tail(struct spi_slave *bus) return NULL; }

- if (spi_flash_probe_slave(bus, flash)) { - spi_free_slave(bus); - free(flash); - return NULL; + flash->spi = bus; + + /* Claim spi bus */ + ret = spi_claim_bus(bus); + if (ret) { + debug("SF: Failed to claim SPI bus: %d\n", ret); + goto err_claim; }

+ ret = spi_flash_scan(flash); + if (ret) + goto err_scan; + +#ifdef CONFIG_SPI_FLASH_MTD + ret = spi_flash_mtd_register(flash); + if (ret) { + printf("SF: failed to register mtd device: %d\n", ret); + goto err_mtd; + } +#endif return flash; + +#ifdef CONFIG_SPI_FLASH_MTD +err_mtd: + spi_free_slave(bus); +#endif +err_scan: + spi_release_bus(bus); +err_claim: + free(flash); + return NULL; }

struct spi_flash *spi_flash_probe(unsigned int busnum, unsigned int cs, @@ -154,7 +140,7 @@ int spi_flash_std_probe(struct udevice *dev) return ret; }

- ret = spi_flash_scan(slave, flash); + ret = spi_flash_scan(flash); if (ret) { ret = -EINVAL; goto err_read_id;

spi_flash_probe_tail code looks not in proper shape to add more functionalities. hence refactorized so-that it's more readable and hence we may extend more functionalies to it.

Cc: Bin Meng bmeng.cn@gmail.com Cc: Troy Kisky troy.kisky@boundarydevices.com Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_probe.c | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/drivers/mtd/spi/sf_probe.c b/drivers/mtd/spi/sf_probe.c index ea24fa0..603c6bc 100644 --- a/drivers/mtd/spi/sf_probe.c +++ b/drivers/mtd/spi/sf_probe.c @@ -123,15 +123,12 @@ int spi_flash_std_erase(struct udevice *dev, u32 offset, size_t len)

int spi_flash_std_probe(struct udevice *dev) { - struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev); + struct spi_flash *flash = dev_get_uclass_priv(dev); struct spi_slave *slave = dev_get_parent_priv(dev); - struct spi_flash *flash; int ret;

- debug("%s: slave=%p, cs=%d\n", __func__, slave, plat->cs); - - flash = dev_get_uclass_priv(dev); flash->dev = dev; + flash->spi = slave;

/* Claim spi bus */ ret = spi_claim_bus(slave); @@ -143,14 +140,23 @@ int spi_flash_std_probe(struct udevice *dev) ret = spi_flash_scan(flash); if (ret) { ret = -EINVAL; - goto err_read_id; + goto err_scan; }

#ifdef CONFIG_SPI_FLASH_MTD ret = spi_flash_mtd_register(flash); + if (ret) { + printf("SF: failed to register mtd device: %d\n", ret); + goto err_mtd; + } #endif + return ret;

-err_read_id: +#ifdef CONFIG_SPI_FLASH_MTD +err_mtd: + spi_free_slave(slave); +#endif +err_scan: spi_release_bus(slave); return ret; }

Add SPL_MTD_SUPPORT to ZYNQ_QSPI SPL.

Cc: Michal Simek michal.simek@xilinx.com Signed-off-by: Jagan Teki jteki@openedev.com --- include/configs/zynq-common.h | 1 + 1 file changed, 1 insertion(+)

diff --git a/include/configs/zynq-common.h b/include/configs/zynq-common.h index fa83ac7..a54fa26 100644 --- a/include/configs/zynq-common.h +++ b/include/configs/zynq-common.h @@ -354,6 +354,7 @@

/* qspi mode is working fine */ #ifdef CONFIG_ZYNQ_QSPI +#define CONFIG_SPL_MTD_SUPPORT #define CONFIG_SPL_SPI_SUPPORT #define CONFIG_SPL_SPI_LOAD #define CONFIG_SPL_SPI_FLASH_SUPPORT

This patch adds mtd_info support to spi_flash layer, MTD has proven core for flash operations so adding MTD to spi_flash will extends more functionality.

Reviewed-by: Heiko Schocher hs@denx.de Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_ops.c | 40 +++++++++++++++++++++++----------------- drivers/mtd/spi/sf_probe.c | 28 ++++++++++++++++++++-------- include/spi_flash.h | 4 ++++ 3 files changed, 47 insertions(+), 25 deletions(-)

diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 3705534..c9f0bbd 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -15,6 +15,7 @@ #include <spi.h> #include <spi_flash.h> #include <linux/log2.h> +#include <linux/mtd/mtd.h>

#include "sf_internal.h"

@@ -177,8 +178,8 @@ static void spi_flash_dual(struct spi_flash *flash, u32 *addr) { switch (flash->dual_flash) { case SF_DUAL_STACKED_FLASH: - if (*addr >= (flash->size >> 1)) { - *addr -= flash->size >> 1; + if (*addr >= (flash->mtd->size >> 1)) { + *addr -= flash->mtd->size >> 1; flash->spi->flags |= SPI_XFER_U_PAGE; } else { flash->spi->flags &= ~SPI_XFER_U_PAGE; @@ -898,6 +899,7 @@ int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash)

int spi_flash_scan(struct spi_flash *flash) { + struct mtd_info *mtd = flash->mtd; const struct spi_flash_params *params; u16 jedec, ext_jedec; u8 idcode[5]; @@ -947,6 +949,9 @@ int spi_flash_scan(struct spi_flash *flash)

/* Assign spi data */ flash->name = params->name; + mtd->type = MTD_NORFLASH; + mtd->writesize = 1; + mtd->flags = MTD_CAP_NORFLASH; flash->memory_map = flash->spi->memory_map; flash->dual_flash = flash->spi->option;

@@ -955,17 +960,17 @@ int spi_flash_scan(struct spi_flash *flash) flash->flags |= SNOR_F_SST_WR;

/* Assign spi_flash ops */ - flash->write = spi_flash_cmd_write_ops; + mtd->_write = spi_flash_cmd_write_ops; #if defined(CONFIG_SPI_FLASH_SST) if (flash->flags & SNOR_F_SST_WR) { if (flash->spi->op_mode_tx & SPI_OPM_TX_BP) - flash->write = sst_write_bp; + mtd->_write = sst_write_bp; else - flash->write = sst_write_wp; + mtd->_write = sst_write_wp; } #endif - flash->erase = spi_flash_cmd_erase_ops; - flash->read = spi_flash_cmd_read_ops; + mtd->_erase = spi_flash_cmd_erase_ops; + mtd->_read = spi_flash_cmd_read_ops;

/* lock hooks are flash specific - assign them based on idcode0 */ switch (idcode[0]) { @@ -998,27 +1003,28 @@ int spi_flash_scan(struct spi_flash *flash) flash->page_size = 256; } flash->page_size <<= flash->shift; + mtd->writebufsize = flash->page_size; flash->sector_size = params->sector_size << flash->shift; - flash->size = flash->sector_size * params->nr_sectors << flash->shift; + mtd->size = flash->sector_size * params->nr_sectors << flash->shift; #ifdef CONFIG_SF_DUAL_FLASH if (flash->dual_flash & SF_DUAL_STACKED_FLASH) - flash->size <<= 1; + mtd->size <<= 1; #endif

/* Compute erase sector and command */ if (params->flags & SECT_4K) { flash->erase_cmd = CMD_ERASE_4K; - flash->erase_size = 4096 << flash->shift; + mtd->erasesize = 4096 << flash->shift; } else if (params->flags & SECT_32K) { flash->erase_cmd = CMD_ERASE_32K; - flash->erase_size = 32768 << flash->shift; + mtd->erasesize = 32768 << flash->shift; } else { flash->erase_cmd = CMD_ERASE_64K; - flash->erase_size = flash->sector_size; + mtd->erasesize = flash->sector_size; }

/* Now erase size becomes valid sector size */ - flash->sector_size = flash->erase_size; + flash->sector_size = mtd->erasesize;

/* Look for the fastest read cmd */ cmd = fls(params->e_rd_cmd & flash->spi->op_mode_rx); @@ -1090,8 +1096,8 @@ int spi_flash_scan(struct spi_flash *flash) #ifndef CONFIG_SPL_BUILD printf("SF: Detected %s with page size ", flash->name); print_size(flash->page_size, ", erase size "); - print_size(flash->erase_size, ", total "); - print_size(flash->size, ""); + print_size(mtd->erasesize, ", total "); + print_size(mtd->size, ""); if (flash->memory_map) printf(", mapped at %p", flash->memory_map); puts("\n"); @@ -1099,9 +1105,9 @@ int spi_flash_scan(struct spi_flash *flash)

#ifndef CONFIG_SPI_FLASH_BAR if (((flash->dual_flash == SF_SINGLE_FLASH) && - (flash->size > SPI_FLASH_16MB_BOUN)) || + (mtd->size > SPI_FLASH_16MB_BOUN)) || ((flash->dual_flash > SF_SINGLE_FLASH) && - (flash->size > SPI_FLASH_16MB_BOUN << 1))) { + (mtd->size > SPI_FLASH_16MB_BOUN << 1))) { puts("SF: Warning - Only lower 16MiB accessible,"); puts(" Full access #define CONFIG_SPI_FLASH_BAR\n"); } diff --git a/drivers/mtd/spi/sf_probe.c b/drivers/mtd/spi/sf_probe.c index 603c6bc..a88d74e 100644 --- a/drivers/mtd/spi/sf_probe.c +++ b/drivers/mtd/spi/sf_probe.c @@ -14,9 +14,17 @@ #include <malloc.h> #include <spi.h> #include <spi_flash.h> +#include <linux/mtd/mtd.h>

#include "sf_internal.h"

+struct spi_flash_priv { +#ifndef CONFIG_DM_SPI_FLASH + struct spi_flash flash; +#endif + struct mtd_info mtd; +}; + #ifndef CONFIG_DM_SPI_FLASH struct spi_flash *spi_flash_probe_tail(struct spi_slave *bus) { @@ -123,12 +131,19 @@ int spi_flash_std_erase(struct udevice *dev, u32 offset, size_t len)

int spi_flash_std_probe(struct udevice *dev) { - struct spi_flash *flash = dev_get_uclass_priv(dev); + struct spi_flash_priv *priv = dev_get_priv(dev); struct spi_slave *slave = dev_get_parent_priv(dev); + struct spi_flash *flash; int ret;

- flash->dev = dev; + flash = dev_get_uclass_priv(dev); + flash->mtd = &priv->mtd; + flash->spi = slave; + flash->priv = priv; + + priv->mtd.priv = flash; + flash->dev = dev;

/* Claim spi bus */ ret = spi_claim_bus(slave); @@ -143,19 +158,16 @@ int spi_flash_std_probe(struct udevice *dev) goto err_scan; }

-#ifdef CONFIG_SPI_FLASH_MTD - ret = spi_flash_mtd_register(flash); + ret = add_mtd_device(&priv->mtd); if (ret) { printf("SF: failed to register mtd device: %d\n", ret); goto err_mtd; } -#endif + return ret;

-#ifdef CONFIG_SPI_FLASH_MTD err_mtd: spi_free_slave(slave); -#endif err_scan: spi_release_bus(slave); return ret; @@ -177,7 +189,7 @@ U_BOOT_DRIVER(spi_flash_std) = { .id = UCLASS_SPI_FLASH, .of_match = spi_flash_std_ids, .probe = spi_flash_std_probe, - .priv_auto_alloc_size = sizeof(struct spi_flash), + .priv_auto_alloc_size = sizeof(struct spi_flash_priv), .ops = &spi_flash_std_ops, };

diff --git a/include/spi_flash.h b/include/spi_flash.h index 721b358..15f7471 100644 --- a/include/spi_flash.h +++ b/include/spi_flash.h @@ -37,6 +37,7 @@ struct spi_slave; * struct spi_flash - SPI flash structure * * @spi: SPI slave + * @mtd: point to a mtd_info structure * @dev: SPI flash device * @name: Name of SPI flash * @dual_flash: Indicates dual flash memories - dual stacked, parallel @@ -54,6 +55,7 @@ struct spi_slave; * @write_cmd: Write cmd - page and quad program. * @dummy_byte: Dummy cycles for read operation. * @memory_map: Address of read-only SPI flash access + * @priv: the private data * @flash_lock: lock a region of the SPI Flash * @flash_unlock: unlock a region of the SPI Flash * @flash_is_locked: check if a region of the SPI Flash is completely locked @@ -67,6 +69,7 @@ struct spi_slave; */ struct spi_flash { struct spi_slave *spi; + struct mtd_info *mtd; #ifdef CONFIG_DM_SPI_FLASH struct udevice *dev; #endif @@ -90,6 +93,7 @@ struct spi_flash { u8 dummy_byte;

void *memory_map; + void *priv;

int (*flash_lock)(struct spi_flash *flash, u32 ofs, size_t len); int (*flash_unlock)(struct spi_flash *flash, u32 ofs, size_t len);

Since mtd got added, replace flash->size with mtd->size.

Reviewed-by: Heiko Schocher hs@denx.de Signed-off-by: Jagan Teki jteki@openedev.com --- common/cmd_sf.c | 16 ++++++++-------- drivers/mtd/spi/sf_ops.c | 23 +++++++++++++---------- include/spi_flash.h | 2 -- 3 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/common/cmd_sf.c b/common/cmd_sf.c index 42862d9..d9f1bd1 100644 --- a/common/cmd_sf.c +++ b/common/cmd_sf.c @@ -275,13 +275,13 @@ static int do_spi_flash_read_write(int argc, char * const argv[]) return -1;

if (mtd_arg_off_size(argc - 2, &argv[2], &dev, &offset, &len, - &maxsize, MTD_DEV_TYPE_NOR, flash->size)) + &maxsize, MTD_DEV_TYPE_NOR, flash->mtd->size)) return -1;

/* Consistency checking */ - if (offset + len > flash->size) { - printf("ERROR: attempting %s past flash size (%#x)\n", - argv[0], flash->size); + if (offset + len > flash->mtd->size) { + printf("ERROR: attempting %s past flash size (0x%llx)\n", + argv[0], flash->mtd->size); return 1; }

@@ -327,7 +327,7 @@ static int do_spi_flash_erase(int argc, char * const argv[]) return -1;

if (mtd_arg_off(argv[1], &dev, &offset, &len, &maxsize, - MTD_DEV_TYPE_NOR, flash->size)) + MTD_DEV_TYPE_NOR, flash->mtd->size)) return -1;

ret = sf_parse_len_arg(argv[2], &size); @@ -335,9 +335,9 @@ static int do_spi_flash_erase(int argc, char * const argv[]) return -1;

/* Consistency checking */ - if (offset + size > flash->size) { - printf("ERROR: attempting %s past flash size (%#x)\n", - argv[0], flash->size); + if (offset + size > flash->mtd->size) { + printf("ERROR: attempting %s past flash size (0x%llx)\n", + argv[0], flash->mtd->size); return 1; }

diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 1356161..5a7f5d5 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -149,7 +149,7 @@ static int spi_flash_read_bar(struct spi_flash *flash, u8 idcode0) u8 curr_bank = 0; int ret;

- if (flash->size <= SPI_FLASH_16MB_BOUN) + if (flash->mtd->size <= SPI_FLASH_16MB_BOUN) goto bank_end;

switch (idcode0) { @@ -651,6 +651,7 @@ static int sst_write_bp(struct mtd_info *mtd, loff_t offset, size_t len, static void stm_get_locked_range(struct spi_flash *flash, u8 sr, loff_t *ofs, u32 *len) { + struct mtd_info *mtd = flash->mtd; u8 mask = SR_BP2 | SR_BP1 | SR_BP0; int shift = ffs(mask) - 1; int pow; @@ -661,8 +662,8 @@ static void stm_get_locked_range(struct spi_flash *flash, u8 sr, loff_t *ofs, *len = 0; } else { pow = ((sr & mask) ^ mask) >> shift; - *len = flash->size >> pow; - *ofs = flash->size - *len; + *len = mtd->size >> pow; + *ofs = mtd->size - *len; } }

@@ -724,6 +725,7 @@ int stm_is_locked(struct spi_flash *flash, u32 ofs, size_t len) */ int stm_lock(struct spi_flash *flash, u32 ofs, size_t len) { + struct mtd_info *mtd = flash->mtd; u8 status_old, status_new; u8 mask = SR_BP2 | SR_BP1 | SR_BP0; u8 shift = ffs(mask) - 1, pow, val; @@ -734,12 +736,12 @@ int stm_lock(struct spi_flash *flash, u32 ofs, size_t len) return ret;

/* SPI NOR always locks to the end */ - if (ofs + len != flash->size) { + if (ofs + len != mtd->size) { /* Does combined region extend to end? */ - if (!stm_is_locked_sr(flash, ofs + len, flash->size - ofs - len, + if (!stm_is_locked_sr(flash, ofs + len, mtd->size - ofs - len, status_old)) return -EINVAL; - len = flash->size - ofs; + len = mtd->size - ofs; }

/* @@ -751,7 +753,7 @@ int stm_lock(struct spi_flash *flash, u32 ofs, size_t len) * * pow = ceil(log2(size / len)) = log2(size) - floor(log2(len)) */ - pow = ilog2(flash->size) - ilog2(len); + pow = ilog2(mtd->size) - ilog2(len); val = mask - (pow << shift); if (val & ~mask) return -EINVAL; @@ -778,6 +780,7 @@ int stm_lock(struct spi_flash *flash, u32 ofs, size_t len) */ int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len) { + struct mtd_info *mtd = flash->mtd; uint8_t status_old, status_new; u8 mask = SR_BP2 | SR_BP1 | SR_BP0; u8 shift = ffs(mask) - 1, pow, val; @@ -800,8 +803,8 @@ int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len) * * pow = floor(log2(size / len)) = log2(size) - ceil(log2(len)) */ - pow = ilog2(flash->size) - order_base_2(flash->size - (ofs + len)); - if (ofs + len == flash->size) { + pow = ilog2(mtd->size) - order_base_2(mtd->size - (ofs + len)); + if (ofs + len == mtd->size) { val = 0; /* fully unlocked */ } else { val = mask - (pow << shift); @@ -908,7 +911,7 @@ int spi_flash_decode_fdt(const void *blob, struct spi_flash *flash) return 0; }

- if (flash->size != size) { + if (flash->mtd->size != size) { debug("%s: Memory map must cover entire device\n", __func__); return -1; } diff --git a/include/spi_flash.h b/include/spi_flash.h index 2e81a14..0fee203 100644 --- a/include/spi_flash.h +++ b/include/spi_flash.h @@ -44,7 +44,6 @@ struct spi_slave; * @dual_flash: Indicates dual flash memories - dual stacked, parallel * @shift: Flash shift useful in dual parallel * @flags: Indication of spi flash flags - * @size: Total flash size * @page_size: Write (page) size * @sector_size: Sector size * @erase_size: Erase size @@ -73,7 +72,6 @@ struct spi_flash { u8 shift; u16 flags;

- u32 size; u32 page_size; u32 sector_size; u32 erase_size;

Since mtd_info ops got introduced, just drop the unneeded dm_spi_flash operations.

Reviewed-by: Heiko Schocher hs@denx.de Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf-uclass.c | 39 -------------------- include/spi_flash.h | 90 +++++++-------------------------------------- 2 files changed, 14 insertions(+), 115 deletions(-)

diff --git a/drivers/mtd/spi/sf-uclass.c b/drivers/mtd/spi/sf-uclass.c index 72e0f6b..5cdbd1b 100644 --- a/drivers/mtd/spi/sf-uclass.c +++ b/drivers/mtd/spi/sf-uclass.c @@ -11,24 +11,6 @@ #include <dm/device-internal.h> #include "sf_internal.h"

-DECLARE_GLOBAL_DATA_PTR; - -int spi_flash_read_dm(struct udevice *dev, u32 offset, size_t len, void *buf) -{ - return sf_get_ops(dev)->read(dev, offset, len, buf); -} - -int spi_flash_write_dm(struct udevice *dev, u32 offset, size_t len, - const void *buf) -{ - return sf_get_ops(dev)->write(dev, offset, len, buf); -} - -int spi_flash_erase_dm(struct udevice *dev, u32 offset, size_t len) -{ - return sf_get_ops(dev)->erase(dev, offset, len); -} - /* * TODO(sjg@chromium.org): This is an old-style function. We should remove * it when all SPI flash drivers use dm @@ -74,29 +56,8 @@ int spi_flash_remove(struct udevice *dev) return device_remove(dev); }

-static int spi_flash_post_bind(struct udevice *dev) -{ -#if defined(CONFIG_NEEDS_MANUAL_RELOC) - struct dm_spi_flash_ops *ops = sf_get_ops(dev); - static int reloc_done; - - if (!reloc_done) { - if (ops->read) - ops->read += gd->reloc_off; - if (ops->write) - ops->write += gd->reloc_off; - if (ops->erase) - ops->erase += gd->reloc_off; - - reloc_done++; - } -#endif - return 0; -} - UCLASS_DRIVER(spi_flash) = { .id = UCLASS_SPI_FLASH, .name = "spi_flash", - .post_bind = spi_flash_post_bind, .per_device_auto_alloc_size = sizeof(struct spi_flash), }; diff --git a/include/spi_flash.h b/include/spi_flash.h index d66a8ec..dd48c97 100644 --- a/include/spi_flash.h +++ b/include/spi_flash.h @@ -91,65 +91,6 @@ struct spi_flash { int (*flash_is_locked)(struct spi_flash *flash, u32 ofs, size_t len); };

-struct dm_spi_flash_ops { - int (*read)(struct udevice *dev, u32 offset, size_t len, void *buf); - int (*write)(struct udevice *dev, u32 offset, size_t len, - const void *buf); - int (*erase)(struct udevice *dev, u32 offset, size_t len); -}; - -/* Access the serial operations for a device */ -#define sf_get_ops(dev) ((struct dm_spi_flash_ops *)(dev)->driver->ops) - -#ifdef CONFIG_DM_SPI_FLASH -/** - * spi_flash_read_dm() - Read data from SPI flash - * - * @dev: SPI flash device - * @offset: Offset into device in bytes to read from - * @len: Number of bytes to read - * @buf: Buffer to put the data that is read - * @return 0 if OK, -ve on error - */ -int spi_flash_read_dm(struct udevice *dev, u32 offset, size_t len, void *buf); - -/** - * spi_flash_write_dm() - Write data to SPI flash - * - * @dev: SPI flash device - * @offset: Offset into device in bytes to write to - * @len: Number of bytes to write - * @buf: Buffer containing bytes to write - * @return 0 if OK, -ve on error - */ -int spi_flash_write_dm(struct udevice *dev, u32 offset, size_t len, - const void *buf); - -/** - * spi_flash_erase_dm() - Erase blocks of the SPI flash - * - * Note that @len must be a muiltiple of the flash sector size. - * - * @dev: SPI flash device - * @offset: Offset into device in bytes to start erasing - * @len: Number of bytes to erase - * @return 0 if OK, -ve on error - */ -int spi_flash_erase_dm(struct udevice *dev, u32 offset, size_t len); - -int spi_flash_probe_bus_cs(unsigned int busnum, unsigned int cs, - unsigned int max_hz, unsigned int spi_mode, - struct udevice **devp); - -/* Compatibility function - this is the old U-Boot API */ -struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs, - unsigned int max_hz, unsigned int spi_mode); - -/* Compatibility function - this is the old U-Boot API */ -void spi_flash_free(struct spi_flash *flash); - -int spi_flash_remove(struct udevice *flash); - static inline int spi_flash_read(struct spi_flash *flash, u32 offset, size_t len, void *buf) { @@ -175,6 +116,20 @@ static inline int spi_flash_erase(struct spi_flash *flash, u32 offset, return mtd_erase(flash->mtd, &instr); }

+#ifdef CONFIG_DM_SPI_FLASH +int spi_flash_probe_bus_cs(unsigned int busnum, unsigned int cs, + unsigned int max_hz, unsigned int spi_mode, + struct udevice **devp); + +/* Compatibility function - this is the old U-Boot API */ +struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs, + unsigned int max_hz, unsigned int spi_mode); + +/* Compatibility function - this is the old U-Boot API */ +void spi_flash_free(struct spi_flash *flash); + +int spi_flash_remove(struct udevice *flash); + struct sandbox_state;

int sandbox_sf_bind_emul(struct sandbox_state *state, int busnum, int cs, @@ -200,23 +155,6 @@ struct spi_flash *spi_flash_probe_fdt(const void *blob, int slave_node,

void spi_flash_free(struct spi_flash *flash);

-static inline int spi_flash_read(struct spi_flash *flash, u32 offset, - size_t len, void *buf) -{ - return flash->read(flash, offset, len, buf); -} - -static inline int spi_flash_write(struct spi_flash *flash, u32 offset, - size_t len, const void *buf) -{ - return flash->write(flash, offset, len, buf); -} - -static inline int spi_flash_erase(struct spi_flash *flash, u32 offset, - size_t len) -{ - return flash->erase(flash, offset, len); -} #endif

static inline int spi_flash_protect(struct spi_flash *flash, u32 ofs, u32 len,

Since the spi-flash framework itself is using core MTD functionalities this patch uses lock operation from mtd.

Cc: Fabio Estevam fabio.estevam@freescale.com Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_internal.h | 9 - drivers/mtd/spi/sf_ops.c | 404 ++++++++++++++++++++++-------------------- include/spi_flash.h | 34 ++-- 3 files changed, 229 insertions(+), 218 deletions(-)

diff --git a/drivers/mtd/spi/sf_internal.h b/drivers/mtd/spi/sf_internal.h index fda49e9..677f582 100644 --- a/drivers/mtd/spi/sf_internal.h +++ b/drivers/mtd/spi/sf_internal.h @@ -163,15 +163,6 @@ int spi_flash_cmd_read(struct spi_slave *spi, const u8 *cmd, int spi_flash_cmd_write(struct spi_slave *spi, const u8 *cmd, size_t cmd_len, const void *data, size_t data_len);

-/* Lock stmicro spi flash region */ -int stm_lock(struct spi_flash *flash, u32 ofs, size_t len); - -/* Unlock stmicro spi flash region */ -int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len); - -/* Check if a stmicro spi flash region is completely locked */ -int stm_is_locked(struct spi_flash *flash, u32 ofs, size_t len); - /* Enable writing on the SPI flash */ static inline int spi_flash_cmd_write_enable(struct spi_flash *flash) { diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 2e279e6..4e80d66 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -258,6 +258,205 @@ static int spi_flash_cmd_wait_ready(struct spi_flash *flash, return -ETIMEDOUT; }

+#if defined(CONFIG_SPI_FLASH_STMICRO) || defined(CONFIG_SPI_FLASH_SST) +static void stm_get_locked_range(struct spi_flash *flash, u8 sr, loff_t *ofs, + uint64_t *len) +{ + struct mtd_info *mtd = flash->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; + *ofs = mtd->size - *len; + } +} + +/* + * Return 1 if the entire region is locked, 0 otherwise + */ +static int stm_is_locked_sr(struct spi_flash *flash, loff_t ofs, uint64_t len, + u8 sr) +{ + loff_t lock_offs; + uint64_t lock_len; + + stm_get_locked_range(flash, sr, &lock_offs, &lock_len); + + return (ofs + len <= lock_offs + lock_len) && (ofs >= lock_offs); +} + +/* + * 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_flash *flash, loff_t ofs, uint64_t len) +{ + int status; + u8 sr; + + status = read_sr(flash, &sr); + if (status < 0) + return status; + + return stm_is_locked_sr(flash, ofs, len, sr); +} + +/* + * Lock a region of the flash. Compatible with ST Micro and similar flash. + * Supports only the block protection bits BP{0,1,2} in the status register + * (SR). Does not support these features found in newer SR bitfields: + * - TB: top/bottom protect - only handle TB=0 (top protect) + * - SEC: sector/block protect - only handle SEC=0 (block protect) + * - CMP: complement protect - only support CMP=0 (range is not complemented) + * + * 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 + * + * Returns negative on errors, 0 on success. + */ +static int stm_lock(struct spi_flash *flash, loff_t ofs, uint64_t len) +{ + struct mtd_info *mtd = flash->mtd; + u8 status_old, status_new; + u8 mask = SR_BP2 | SR_BP1 | SR_BP0; + u8 shift = ffs(mask) - 1, pow, val; + int ret; + + ret = read_sr(flash, &status_old); + if (ret < 0) + return ret; + + /* SPI NOR always locks to the end */ + if (ofs + len != mtd->size) { + /* Does combined region extend to end? */ + if (!stm_is_locked_sr(flash, ofs + len, mtd->size - ofs - len, + status_old)) + return -EINVAL; + len = mtd->size - ofs; + } + + /* + * 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)) + */ + pow = ilog2(mtd->size) - ilog2(len); + val = mask - (pow << shift); + if (val & ~mask) + return -EINVAL; + + /* Don't "lock" with no region! */ + if (!(val & mask)) + return -EINVAL; + + status_new = (status_old & ~mask) | val; + + /* Only modify protection if it will not unlock other areas */ + if ((status_new & mask) <= (status_old & mask)) + return -EINVAL; + + write_sr(flash, status_new); + + return 0; +} + +/* + * Unlock a region of the flash. See stm_lock() for more info + * + * Returns negative on errors, 0 on success. + */ +static int stm_unlock(struct spi_flash *flash, loff_t ofs, uint64_t len) +{ + struct mtd_info *mtd = flash->mtd; + uint8_t status_old, status_new; + u8 mask = SR_BP2 | SR_BP1 | SR_BP0; + u8 shift = ffs(mask) - 1, pow, val; + int ret; + + ret = read_sr(flash, &status_old); + if (ret < 0) + return ret; + + /* Cannot unlock; would unlock larger region than requested */ + if (stm_is_locked_sr(flash, status_old, ofs - mtd->erasesize, + mtd->erasesize)) + return -EINVAL; + /* + * 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)) + */ + pow = ilog2(mtd->size) - order_base_2(mtd->size - (ofs + len)); + if (ofs + len == mtd->size) { + val = 0; /* fully unlocked */ + } else { + val = mask - (pow << shift); + /* Some power-of-two sizes are not supported */ + if (val & ~mask) + return -EINVAL; + } + + status_new = (status_old & ~mask) | val; + + /* Only modify protection if it will not lock other areas */ + if ((status_new & mask) >= (status_old & mask)) + return -EINVAL; + + write_sr(flash, status_new); + + return 0; +} +#endif /* CONFIG_SPI_FLASH_STMICRO */ + +static int spi_flash_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) +{ + struct spi_flash *flash = mtd->priv; + + return flash->flash_lock(flash, ofs, len); +} + +static int spi_flash_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) +{ + struct spi_flash *flash = mtd->priv; + + return flash->flash_unlock(flash, ofs, len); +} + +static int spi_flash_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len) +{ + struct spi_flash *flash = mtd->priv; + + return flash->flash_is_locked(flash, ofs, len); +} + int spi_flash_write_common(struct spi_flash *flash, const u8 *cmd, size_t cmd_len, const void *buf, size_t buf_len) { @@ -315,8 +514,8 @@ static int spi_flash_cmd_erase_ops(struct mtd_info *mtd, offset = instr->addr; len = instr->len;

- if (flash->flash_is_locked) { - if (flash->flash_is_locked(flash, offset, len) > 0) { + if (mtd->_is_locked) { + if (mtd->_is_locked(mtd, offset, len) > 0) { printf("offset 0x%x is protected and cannot be erased\n", offset); return -EINVAL; @@ -373,9 +572,9 @@ static int spi_flash_cmd_write_ops(struct mtd_info *mtd, loff_t offset,

page_size = flash->page_size;

- if (flash->flash_is_locked) { - if (flash->flash_is_locked(flash, offset, len) > 0) { - printf("offset 0x%x is protected and cannot be written\n", + if (mtd->_is_locked) { + if (mtd->_is_locked(mtd, offset, len) > 0) { + printf("offset 0x%llx is protected and cannot be written\n", offset); return -EINVAL; } @@ -647,185 +846,6 @@ static int sst_write_bp(struct mtd_info *mtd, loff_t offset, size_t len, } #endif

-#if defined(CONFIG_SPI_FLASH_STMICRO) || defined(CONFIG_SPI_FLASH_SST) -static void stm_get_locked_range(struct spi_flash *flash, u8 sr, loff_t *ofs, - u32 *len) -{ - struct mtd_info *mtd = flash->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; - *ofs = mtd->size - *len; - } -} - -/* - * Return 1 if the entire region is locked, 0 otherwise - */ -static int stm_is_locked_sr(struct spi_flash *flash, u32 ofs, u32 len, - u8 sr) -{ - loff_t lock_offs; - u32 lock_len; - - stm_get_locked_range(flash, sr, &lock_offs, &lock_len); - - return (ofs + len <= lock_offs + lock_len) && (ofs >= lock_offs); -} - -/* - * 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. - */ -int stm_is_locked(struct spi_flash *flash, u32 ofs, size_t len) -{ - int status; - u8 sr; - - status = read_sr(flash, &sr); - if (status < 0) - return status; - - return stm_is_locked_sr(flash, ofs, len, sr); -} - -/* - * Lock a region of the flash. Compatible with ST Micro and similar flash. - * Supports only the block protection bits BP{0,1,2} in the status register - * (SR). Does not support these features found in newer SR bitfields: - * - TB: top/bottom protect - only handle TB=0 (top protect) - * - SEC: sector/block protect - only handle SEC=0 (block protect) - * - CMP: complement protect - only support CMP=0 (range is not complemented) - * - * 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 - * - * Returns negative on errors, 0 on success. - */ -int stm_lock(struct spi_flash *flash, u32 ofs, size_t len) -{ - struct mtd_info *mtd = flash->mtd; - u8 status_old, status_new; - u8 mask = SR_BP2 | SR_BP1 | SR_BP0; - u8 shift = ffs(mask) - 1, pow, val; - int ret; - - ret = read_sr(flash, &status_old); - if (ret < 0) - return ret; - - /* SPI NOR always locks to the end */ - if (ofs + len != mtd->size) { - /* Does combined region extend to end? */ - if (!stm_is_locked_sr(flash, ofs + len, mtd->size - ofs - len, - status_old)) - return -EINVAL; - len = mtd->size - ofs; - } - - /* - * 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)) - */ - pow = ilog2(mtd->size) - ilog2(len); - val = mask - (pow << shift); - if (val & ~mask) - return -EINVAL; - - /* Don't "lock" with no region! */ - if (!(val & mask)) - return -EINVAL; - - status_new = (status_old & ~mask) | val; - - /* Only modify protection if it will not unlock other areas */ - if ((status_new & mask) <= (status_old & mask)) - return -EINVAL; - - write_sr(flash, status_new); - - return 0; -} - -/* - * Unlock a region of the flash. See stm_lock() for more info - * - * Returns negative on errors, 0 on success. - */ -int stm_unlock(struct spi_flash *flash, u32 ofs, size_t len) -{ - struct mtd_info *mtd = flash->mtd; - uint8_t status_old, status_new; - u8 mask = SR_BP2 | SR_BP1 | SR_BP0; - u8 shift = ffs(mask) - 1, pow, val; - int ret; - - ret = read_sr(flash, &status_old); - if (ret < 0) - return ret; - - /* Cannot unlock; would unlock larger region than requested */ - if (stm_is_locked_sr(flash, status_old, ofs - mtd->erasesize, - mtd->erasesize)) - return -EINVAL; - /* - * 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)) - */ - pow = ilog2(mtd->size) - order_base_2(mtd->size - (ofs + len)); - if (ofs + len == mtd->size) { - val = 0; /* fully unlocked */ - } else { - val = mask - (pow << shift); - /* Some power-of-two sizes are not supported */ - if (val & ~mask) - return -EINVAL; - } - - status_new = (status_old & ~mask) | val; - - /* Only modify protection if it will not lock other areas */ - if ((status_new & mask) >= (status_old & mask)) - return -EINVAL; - - write_sr(flash, status_new); - - return 0; -} -#endif - - #ifdef CONFIG_SPI_FLASH_MACRONIX static int spi_flash_set_qeb_mxic(struct spi_flash *flash) { @@ -996,18 +1016,20 @@ int spi_flash_scan(struct spi_flash *flash) mtd->_erase = spi_flash_cmd_erase_ops; mtd->_read = spi_flash_cmd_read_ops;

- /* lock hooks are flash specific - assign them based on idcode0 */ - switch (idcode[0]) { + /* NOR protection support for STmicro/Micron chips and similar */ #if defined(CONFIG_SPI_FLASH_STMICRO) || defined(CONFIG_SPI_FLASH_SST) - case SPI_FLASH_CFI_MFR_STMICRO: - case SPI_FLASH_CFI_MFR_SST: + if ((idcode[0] == SPI_FLASH_CFI_MFR_STMICRO) || + (idcode[0] == SPI_FLASH_CFI_MFR_SST)) { flash->flash_lock = stm_lock; flash->flash_unlock = stm_unlock; flash->flash_is_locked = stm_is_locked; + } #endif - break; - default: - debug("SF: Lock ops not supported for %02x flash\n", idcode[0]); + + if (flash->flash_lock && flash->flash_unlock && flash->flash_is_locked) { + mtd->_lock = spi_flash_lock; + mtd->_unlock = spi_flash_unlock; + mtd->_is_locked = spi_flash_is_locked; }

/* Compute the flash size */ diff --git a/include/spi_flash.h b/include/spi_flash.h index dd48c97..d617061 100644 --- a/include/spi_flash.h +++ b/include/spi_flash.h @@ -55,9 +55,10 @@ struct spi_slave; * @dummy_byte: Dummy cycles for read operation. * @memory_map: Address of read-only SPI flash access * @priv: the private data - * @flash_lock: lock a region of the SPI Flash - * @flash_unlock: unlock a region of the SPI Flash - * @flash_is_locked: check if a region of the SPI Flash is completely locked + * @flash_lock: [FLASH-SPECIFIC] lock a region of the SPI NOR + * @flash_unlock: [FLASH-SPECIFIC] unlock a region of the SPI NOR + * @flash_is_locked: [FLASH-SPECIFIC] check if a region of the SPI NOR is + * completely locked * return 0 - Success, 1 - Failure */ struct spi_flash { @@ -86,9 +87,9 @@ struct spi_flash { void *memory_map; void *priv;

- int (*flash_lock)(struct spi_flash *flash, u32 ofs, size_t len); - int (*flash_unlock)(struct spi_flash *flash, u32 ofs, size_t len); - int (*flash_is_locked)(struct spi_flash *flash, u32 ofs, size_t len); + int (*flash_lock)(struct spi_flash *flash, loff_t ofs, uint64_t len); + int (*flash_unlock)(struct spi_flash *flash, loff_t ofs, uint64_t len); + int (*flash_is_locked)(struct spi_flash *flash, loff_t ofs, uint64_t len); };

static inline int spi_flash_read(struct spi_flash *flash, u32 offset, @@ -116,6 +117,15 @@ static inline int spi_flash_erase(struct spi_flash *flash, u32 offset, return mtd_erase(flash->mtd, &instr); }

+static inline int spi_flash_protect(struct spi_flash *flash, u32 ofs, u32 len, + bool prot) +{ + if (prot) + return mtd_lock(flash->mtd, ofs, len); + else + return mtd_unlock(flash->mtd, ofs, len); +} + #ifdef CONFIG_DM_SPI_FLASH int spi_flash_probe_bus_cs(unsigned int busnum, unsigned int cs, unsigned int max_hz, unsigned int spi_mode, @@ -157,18 +167,6 @@ void spi_flash_free(struct spi_flash *flash);

#endif

-static inline int spi_flash_protect(struct spi_flash *flash, u32 ofs, u32 len, - bool prot) -{ - if (!flash->flash_lock || !flash->flash_unlock) - return -EOPNOTSUPP; - - if (prot) - return flash->flash_lock(flash, ofs, len); - else - return flash->flash_unlock(flash, ofs, len); -} - void spi_boot(void) __noreturn; void spi_spl_load_image(uint32_t offs, unsigned int size, void *vdst);

Since mtd_info{} ops are used instead of spi_flash{} ops there is no need to check the flash->flags to SNOR_F_SST_WR as sf_ops behaves as a core to handling generic flash functionalities for both dm and non-dm.

Cc: Bin Meng bmeng.cn@gmail.com Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_internal.h | 3 +-- drivers/mtd/spi/sf_ops.c | 6 +----- 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/drivers/mtd/spi/sf_internal.h b/drivers/mtd/spi/sf_internal.h index 677f582..6c4ce77 100644 --- a/drivers/mtd/spi/sf_internal.h +++ b/drivers/mtd/spi/sf_internal.h @@ -52,8 +52,7 @@ enum { #define SST_WR (SST_BP | SST_WP)

enum spi_nor_option_flags { - SNOR_F_SST_WR = (1 << 0), - SNOR_F_USE_FSR = (1 << 1), + SNOR_F_USE_FSR = (1 << 0), };

#define SPI_FLASH_3B_ADDR_LEN 3 diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 4e80d66..4e2845c 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -999,14 +999,10 @@ int spi_flash_scan(struct spi_flash *flash) flash->memory_map = flash->spi->memory_map; flash->dual_flash = flash->spi->option;

- /* Assign spi flash flags */ - if (params->flags & SST_WR) - flash->flags |= SNOR_F_SST_WR; - /* Assign spi_flash ops */ mtd->_write = spi_flash_cmd_write_ops; #if defined(CONFIG_SPI_FLASH_SST) - if (flash->flags & SNOR_F_SST_WR) { + if (params->flags & SST_WR) { if (flash->spi->op_mode_tx & SPI_OPM_TX_BP) mtd->_write = sst_write_bp; else

For assigning read_bar commands in spansion case, break is missing this patch add that break.

Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_ops.c | 1 + 1 file changed, 1 insertion(+)

diff --git a/drivers/mtd/spi/sf_ops.c b/drivers/mtd/spi/sf_ops.c index 4e2845c..bc9cbf7 100644 --- a/drivers/mtd/spi/sf_ops.c +++ b/drivers/mtd/spi/sf_ops.c @@ -156,6 +156,7 @@ static int spi_flash_read_bar(struct spi_flash *flash, u8 idcode0) case SPI_FLASH_CFI_MFR_SPANSION: flash->bank_read_cmd = CMD_BANKADDR_BRRD; flash->bank_write_cmd = CMD_BANKADDR_BRWR; + break; default: flash->bank_read_cmd = CMD_EXTNADDR_RDEAR; flash->bank_write_cmd = CMD_EXTNADDR_WREAR;

No explict spi-flash mtd handling driver, it's been part of spi-flash layer iteself, hence removed it from board configs.

Cc: Heiko Schocher hs@denx.de Signed-off-by: Jagan Teki jteki@openedev.com --- include/configs/aristainetos-common.h | 1 - include/configs/gw_ventana.h | 1 - include/configs/socfpga_common.h | 1 - 3 files changed, 3 deletions(-)

diff --git a/include/configs/aristainetos-common.h b/include/configs/aristainetos-common.h index 0b97ccc..cbba6be 100644 --- a/include/configs/aristainetos-common.h +++ b/include/configs/aristainetos-common.h @@ -42,7 +42,6 @@ #define CONFIG_PHY_MICREL

#define CONFIG_CMD_SF -#define CONFIG_SPI_FLASH_MTD #define CONFIG_MXC_SPI #define CONFIG_SF_DEFAULT_SPEED 20000000 #define CONFIG_SF_DEFAULT_MODE SPI_MODE_0 diff --git a/include/configs/gw_ventana.h b/include/configs/gw_ventana.h index b7b9c78..1ac9420 100644 --- a/include/configs/gw_ventana.h +++ b/include/configs/gw_ventana.h @@ -68,7 +68,6 @@ #define CONFIG_CMD_SF #ifdef CONFIG_CMD_SF #define CONFIG_MXC_SPI - #define CONFIG_SPI_FLASH_MTD #define CONFIG_SPI_FLASH_BAR #define CONFIG_SF_DEFAULT_BUS 0 #define CONFIG_SF_DEFAULT_CS 0 diff --git a/include/configs/socfpga_common.h b/include/configs/socfpga_common.h index b22e3b1..0a68510 100644 --- a/include/configs/socfpga_common.h +++ b/include/configs/socfpga_common.h @@ -191,7 +191,6 @@ unsigned int cm_get_l4_sp_clk_hz(void); */ /* Enable multiple SPI NOR flash manufacturers */ #ifndef CONFIG_SPL_BUILD -#define CONFIG_SPI_FLASH_MTD #define CONFIG_CMD_MTDPARTS #define CONFIG_MTD_DEVICE #define CONFIG_MTD_PARTITIONS

Flash id detection should be the first step to enumerate the connected flash on the board, once ie done checking with respective id codes locally in the driver all this should be part of jedec_probe instead of id detection and validated through flash_info{} table separatly.

Cc: Haikun Wang haikun.wang@freescale.com Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_dataflash.c | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/drivers/mtd/spi/sf_dataflash.c b/drivers/mtd/spi/sf_dataflash.c index 6a9dfef..7c6c8d2 100644 --- a/drivers/mtd/spi/sf_dataflash.c +++ b/drivers/mtd/spi/sf_dataflash.c @@ -501,9 +501,10 @@ static struct flash_info dataflash_data[] = { { "at45db642d", 0x1f2800, 8192, 1024, 10, SUP_POW2PS | IS_POW2PS}, };

-static struct flash_info *jedec_probe(struct spi_slave *spi, u8 *id) +static struct flash_info *jedec_probe(struct spi_slave *spi) { int tmp; + uint8_t id[5]; uint32_t jedec; struct flash_info *info; int status; @@ -517,6 +518,11 @@ static struct flash_info *jedec_probe(struct spi_slave *spi, u8 *id) * That's not an error; only rev C and newer chips handle it, and * only Atmel sells these chips. */ + tmp = spi_flash_cmd(spi, CMD_READ_ID, id, sizeof(id)); + if (tmp < 0) { + printf("dataflash: error %d reading JEDEC ID\n", tmp); + return ERR_PTR(tmp); + } if (id[0] != 0x1f) return NULL;

@@ -580,7 +586,6 @@ static int spi_dataflash_probe(struct udevice *dev) struct spi_slave *spi = dev_get_parent_priv(dev); struct spi_flash *spi_flash; struct flash_info *info; - u8 idcode[5]; int ret, status = 0;

spi_flash = dev_get_uclass_priv(dev); @@ -591,12 +596,6 @@ static int spi_dataflash_probe(struct udevice *dev) if (ret) return ret;

- ret = spi_flash_cmd(spi, CMD_READ_ID, idcode, sizeof(idcode)); - if (ret) { - printf("SPI DataFlash: Failed to get idcodes\n"); - goto err_read_cmd; - } - /* * Try to detect dataflash by JEDEC ID. * If it succeeds we know we have either a C or D part. @@ -604,7 +603,9 @@ static int spi_dataflash_probe(struct udevice *dev) * Both support the security register, though with different * write procedures. */ - info = jedec_probe(spi, idcode); + info = jedec_probe(spi); + if (IS_ERR(info)) + return PTR_ERR(info); if (info != NULL) add_dataflash(dev, info->name, info->nr_pages, info->pagesize, info->pageoffset,

Since spi-flash is using MTD core by inheriting flash operation from mtd_info, legacy spi_flash{} are no longer available so this patch use mtd_info as same as spi-flash.

Cc: Haikun Wang haikun.wang@freescale.com Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/sf_dataflash.c | 236 ++++++++++++++++++++++------------------- 1 file changed, 124 insertions(+), 112 deletions(-)

diff --git a/drivers/mtd/spi/sf_dataflash.c b/drivers/mtd/spi/sf_dataflash.c index 212aa69..bdface2 100644 --- a/drivers/mtd/spi/sf_dataflash.c +++ b/drivers/mtd/spi/sf_dataflash.c @@ -2,6 +2,7 @@ * * Atmel DataFlash probing * + * Copyright (C) 2015 Jagan Teki jteki@openedev.com * Copyright (C) 2004-2009, 2015 Freescale Semiconductor, Inc. * Haikun Wang (haikun.wang@freescale.com) * @@ -16,6 +17,7 @@ #include <div64.h> #include <linux/err.h> #include <linux/math64.h> +#include <linux/mtd/mtd.h>

#include "sf_internal.h"

@@ -70,7 +72,11 @@

struct dataflash { uint8_t command[16]; + unsigned short page_offset; /* offset in flash address */ + unsigned int page_size; /* of bytes per page */ + + struct mtd_info mtd; };

/* @@ -117,31 +123,26 @@ static int dataflash_waitready(struct spi_slave *spi) /* * Erase pages of flash. */ -static int spi_dataflash_erase(struct udevice *dev, u32 offset, size_t len) +static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr) { - struct dataflash *dataflash; - struct spi_flash *spi_flash; - struct spi_slave *spi; - unsigned blocksize; + struct spi_flash *flash = mtd->priv; + struct dataflash *priv = flash->priv; + struct spi_slave *spi = flash->spi; + unsigned blocksize = priv->page_size << 3; uint8_t *command; uint32_t rem; int status;

- dataflash = dev_get_priv(dev); - spi_flash = dev_get_uclass_priv(dev); - spi = spi_flash->spi; - - blocksize = spi_flash->page_size << 3; + memset(priv->command, 0 , sizeof(priv->command)); + command = priv->command;

- memset(dataflash->command, 0 , sizeof(dataflash->command)); - command = dataflash->command; + debug("%s: erase addr=0x%llx len 0x%llx\n", flash->name, + instr->addr, instr->len);

- debug("%s: erase addr=0x%x len 0x%x\n", dev->name, offset, len); - - div_u64_rem(len, spi_flash->page_size, &rem); + div_u64_rem(instr->len, priv->page_size, &rem); if (rem) return -EINVAL; - div_u64_rem(offset, spi_flash->page_size, &rem); + div_u64_rem(instr->addr, priv->page_size, &rem); if (rem) return -EINVAL;

@@ -151,16 +152,16 @@ static int spi_dataflash_erase(struct udevice *dev, u32 offset, size_t len) return status; }

- while (len > 0) { + while (instr->len > 0) { unsigned int pageaddr; int do_block; /* * Calculate flash page address; use block erase (for speed) if * we're at a block boundary and need to erase the whole block. */ - pageaddr = div_u64(offset, spi_flash->page_size); - do_block = (pageaddr & 0x7) == 0 && len >= blocksize; - pageaddr = pageaddr << dataflash->page_offset; + pageaddr = div_u64(instr->addr, priv->page_size); + do_block = (pageaddr & 0x7) == 0 && instr->len >= blocksize; + pageaddr = pageaddr << priv->page_offset;

command[0] = do_block ? OP_ERASE_BLOCK : OP_ERASE_PAGE; command[1] = (uint8_t)(pageaddr >> 16); @@ -168,67 +169,69 @@ static int spi_dataflash_erase(struct udevice *dev, u32 offset, size_t len) command[3] = 0;

debug("%s ERASE %s: (%x) %x %x %x [%d]\n", - dev->name, do_block ? "block" : "page", + flash->name, do_block ? "block" : "page", command[0], command[1], command[2], command[3], pageaddr);

status = spi_flash_cmd_write(spi, command, 4, NULL, 0); if (status < 0) { - debug("%s: erase send command error!\n", dev->name); + debug("%s: erase send command error!\n", flash->name); return -EIO; }

status = dataflash_waitready(spi); if (status < 0) { - debug("%s: erase waitready error!\n", dev->name); + debug("%s: erase waitready error!\n", flash->name); return status; }

if (do_block) { - offset += blocksize; - len -= blocksize; + instr->addr += blocksize; + instr->len -= blocksize; } else { - offset += spi_flash->page_size; - len -= spi_flash->page_size; + instr->addr += priv->page_size; + instr->len -= priv->page_size; } }

spi_release_bus(spi);

+ /* Inform MTD subsystem that erase is complete */ + instr->state = MTD_ERASE_DONE; + mtd_erase_callback(instr); + return 0; }

/* * Read from the DataFlash device. - * offset : Start offset in flash device + * from : Start offset in flash device * len : Amount to read + * retlen : About of data actually read * buf : Buffer containing the data */ -static int spi_dataflash_read(struct udevice *dev, u32 offset, size_t len, - void *buf) +static int dataflash_read(struct mtd_info *mtd, loff_t from, size_t len, + size_t *retlen, u_char *buf) { - struct dataflash *dataflash; - struct spi_flash *spi_flash; - struct spi_slave *spi; + struct spi_flash *flash = mtd->priv; + struct dataflash *priv = flash->priv; + struct spi_slave *spi = flash->spi; unsigned int addr; uint8_t *command; int status;

- dataflash = dev_get_priv(dev); - spi_flash = dev_get_uclass_priv(dev); - spi = spi_flash->spi; + memset(priv->command, 0 , sizeof(priv->command)); + command = priv->command;

- memset(dataflash->command, 0 , sizeof(dataflash->command)); - command = dataflash->command; - - debug("%s: erase addr=0x%x len 0x%x\n", dev->name, offset, len); + debug("%s: read 0x%x..0x%x\n", flash->name, (unsigned)from, + (unsigned)(from + len)); debug("READ: (%x) %x %x %x\n", command[0], command[1], command[2], command[3]);

/* Calculate flash page/byte address */ - addr = (((unsigned)offset / spi_flash->page_size) - << dataflash->page_offset) - + ((unsigned)offset % spi_flash->page_size); + addr = (((unsigned)from / priv->page_size) + << priv->page_offset) + + ((unsigned)from % priv->page_size);

status = spi_claim_bus(spi); if (status) { @@ -248,6 +251,10 @@ static int spi_dataflash_read(struct udevice *dev, u32 offset, size_t len,

/* plus 4 "don't care" bytes, command len: 4 + 4 "don't care" bytes */ status = spi_flash_cmd_read(spi, command, 8, buf, len); + if (status >= 0) { + *retlen = len - 8; + status = 0; + }

spi_release_bus(spi);

@@ -256,35 +263,33 @@ static int spi_dataflash_read(struct udevice *dev, u32 offset, size_t len,

/* * Write to the DataFlash device. - * offset : Start offset in flash device + * to : Start offset in flash device * len : Amount to write + * retlen : Amount of data actually written * buf : Buffer containing the data */ -int spi_dataflash_write(struct udevice *dev, u32 offset, size_t len, - const void *buf) +static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len, + size_t *retlen, const u_char *buf) { - struct dataflash *dataflash; - struct spi_flash *spi_flash; - struct spi_slave *spi; + struct spi_flash *flash = mtd->priv; + struct dataflash *priv = flash->priv; + struct spi_slave *spi = flash->spi; uint8_t *command; - unsigned int pageaddr, addr, to, writelen; + unsigned int pageaddr, addr, offset, writelen; size_t remaining = len; u_char *writebuf = (u_char *)buf; int status = -EINVAL;

- dataflash = dev_get_priv(dev); - spi_flash = dev_get_uclass_priv(dev); - spi = spi_flash->spi; + memset(priv->command, 0 , sizeof(priv->command)); + command = priv->command;

- memset(dataflash->command, 0 , sizeof(dataflash->command)); - command = dataflash->command; + debug("%s: write 0x%x..0x%x\n", flash->name, (unsigned)to, + (unsigned)(to + len));

- debug("%s: write 0x%x..0x%x\n", dev->name, offset, (offset + len)); - - pageaddr = ((unsigned)offset / spi_flash->page_size); - to = ((unsigned)offset % spi_flash->page_size); - if (to + len > spi_flash->page_size) - writelen = spi_flash->page_size - to; + pageaddr = ((unsigned)to / priv->page_size); + offset = ((unsigned)to % priv->page_size); + if (offset + len > priv->page_size) + writelen = priv->page_size - offset; else writelen = len;

@@ -295,7 +300,7 @@ int spi_dataflash_write(struct udevice *dev, u32 offset, size_t len, }

while (remaining > 0) { - debug("write @ %d:%d len=%d\n", pageaddr, to, writelen); + debug("write @ %d:%d len=%d\n", pageaddr, offset, writelen);

/* * REVISIT: @@ -314,10 +319,10 @@ int spi_dataflash_write(struct udevice *dev, u32 offset, size_t len, * support boot-from-DataFlash.) */

- addr = pageaddr << dataflash->page_offset; + addr = pageaddr << priv->page_offset;

/* (1) Maybe transfer partial page to Buffer1 */ - if (writelen != spi_flash->page_size) { + if (writelen != priv->page_size) { command[0] = OP_TRANSFER_BUF1; command[1] = (addr & 0x00FF0000) >> 16; command[2] = (addr & 0x0000FF00) >> 8; @@ -329,20 +334,20 @@ int spi_dataflash_write(struct udevice *dev, u32 offset, size_t len, status = spi_flash_cmd_write(spi, command, 4, NULL, 0); if (status < 0) { debug("%s: write(<pagesize) command error!\n", - dev->name); + flash->name); return -EIO; }

status = dataflash_waitready(spi); if (status < 0) { debug("%s: write(<pagesize) waitready error!\n", - dev->name); + flash->name); return status; } }

/* (2) Program full page via Buffer1 */ - addr += to; + addr += offset; command[0] = OP_PROGRAM_VIA_BUF1; command[1] = (addr & 0x00FF0000) >> 16; command[2] = (addr & 0x0000FF00) >> 8; @@ -354,19 +359,19 @@ int spi_dataflash_write(struct udevice *dev, u32 offset, size_t len, status = spi_flash_cmd_write(spi, command, 4, writebuf, writelen); if (status < 0) { - debug("%s: write send command error!\n", dev->name); + debug("%s: write send command error!\n", flash->name); return -EIO; }

status = dataflash_waitready(spi); if (status < 0) { - debug("%s: write waitready error!\n", dev->name); + debug("%s: write waitready error!\n", flash->name); return status; }

#ifdef CONFIG_SPI_DATAFLASH_WRITE_VERIFY /* (3) Compare to Buffer1 */ - addr = pageaddr << dataflash->page_offset; + addr = pageaddr << priv->page_offset; command[0] = OP_COMPARE_BUF1; command[1] = (addr & 0x00FF0000) >> 16; command[2] = (addr & 0x0000FF00) >> 8; @@ -379,7 +384,7 @@ int spi_dataflash_write(struct udevice *dev, u32 offset, size_t len, 4, writebuf, writelen); if (status < 0) { debug("%s: write(compare) send command error!\n", - dev->name); + flash->name); return -EIO; }

@@ -399,11 +404,12 @@ int spi_dataflash_write(struct udevice *dev, u32 offset, size_t len, #endif /* CONFIG_SPI_DATAFLASH_WRITE_VERIFY */ remaining = remaining - writelen; pageaddr++; - to = 0; + offset = 0; writebuf += writelen; + *retlen += writelen;

- if (remaining > spi_flash->page_size) - writelen = spi_flash->page_size; + if (remaining > priv->page_size) + writelen = priv->page_size; else writelen = remaining; } @@ -413,32 +419,40 @@ int spi_dataflash_write(struct udevice *dev, u32 offset, size_t len, return 0; }

-static int add_dataflash(struct udevice *dev, char *name, int nr_pages, +static int add_dataflash(struct spi_flash *flash, char *name, int nr_pages, int pagesize, int pageoffset, char revision) { - struct spi_flash *spi_flash; - struct dataflash *dataflash; - - dataflash = dev_get_priv(dev); - spi_flash = dev_get_uclass_priv(dev); + struct mtd_info *mtd = flash->mtd; + struct dataflash *priv = flash->priv; + int ret;

- dataflash->page_offset = pageoffset; + priv->page_size = pagesize; + priv->page_offset = pageoffset;

- spi_flash->name = name; - spi_flash->page_size = pagesize; - spi_flash->size = nr_pages * pagesize; - spi_flash->erase_size = pagesize; + flash->name = name; + mtd->size = nr_pages * pagesize; + mtd->erasesize = pagesize; + mtd->writesize = pagesize; + mtd->type = MTD_DATAFLASH; + mtd->flags = MTD_WRITEABLE; + mtd->_erase = dataflash_erase; + mtd->_read = dataflash_read; + mtd->_write = dataflash_write;

#ifndef CONFIG_SPL_BUILD - printf("SPI DataFlash: Detected %s with page size ", spi_flash->name); - print_size(spi_flash->page_size, ", erase size "); - print_size(spi_flash->erase_size, ", total "); - print_size(spi_flash->size, ""); + printf("SPI DataFlash: Detected %s with page size ", flash->name); + print_size(priv->page_size, ", erase size "); + print_size(mtd->erasesize, ", total "); + print_size(mtd->size, ""); printf(", revision %c", revision); puts("\n"); #endif

- return 0; + ret = add_mtd_device(mtd); + if (ret) + return ret; + + return ret; }

struct flash_info { @@ -583,14 +597,19 @@ static struct flash_info *jedec_probe(struct spi_slave *spi) */ static int spi_dataflash_probe(struct udevice *dev) { - struct spi_slave *spi = dev_get_parent_priv(dev); - struct spi_flash *spi_flash; - struct flash_info *info; + struct dataflash *priv = dev_get_priv(dev); + struct spi_slave *spi = dev_get_parent_priv(dev); + struct spi_flash *flash = dev_get_uclass_priv(dev); + struct flash_info *info; int status;

- spi_flash = dev_get_uclass_priv(dev); - spi_flash->spi = spi; - spi_flash->dev = dev; + flash->mtd = &priv->mtd; + + flash->spi = spi; + flash->priv = priv; + + priv->mtd.priv = flash; + flash->dev = dev;

status = spi_claim_bus(spi); if (status) @@ -607,7 +626,7 @@ static int spi_dataflash_probe(struct udevice *dev) if (IS_ERR(info)) goto err_jedec_probe; if (info != NULL) { - status = add_dataflash(dev, info->name, info->nr_pages, + status = add_dataflash(flash, info->name, info->nr_pages, info->pagesize, info->pageoffset, (info->flags & SUP_POW2PS) ? 'd' : 'c'); if (status < 0) @@ -633,31 +652,31 @@ static int spi_dataflash_probe(struct udevice *dev) */ switch (status & 0x3c) { case 0x0c: /* 0 0 1 1 x x */ - status = add_dataflash(dev, "AT45DB011B", 512, 264, 9, 0); + status = add_dataflash(flash, "AT45DB011B", 512, 264, 9, 0); break; case 0x14: /* 0 1 0 1 x x */ - status = add_dataflash(dev, "AT45DB021B", 1024, 264, 9, 0); + status = add_dataflash(flash, "AT45DB021B", 1024, 264, 9, 0); break; case 0x1c: /* 0 1 1 1 x x */ - status = add_dataflash(dev, "AT45DB041x", 2048, 264, 9, 0); + status = add_dataflash(flash, "AT45DB041x", 2048, 264, 9, 0); break; case 0x24: /* 1 0 0 1 x x */ - status = add_dataflash(dev, "AT45DB081B", 4096, 264, 9, 0); + status = add_dataflash(flash, "AT45DB081B", 4096, 264, 9, 0); break; case 0x2c: /* 1 0 1 1 x x */ - status = add_dataflash(dev, "AT45DB161x", 4096, 528, 10, 0); + status = add_dataflash(flash, "AT45DB161x", 4096, 528, 10, 0); break; case 0x34: /* 1 1 0 1 x x */ - status = add_dataflash(dev, "AT45DB321x", 8192, 528, 10, 0); + status = add_dataflash(flash, "AT45DB321x", 8192, 528, 10, 0); break; case 0x38: /* 1 1 1 x x x */ case 0x3c: - status = add_dataflash(dev, "AT45DB642x", 8192, 1056, 11, 0); + status = add_dataflash(flash, "AT45DB642x", 8192, 1056, 11, 0); break; /* obsolete AT45DB1282 not (yet?) supported */ default: dev_info(&spi->dev, "unsupported device (%x)\n", - status & 0x3c); + status & 0x3c); status = -ENODEV; goto err_status; } @@ -671,12 +690,6 @@ err_jedec_probe: return status; }

-static const struct dm_spi_flash_ops spi_dataflash_ops = { - .read = spi_dataflash_read, - .write = spi_dataflash_write, - .erase = spi_dataflash_erase, -}; - static const struct udevice_id spi_dataflash_ids[] = { { .compatible = "atmel,at45", }, { .compatible = "atmel,dataflash", }, @@ -689,5 +702,4 @@ U_BOOT_DRIVER(spi_dataflash) = { .of_match = spi_dataflash_ids, .probe = spi_dataflash_probe, .priv_auto_alloc_size = sizeof(struct dataflash), - .ops = &spi_dataflash_ops, };

- fix single line comments - remove unneeded spaces - ascending order of include files - rename spi_dataflash_* to dataflash_* - rename SPI DATAFLASH to dataflash - rename SPI DataFlash to dataflash - return NULL replaced with error code

Cc: Haikun Wang haikun.wang@freescale.com Signed-off-by: Jagan Teki jteki@openedev.com --- drivers/mtd/spi/mtd_dataflash.c | 50 +++++++++++++++++------------------------ 1 file changed, 21 insertions(+), 29 deletions(-)

diff --git a/drivers/mtd/spi/mtd_dataflash.c b/drivers/mtd/spi/mtd_dataflash.c index bdface2..65ac5e9 100644 --- a/drivers/mtd/spi/mtd_dataflash.c +++ b/drivers/mtd/spi/mtd_dataflash.c @@ -1,5 +1,4 @@ /* - * * Atmel DataFlash probing * * Copyright (C) 2015 Jagan Teki jteki@openedev.com @@ -7,14 +6,15 @@ * Haikun Wang (haikun.wang@freescale.com) * * SPDX-License-Identifier: GPL-2.0+ -*/ + */ + #include <common.h> +#include <div64.h> #include <dm.h> #include <errno.h> #include <fdtdec.h> #include <spi.h> #include <spi_flash.h> -#include <div64.h> #include <linux/err.h> #include <linux/math64.h> #include <linux/mtd/mtd.h> @@ -69,7 +69,6 @@ #define OP_WRITE_SECURITY_REVC 0x9A #define OP_WRITE_SECURITY 0x9B /* revision D */

- struct dataflash { uint8_t command[16];

@@ -79,9 +78,7 @@ struct dataflash { struct mtd_info mtd; };

-/* - * Return the status of the DataFlash device. - */ +/* Return the status of the DataFlash device */ static inline int dataflash_status(struct spi_slave *spi) { int ret; @@ -120,9 +117,7 @@ static int dataflash_waitready(struct spi_slave *spi) return -ETIME; }

-/* - * Erase pages of flash. - */ +/* Erase pages of flash */ static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr) { struct spi_flash *flash = mtd->priv; @@ -148,7 +143,7 @@ static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr)

status = spi_claim_bus(spi); if (status) { - debug("SPI DATAFLASH: unable to claim SPI bus\n"); + debug("dataflash: unable to claim SPI bus\n"); return status; }

@@ -235,7 +230,7 @@ static int dataflash_read(struct mtd_info *mtd, loff_t from, size_t len,

status = spi_claim_bus(spi); if (status) { - debug("SPI DATAFLASH: unable to claim SPI bus\n"); + debug("dataflash: unable to claim SPI bus\n"); return status; }

@@ -295,7 +290,7 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,

status = spi_claim_bus(spi); if (status) { - debug("SPI DATAFLASH: unable to claim SPI bus\n"); + debug("dataflash: unable to claim SPI bus\n"); return status; }

@@ -392,7 +387,7 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,

/* Check result of the compare operation */ if (status & (1 << 6)) { - printf("SPI DataFlash: write compare page %u, err %d\n", + printf("dataflash: write compare page %u, err %d\n", pageaddr, status); remaining = 0; status = -EIO; @@ -440,7 +435,7 @@ static int add_dataflash(struct spi_flash *flash, char *name, int nr_pages, mtd->_write = dataflash_write;

#ifndef CONFIG_SPL_BUILD - printf("SPI DataFlash: Detected %s with page size ", flash->name); + printf("DATAFLASH: Detected %s with page size ", flash->name); print_size(priv->page_size, ", erase size "); print_size(mtd->erasesize, ", total "); print_size(mtd->size, ""); @@ -553,7 +548,7 @@ static struct flash_info *jedec_probe(struct spi_slave *spi) if (info->flags & SUP_POW2PS) { status = dataflash_status(spi); if (status < 0) { - debug("SPI DataFlash: status error %d\n", + debug("dataflash: status error %d\n", status); return NULL; } @@ -575,10 +570,8 @@ static struct flash_info *jedec_probe(struct spi_slave *spi) * size (it might be binary) even when we can tell which density * class is involved (legacy chip id scheme). */ - printf("SPI DataFlash: Unsupported flash IDs: "); - printf("manuf %02x, jedec %04x, ext_jedec %04x\n", - id[0], jedec, id[3] << 8 | id[4]); - return NULL; + printf("dataflash: JEDEC id %06x not handled\n", jedec); + return ERR_PTR(-ENODEV); }

/* @@ -595,7 +588,7 @@ static struct flash_info *jedec_probe(struct spi_slave *spi) * AT45DB0642 64Mbit (8M) xx111xxx (0x3c) 8192 1056 11 * AT45DB1282 128Mbit (16M) xx0100xx (0x10) 16384 1056 11 */ -static int spi_dataflash_probe(struct udevice *dev) +static int dataflash_probe(struct udevice *dev) { struct dataflash *priv = dev_get_priv(dev); struct spi_slave *spi = dev_get_parent_priv(dev); @@ -633,19 +626,19 @@ static int spi_dataflash_probe(struct udevice *dev) goto err_status; }

- /* + /* * Older chips support only legacy commands, identifing * capacity using bits in the status byte. */ status = dataflash_status(spi); if (status <= 0 || status == 0xff) { - printf("SPI DataFlash: read status error %d\n", status); + printf("dataflash: read status error %d\n", status); if (status == 0 || status == 0xff) status = -ENODEV; goto err_jedec_probe; }

- /* + /* * if there's a device there, assume it's dataflash. * board setup should have set spi->max_speed_max to * match f(car) for continuous reads, mode 0 or 3. @@ -675,8 +668,7 @@ static int spi_dataflash_probe(struct udevice *dev) break; /* obsolete AT45DB1282 not (yet?) supported */ default: - dev_info(&spi->dev, "unsupported device (%x)\n", - status & 0x3c); + printf("dataflash: unsupported device (%x)\n", status & 0x3c); status = -ENODEV; goto err_status; } @@ -690,7 +682,7 @@ err_jedec_probe: return status; }

-static const struct udevice_id spi_dataflash_ids[] = { +static const struct udevice_id dataflash_ids[] = { { .compatible = "atmel,at45", }, { .compatible = "atmel,dataflash", }, { } @@ -699,7 +691,7 @@ static const struct udevice_id spi_dataflash_ids[] = { U_BOOT_DRIVER(spi_dataflash) = { .name = "spi_dataflash", .id = UCLASS_SPI_FLASH, - .of_match = spi_dataflash_ids, - .probe = spi_dataflash_probe, + .of_match = dataflash_ids, + .probe = dataflash_probe, .priv_auto_alloc_size = sizeof(struct dataflash), };