GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

drivers/spi/spi_flash: Add page_size to struct spi_flash 

Add a new member page_size to spi_flash structure so that the various
spi flash drivers can store this info in spi_flash along with the
other sizes (sector size and total size) during flash probe. This
removes the need to have {driver}_spi_flash structure in every spi
flash driver.

This is part of patch series to clean up the SPI flash and SPI driver
interface.

BUG=b:38330715

Change-Id: I0f83e52cb1041432b0b575a8ee3bd173cc038d1f
Signed-off-by: Furquan Shaikh <furquan@chromium.org>
Reviewed-on: https://review.coreboot.org/19704
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Aaron Durbin <adurbin@chromium.org>
This commit is contained in:
Furquan Shaikh 2017-05-12 00:19:56 -07:00 committed by Furquan Shaikh
parent f422fd2c78
commit fc1a123aa7
12 changed files with 162 additions and 305 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/drivers/spi/adesto.c
View File

@ -42,18 +42,6 @@ struct adesto_spi_flash_params {
const char *name; const char *name;
}; };
/* spi_flash needs to be first so upper layers can free() it */
struct adesto_spi_flash {
struct spi_flash flash;
const struct adesto_spi_flash_params *params;
};
static inline struct adesto_spi_flash *
to_adesto_spi_flash(const struct spi_flash *flash)
{
return container_of(flash, struct adesto_spi_flash, flash);
}
static const struct adesto_spi_flash_params adesto_spi_flash_table[] = { static const struct adesto_spi_flash_params adesto_spi_flash_table[] = {
{ {
.id = 0x4501, .id = 0x4501,
@ -84,7 +72,6 @@ static const struct adesto_spi_flash_params adesto_spi_flash_table[] = {
static int adesto_write(const struct spi_flash *flash, u32 offset, size_t len, static int adesto_write(const struct spi_flash *flash, u32 offset, size_t len,
const void *buf) const void *buf)
{ {
struct adesto_spi_flash *stm = to_adesto_spi_flash(flash);
unsigned long byte_addr; unsigned long byte_addr;
unsigned long page_size; unsigned long page_size;
size_t chunk_len; size_t chunk_len;
@ -92,7 +79,7 @@ static int adesto_write(const struct spi_flash *flash, u32 offset, size_t len,
int ret; int ret;
u8 cmd[4]; u8 cmd[4];
page_size = 1 << stm->params->l2_page_size; page_size = flash->page_size;
for (actual = 0; actual < len; actual += chunk_len) { for (actual = 0; actual < len; actual += chunk_len) {
byte_addr = offset % page_size; byte_addr = offset % page_size;
@ -142,8 +129,7 @@ out:
struct spi_flash *spi_flash_probe_adesto(struct spi_slave *spi, u8 *idcode) struct spi_flash *spi_flash_probe_adesto(struct spi_slave *spi, u8 *idcode)
{ {
const struct adesto_spi_flash_params *params; const struct adesto_spi_flash_params *params;
unsigned page_size; struct spi_flash *flash;
struct adesto_spi_flash *stm;
unsigned int i; unsigned int i;
for (i = 0; i < ARRAY_SIZE(adesto_spi_flash_table); i++) { for (i = 0; i < ARRAY_SIZE(adesto_spi_flash_table); i++) {
@ -158,32 +144,28 @@ struct spi_flash *spi_flash_probe_adesto(struct spi_slave *spi, u8 *idcode)
return NULL; return NULL;
} }
stm = malloc(sizeof(struct adesto_spi_flash)); flash = malloc(sizeof(*flash));
if (!stm) { if (!flash) {
printk(BIOS_WARNING, "SF: Failed to allocate memory\n"); printk(BIOS_WARNING, "SF: Failed to allocate memory\n");
return NULL; return NULL;
} }
stm->params = params; memcpy(&flash->spi, spi, sizeof(*spi));
memcpy(&stm->flash.spi, spi, sizeof(*spi)); flash->name = params->name;
stm->flash.name = params->name;
/* Assuming power-of-two page size initially. */ /* Assuming power-of-two page size initially. */
page_size = 1 << params->l2_page_size; flash->page_size = 1 << params->l2_page_size;
flash->sector_size = flash->page_size * params->pages_per_sector;
flash->size = flash->sector_size *params->sectors_per_block *
params->nr_blocks;
flash->erase_cmd = CMD_AT25DF_SE;
stm->flash.internal_write = adesto_write; flash->internal_write = adesto_write;
stm->flash.internal_erase = spi_flash_cmd_erase; flash->internal_erase = spi_flash_cmd_erase;
#if CONFIG_SPI_FLASH_NO_FAST_READ #if CONFIG_SPI_FLASH_NO_FAST_READ
stm->flash.internal_read = spi_flash_cmd_read_slow; flash->internal_read = spi_flash_cmd_read_slow;
#else #else
stm->flash.internal_read = spi_flash_cmd_read_fast; flash->internal_read = spi_flash_cmd_read_fast;
#endif #endif
stm->flash.sector_size = (1 << stm->params->l2_page_size) *
stm->params->pages_per_sector;
stm->flash.size = page_size * params->pages_per_sector
* params->sectors_per_block
* params->nr_blocks;
stm->flash.erase_cmd = CMD_AT25DF_SE;
return &stm->flash; return flash;
} }

49
src/drivers/spi/amic.c
View File

@ -40,18 +40,6 @@ struct amic_spi_flash_params {
const char *name; const char *name;
}; };
/* spi_flash needs to be first so upper layers can free() it */
struct amic_spi_flash {
struct spi_flash flash;
const struct amic_spi_flash_params *params;
};
static inline struct amic_spi_flash *
to_amic_spi_flash(const struct spi_flash *flash)
{
return container_of(flash, struct amic_spi_flash, flash);
}
static const struct amic_spi_flash_params amic_spi_flash_table[] = { static const struct amic_spi_flash_params amic_spi_flash_table[] = {
{ {
.id = 0x3016, .id = 0x3016,
@ -66,7 +54,6 @@ static const struct amic_spi_flash_params amic_spi_flash_table[] = {
static int amic_write(const struct spi_flash *flash, u32 offset, size_t len, static int amic_write(const struct spi_flash *flash, u32 offset, size_t len,
const void *buf) const void *buf)
{ {
struct amic_spi_flash *amic = to_amic_spi_flash(flash);
unsigned long byte_addr; unsigned long byte_addr;
unsigned long page_size; unsigned long page_size;
size_t chunk_len; size_t chunk_len;
@ -74,7 +61,7 @@ static int amic_write(const struct spi_flash *flash, u32 offset, size_t len,
int ret; int ret;
u8 cmd[4]; u8 cmd[4];
page_size = 1 << amic->params->l2_page_size; page_size = flash->page_size;
byte_addr = offset % page_size; byte_addr = offset % page_size;
for (actual = 0; actual < len; actual += chunk_len) { for (actual = 0; actual < len; actual += chunk_len) {
@ -125,9 +112,8 @@ out:
struct spi_flash *spi_flash_probe_amic(struct spi_slave *spi, u8 *idcode) struct spi_flash *spi_flash_probe_amic(struct spi_slave *spi, u8 *idcode)
{ {
const struct amic_spi_flash_params *params; const struct amic_spi_flash_params *params;
unsigned page_size;
struct amic_spi_flash *amic;
unsigned int i; unsigned int i;
struct spi_flash *flash;
for (i = 0; i < ARRAY_SIZE(amic_spi_flash_table); i++) { for (i = 0; i < ARRAY_SIZE(amic_spi_flash_table); i++) {
params = &amic_spi_flash_table[i]; params = &amic_spi_flash_table[i];
@ -141,32 +127,29 @@ struct spi_flash *spi_flash_probe_amic(struct spi_slave *spi, u8 *idcode)
return NULL; return NULL;
} }
amic = malloc(sizeof(struct amic_spi_flash)); flash = malloc(sizeof(*flash));
if (!amic) { if (!flash) {
printk(BIOS_WARNING, "SF: Failed to allocate memory\n"); printk(BIOS_WARNING, "SF: Failed to allocate memory\n");
return NULL; return NULL;
} }
amic->params = params; memcpy(&flash->spi, spi, sizeof(*spi));
memcpy(&amic->flash.spi, spi, sizeof(*spi)); flash->name = params->name;
amic->flash.name = params->name;
/* Assuming power-of-two page size initially. */ /* Assuming power-of-two page size initially. */
page_size = 1 << params->l2_page_size; flash->page_size = 1 << params->l2_page_size;
flash->sector_size = flash->page_size * params->pages_per_sector;
flash->size = flash->sector_size * params->sectors_per_block *
params->nr_blocks;
flash->erase_cmd = CMD_A25_SE;
amic->flash.internal_write = amic_write; flash->internal_write = amic_write;
amic->flash.internal_erase = spi_flash_cmd_erase; flash->internal_erase = spi_flash_cmd_erase;
#if CONFIG_SPI_FLASH_NO_FAST_READ #if CONFIG_SPI_FLASH_NO_FAST_READ
amic->flash.internal_read = spi_flash_cmd_read_slow; flash->internal_read = spi_flash_cmd_read_slow;
#else #else
amic->flash.internal_read = spi_flash_cmd_read_fast; flash->internal_read = spi_flash_cmd_read_fast;
#endif #endif
amic->flash.sector_size = (1 << amic->params->l2_page_size) *
amic->params->pages_per_sector;
amic->flash.size = page_size * params->pages_per_sector
* params->sectors_per_block
* params->nr_blocks;
amic->flash.erase_cmd = CMD_A25_SE;
return &amic->flash; return flash;
} }

49
src/drivers/spi/atmel.c
View File

@ -38,18 +38,6 @@ struct atmel_spi_flash_params {
const char *name; const char *name;
}; };
/* spi_flash needs to be first so upper layers can free() it */
struct atmel_spi_flash {
struct spi_flash flash;
const struct atmel_spi_flash_params *params;
};
static inline struct atmel_spi_flash *
to_atmel_spi_flash(const struct spi_flash *flash)
{
return container_of(flash, struct atmel_spi_flash, flash);
}
static const struct atmel_spi_flash_params atmel_spi_flash_table[] = { static const struct atmel_spi_flash_params atmel_spi_flash_table[] = {
{ {
.id = 0x3015, .id = 0x3015,
@ -112,7 +100,6 @@ static const struct atmel_spi_flash_params atmel_spi_flash_table[] = {
static int atmel_write(const struct spi_flash *flash, u32 offset, size_t len, static int atmel_write(const struct spi_flash *flash, u32 offset, size_t len,
const void *buf) const void *buf)
{ {
struct atmel_spi_flash *stm = to_atmel_spi_flash(flash);
unsigned long byte_addr; unsigned long byte_addr;
unsigned long page_size; unsigned long page_size;
size_t chunk_len; size_t chunk_len;
@ -120,7 +107,7 @@ static int atmel_write(const struct spi_flash *flash, u32 offset, size_t len,
int ret; int ret;
u8 cmd[4]; u8 cmd[4];
page_size = 1 << stm->params->l2_page_size; page_size = flash->page_size;
for (actual = 0; actual < len; actual += chunk_len) { for (actual = 0; actual < len; actual += chunk_len) {
byte_addr = offset % page_size; byte_addr = offset % page_size;
@ -170,9 +157,8 @@ out:
struct spi_flash *spi_flash_probe_atmel(struct spi_slave *spi, u8 *idcode) struct spi_flash *spi_flash_probe_atmel(struct spi_slave *spi, u8 *idcode)
{ {
const struct atmel_spi_flash_params *params; const struct atmel_spi_flash_params *params;
unsigned page_size;
struct atmel_spi_flash *stm;
unsigned int i; unsigned int i;
struct spi_flash *flash;
for (i = 0; i < ARRAY_SIZE(atmel_spi_flash_table); i++) { for (i = 0; i < ARRAY_SIZE(atmel_spi_flash_table); i++) {
params = &atmel_spi_flash_table[i]; params = &atmel_spi_flash_table[i];
@ -186,32 +172,29 @@ struct spi_flash *spi_flash_probe_atmel(struct spi_slave *spi, u8 *idcode)
return NULL; return NULL;
} }
stm = malloc(sizeof(struct atmel_spi_flash)); flash = malloc(sizeof(*flash));
if (!stm) { if (!flash) {
printk(BIOS_WARNING, "SF: Failed to allocate memory\n"); printk(BIOS_WARNING, "SF: Failed to allocate memory\n");
return NULL; return NULL;
} }
stm->params = params; memcpy(&flash->spi, spi, sizeof(*spi));
memcpy(&stm->flash.spi, spi, sizeof(*spi)); flash->name = params->name;
stm->flash.name = params->name;
/* Assuming power-of-two page size initially. */ /* Assuming power-of-two page size initially. */
page_size = 1 << params->l2_page_size; flash->page_size = 1 << params->l2_page_size;
flash->sector_size = flash->page_size * params->pages_per_sector;
flash->size = flash->sector_size * params->sectors_per_block *
params->nr_blocks;
flash->erase_cmd = CMD_AT25_SE;
stm->flash.internal_write = atmel_write; flash->internal_write = atmel_write;
stm->flash.internal_erase = spi_flash_cmd_erase; flash->internal_erase = spi_flash_cmd_erase;
#if CONFIG_SPI_FLASH_NO_FAST_READ #if CONFIG_SPI_FLASH_NO_FAST_READ
stm->flash.internal_read = spi_flash_cmd_read_slow; flash->internal_read = spi_flash_cmd_read_slow;
#else #else
stm->flash.internal_read = spi_flash_cmd_read_fast; flash->internal_read = spi_flash_cmd_read_fast;
#endif #endif
stm->flash.sector_size = (1 << stm->params->l2_page_size) *
stm->params->pages_per_sector;
stm->flash.size = page_size * params->pages_per_sector
* params->sectors_per_block
* params->nr_blocks;
stm->flash.erase_cmd = CMD_AT25_SE;
return &stm->flash; return flash;
} }

47
src/drivers/spi/eon.c
View File

@ -40,18 +40,6 @@ struct eon_spi_flash_params {
const char *name; const char *name;
}; };
/* spi_flash needs to be first so upper layers can free() it */
struct eon_spi_flash {
struct spi_flash flash;
const struct eon_spi_flash_params *params;
};
static inline
struct eon_spi_flash *to_eon_spi_flash(const struct spi_flash *flash)
{
return container_of(flash, struct eon_spi_flash, flash);
}
static const struct eon_spi_flash_params eon_spi_flash_table[] = { static const struct eon_spi_flash_params eon_spi_flash_table[] = {
{ {
.id = EON_ID_EN25Q128, .id = EON_ID_EN25Q128,
@ -82,7 +70,6 @@ static const struct eon_spi_flash_params eon_spi_flash_table[] = {
static int eon_write(const struct spi_flash *flash, static int eon_write(const struct spi_flash *flash,
u32 offset, size_t len, const void *buf) u32 offset, size_t len, const void *buf)
{ {
struct eon_spi_flash *eon = to_eon_spi_flash(flash);
unsigned long byte_addr; unsigned long byte_addr;
unsigned long page_size; unsigned long page_size;
size_t chunk_len; size_t chunk_len;
@ -90,7 +77,7 @@ static int eon_write(const struct spi_flash *flash,
int ret = 0; int ret = 0;
u8 cmd[4]; u8 cmd[4];
page_size = 1 << eon->params->page_size; page_size = flash->page_size;
for (actual = 0; actual < len; actual += chunk_len) { for (actual = 0; actual < len; actual += chunk_len) {
byte_addr = offset % page_size; byte_addr = offset % page_size;
@ -142,7 +129,7 @@ out:
struct spi_flash *spi_flash_probe_eon(struct spi_slave *spi, u8 *idcode) struct spi_flash *spi_flash_probe_eon(struct spi_slave *spi, u8 *idcode)
{ {
const struct eon_spi_flash_params *params; const struct eon_spi_flash_params *params;
struct eon_spi_flash *eon; struct spi_flash *flash;
unsigned int i; unsigned int i;
for (i = 0; i < ARRAY_SIZE(eon_spi_flash_table); ++i) { for (i = 0; i < ARRAY_SIZE(eon_spi_flash_table); ++i) {
@ -157,25 +144,25 @@ struct spi_flash *spi_flash_probe_eon(struct spi_slave *spi, u8 *idcode)
return NULL; return NULL;
} }
eon = malloc(sizeof(*eon)); flash = malloc(sizeof(*flash));
if (!eon) { if (!flash) {
printk(BIOS_WARNING, "SF: Failed to allocate memory\n"); printk(BIOS_WARNING, "SF: Failed to allocate memory\n");
return NULL; return NULL;
} }
eon->params = params; memcpy(&flash->spi, spi, sizeof(*spi));
memcpy(&eon->flash.spi, spi, sizeof(*spi));
eon->flash.name = params->name;
eon->flash.internal_write = eon_write; flash->name = params->name;
eon->flash.internal_erase = spi_flash_cmd_erase; flash->page_size = params->page_size;
eon->flash.internal_status = spi_flash_cmd_status; flash->sector_size = params->page_size * params->pages_per_sector;
eon->flash.internal_read = spi_flash_cmd_read_fast; flash->size = flash->sector_size * params->nr_sectors;
eon->flash.sector_size = params->page_size * params->pages_per_sector; flash->erase_cmd = CMD_EN25_SE;
eon->flash.size = params->page_size * params->pages_per_sector flash->status_cmd = CMD_EN25_RDSR;
* params->nr_sectors;
eon->flash.erase_cmd = CMD_EN25_SE;
eon->flash.status_cmd = CMD_EN25_RDSR;
return &eon->flash; flash->internal_write = eon_write;
flash->internal_erase = spi_flash_cmd_erase;
flash->internal_status = spi_flash_cmd_status;
flash->internal_read = spi_flash_cmd_read_fast;
return flash;
} }

49
src/drivers/spi/gigadevice.c
View File

@ -49,18 +49,6 @@ struct gigadevice_spi_flash_params {
const char *name; const char *name;
}; };
/* spi_flash needs to be first so upper layers can free() it */
struct gigadevice_spi_flash {
struct spi_flash flash;
const struct gigadevice_spi_flash_params *params;
};
static inline struct gigadevice_spi_flash *
to_gigadevice_spi_flash(const struct spi_flash *flash)
{
return container_of(flash, struct gigadevice_spi_flash, flash);
}
static const struct gigadevice_spi_flash_params gigadevice_spi_flash_table[] = { static const struct gigadevice_spi_flash_params gigadevice_spi_flash_table[] = {
{ {
.id = 0x4014, .id = 0x4014,
@ -123,7 +111,6 @@ static const struct gigadevice_spi_flash_params gigadevice_spi_flash_table[] = {
static int gigadevice_write(const struct spi_flash *flash, u32 offset, static int gigadevice_write(const struct spi_flash *flash, u32 offset,
size_t len, const void *buf) size_t len, const void *buf)
{ {
struct gigadevice_spi_flash *stm = to_gigadevice_spi_flash(flash);
unsigned long byte_addr; unsigned long byte_addr;
unsigned long page_size; unsigned long page_size;
size_t chunk_len; size_t chunk_len;
@ -131,7 +118,7 @@ static int gigadevice_write(const struct spi_flash *flash, u32 offset,
int ret = 0; int ret = 0;
u8 cmd[4]; u8 cmd[4];
page_size = 1 << stm->params->l2_page_size; page_size = flash->page_size;
for (actual = 0; actual < len; actual += chunk_len) { for (actual = 0; actual < len; actual += chunk_len) {
byte_addr = offset % page_size; byte_addr = offset % page_size;
@ -183,12 +170,11 @@ out:
return ret; return ret;
} }
static struct gigadevice_spi_flash stm; static struct spi_flash flash;
struct spi_flash *spi_flash_probe_gigadevice(struct spi_slave *spi, u8 *idcode) struct spi_flash *spi_flash_probe_gigadevice(struct spi_slave *spi, u8 *idcode)
{ {
const struct gigadevice_spi_flash_params *params; const struct gigadevice_spi_flash_params *params;
unsigned page_size;
unsigned int i; unsigned int i;
for (i = 0; i < ARRAY_SIZE(gigadevice_spi_flash_table); i++) { for (i = 0; i < ARRAY_SIZE(gigadevice_spi_flash_table); i++) {
@ -204,28 +190,25 @@ struct spi_flash *spi_flash_probe_gigadevice(struct spi_slave *spi, u8 *idcode)
return NULL; return NULL;
} }
stm.params = params; memcpy(&flash.spi, spi, sizeof(*spi));
memcpy(&stm.flash.spi, spi, sizeof(*spi)); flash.name = params->name;
stm.flash.name = params->name;
/* Assuming power-of-two page size initially. */ /* Assuming power-of-two page size initially. */
page_size = 1 << params->l2_page_size; flash.page_size = 1 << params->l2_page_size;
flash.sector_size = flash.page_size * params->pages_per_sector;
flash.size = flash.sector_size * params->sectors_per_block *
params->nr_blocks;
flash.erase_cmd = CMD_GD25_SE;
flash.status_cmd = CMD_GD25_RDSR;
stm.flash.internal_write = gigadevice_write; flash.internal_write = gigadevice_write;
stm.flash.internal_erase = spi_flash_cmd_erase; flash.internal_erase = spi_flash_cmd_erase;
stm.flash.internal_status = spi_flash_cmd_status; flash.internal_status = spi_flash_cmd_status;
#if CONFIG_SPI_FLASH_NO_FAST_READ #if CONFIG_SPI_FLASH_NO_FAST_READ
stm.flash.internal_read = spi_flash_cmd_read_slow; flash.internal_read = spi_flash_cmd_read_slow;
#else #else
stm.flash.internal_read = spi_flash_cmd_read_fast; flash.internal_read = spi_flash_cmd_read_fast;
#endif #endif
stm.flash.sector_size = (1 << stm.params->l2_page_size) *
stm.params->pages_per_sector;
stm.flash.size = page_size * params->pages_per_sector
* params->sectors_per_block
* params->nr_blocks;
stm.flash.erase_cmd = CMD_GD25_SE;
stm.flash.status_cmd = CMD_GD25_RDSR;
return &stm.flash; return &flash;
} }

44
src/drivers/spi/macronix.c
View File

@ -54,17 +54,6 @@ struct macronix_spi_flash_params {
const char *name; const char *name;
}; };
struct macronix_spi_flash {
struct spi_flash flash;
const struct macronix_spi_flash_params *params;
};
static inline
struct macronix_spi_flash *to_macronix_spi_flash(const struct spi_flash *flash)
{
return container_of(flash, struct macronix_spi_flash, flash);
}
static const struct macronix_spi_flash_params macronix_spi_flash_table[] = { static const struct macronix_spi_flash_params macronix_spi_flash_table[] = {
{ {
.idcode = 0x2015, .idcode = 0x2015,
@ -151,7 +140,6 @@ static const struct macronix_spi_flash_params macronix_spi_flash_table[] = {
static int macronix_write(const struct spi_flash *flash, u32 offset, size_t len, static int macronix_write(const struct spi_flash *flash, u32 offset, size_t len,
const void *buf) const void *buf)
{ {
struct macronix_spi_flash *mcx = to_macronix_spi_flash(flash);
unsigned long byte_addr; unsigned long byte_addr;
unsigned long page_size; unsigned long page_size;
size_t chunk_len; size_t chunk_len;
@ -159,7 +147,7 @@ static int macronix_write(const struct spi_flash *flash, u32 offset, size_t len,
int ret = 0; int ret = 0;
u8 cmd[4]; u8 cmd[4];
page_size = mcx->params->page_size; page_size = flash->page_size;
for (actual = 0; actual < len; actual += chunk_len) { for (actual = 0; actual < len; actual += chunk_len) {
byte_addr = offset % page_size; byte_addr = offset % page_size;
@ -204,7 +192,7 @@ static int macronix_write(const struct spi_flash *flash, u32 offset, size_t len,
return ret; return ret;
} }
static struct macronix_spi_flash mcx; static struct spi_flash flash;
struct spi_flash *spi_flash_probe_macronix(struct spi_slave *spi, u8 *idcode) struct spi_flash *spi_flash_probe_macronix(struct spi_slave *spi, u8 *idcode)
{ {
@ -223,23 +211,23 @@ struct spi_flash *spi_flash_probe_macronix(struct spi_slave *spi, u8 *idcode)
return NULL; return NULL;
} }
mcx.params = params; memcpy(&flash.spi, spi, sizeof(*spi));
memcpy(&mcx.flash.spi, spi, sizeof(*spi)); flash.name = params->name;
mcx.flash.name = params->name; flash.page_size = params->page_size;
flash.sector_size = params->page_size * params->pages_per_sector;
flash.size = flash.sector_size * params->sectors_per_block *
params->nr_blocks;
flash.erase_cmd = CMD_MX25XX_SE;
flash.status_cmd = CMD_MX25XX_RDSR;
mcx.flash.internal_write = macronix_write; flash.internal_write = macronix_write;
mcx.flash.internal_erase = spi_flash_cmd_erase; flash.internal_erase = spi_flash_cmd_erase;
mcx.flash.internal_status = spi_flash_cmd_status; flash.internal_status = spi_flash_cmd_status;
#if CONFIG_SPI_FLASH_NO_FAST_READ #if CONFIG_SPI_FLASH_NO_FAST_READ
mcx.flash.internal_read = spi_flash_cmd_read_slow; flash.internal_read = spi_flash_cmd_read_slow;
#else #else
mcx.flash.internal_read = spi_flash_cmd_read_fast; flash.internal_read = spi_flash_cmd_read_fast;
#endif #endif
mcx.flash.sector_size = params->page_size * params->pages_per_sector;
mcx.flash.size = mcx.flash.sector_size * params->sectors_per_block *
params->nr_blocks;
mcx.flash.erase_cmd = CMD_MX25XX_SE;
mcx.flash.status_cmd = CMD_MX25XX_RDSR;
return &mcx.flash; return &flash;
} }

43
src/drivers/spi/spansion.c
View File

@ -64,17 +64,6 @@ struct spansion_spi_flash_params {
const char *name; const char *name;
}; };
struct spansion_spi_flash {
struct spi_flash flash;
const struct spansion_spi_flash_params *params;
};
static inline
struct spansion_spi_flash *to_spansion_spi_flash(const struct spi_flash *flash)
{
return container_of(flash, struct spansion_spi_flash, flash);
}
/* /*
* returns non-zero if the given idcode matches the ID of the chip. this is for * returns non-zero if the given idcode matches the ID of the chip. this is for
* chips which use 2nd, 3rd, 4th, and 5th byte. * chips which use 2nd, 3rd, 4th, and 5th byte.
@ -204,7 +193,6 @@ static const struct spansion_spi_flash_params spansion_spi_flash_table[] = {
static int spansion_write(const struct spi_flash *flash, u32 offset, size_t len, static int spansion_write(const struct spi_flash *flash, u32 offset, size_t len,
const void *buf) const void *buf)
{ {
struct spansion_spi_flash *spsn = to_spansion_spi_flash(flash);
unsigned long byte_addr; unsigned long byte_addr;
unsigned long page_size; unsigned long page_size;
size_t chunk_len; size_t chunk_len;
@ -212,7 +200,7 @@ static int spansion_write(const struct spi_flash *flash, u32 offset, size_t len,
int ret = 0; int ret = 0;
u8 cmd[4]; u8 cmd[4];
page_size = spsn->params->page_size; page_size = flash->page_size;
for (actual = 0; actual < len; actual += chunk_len) { for (actual = 0; actual < len; actual += chunk_len) {
byte_addr = offset % page_size; byte_addr = offset % page_size;
@ -258,12 +246,11 @@ static int spansion_write(const struct spi_flash *flash, u32 offset, size_t len,
return ret; return ret;
} }
static struct spansion_spi_flash spsn_flash; static struct spi_flash flash;
struct spi_flash *spi_flash_probe_spansion(struct spi_slave *spi, u8 *idcode) struct spi_flash *spi_flash_probe_spansion(struct spi_slave *spi, u8 *idcode)
{ {
const struct spansion_spi_flash_params *params; const struct spansion_spi_flash_params *params;
struct spansion_spi_flash *spsn;
unsigned int i; unsigned int i;
for (i = 0; i < ARRAY_SIZE(spansion_spi_flash_table); i++) { for (i = 0; i < ARRAY_SIZE(spansion_spi_flash_table); i++) {
@ -279,20 +266,18 @@ struct spi_flash *spi_flash_probe_spansion(struct spi_slave *spi, u8 *idcode)
return NULL; return NULL;
} }
spsn = &spsn_flash; memcpy(&flash.spi, spi, sizeof(*spi));
flash.name = params->name;
flash.page_size = params->page_size;
flash.sector_size = params->page_size * params->pages_per_sector;
flash.size = flash.sector_size * params->nr_sectors;
flash.erase_cmd = CMD_S25FLXX_SE;
flash.status_cmd = CMD_S25FLXX_RDSR;
spsn->params = params; flash.internal_write = spansion_write;
memcpy(&spsn->flash.spi, spi, sizeof(*spi)); flash.internal_erase = spi_flash_cmd_erase;
spsn->flash.name = params->name; flash.internal_read = spi_flash_cmd_read_slow;
flash.internal_status = spi_flash_cmd_status;
spsn->flash.internal_write = spansion_write; return &flash;
spsn->flash.internal_erase = spi_flash_cmd_erase;
spsn->flash.internal_read = spi_flash_cmd_read_slow;
spsn->flash.internal_status = spi_flash_cmd_status;
spsn->flash.sector_size = params->page_size * params->pages_per_sector;
spsn->flash.size = spsn->flash.sector_size * params->nr_sectors;
spsn->flash.erase_cmd = CMD_S25FLXX_SE;
spsn->flash.status_cmd = CMD_S25FLXX_RDSR;
return &spsn->flash;
} }

36
src/drivers/spi/sst.c
View File

@ -47,11 +47,6 @@ struct sst_spi_flash_params {
size_t len, const void *buf); size_t len, const void *buf);
}; };
struct sst_spi_flash {
struct spi_flash flash;
const struct sst_spi_flash_params *params;
};
static int sst_write_ai(const struct spi_flash *flash, u32 offset, size_t len, static int sst_write_ai(const struct spi_flash *flash, u32 offset, size_t len,
const void *buf); const void *buf);
static int sst_write_256(const struct spi_flash *flash, u32 offset, size_t len, static int sst_write_256(const struct spi_flash *flash, u32 offset, size_t len,
@ -323,7 +318,7 @@ struct spi_flash *
spi_flash_probe_sst(struct spi_slave *spi, u8 *idcode) spi_flash_probe_sst(struct spi_slave *spi, u8 *idcode)
{ {
const struct sst_spi_flash_params *params; const struct sst_spi_flash_params *params;
struct sst_spi_flash *stm; struct spi_flash *flash;
size_t i; size_t i;
for (i = 0; i < ARRAY_SIZE(sst_spi_flash_table); ++i) { for (i = 0; i < ARRAY_SIZE(sst_spi_flash_table); ++i) {
@ -337,27 +332,26 @@ spi_flash_probe_sst(struct spi_slave *spi, u8 *idcode)
return NULL; return NULL;
} }
stm = malloc(sizeof(*stm)); flash = malloc(sizeof(*flash));
if (!stm) { if (!flash) {
printk(BIOS_WARNING, "SF: Failed to allocate memory\n"); printk(BIOS_WARNING, "SF: Failed to allocate memory\n");
return NULL; return NULL;
} }
stm->params = params; memcpy(&flash->spi, spi, sizeof(*spi));
memcpy(&stm->flash.spi, spi, sizeof(*spi)); flash->name = params->name;
stm->flash.name = params->name; flash->sector_size = SST_SECTOR_SIZE;
flash->size = flash->sector_size * params->nr_sectors;
flash->erase_cmd = CMD_SST_SE;
flash->status_cmd = CMD_SST_RDSR;
stm->flash.internal_write = params->write; flash->internal_write = params->write;
stm->flash.internal_erase = spi_flash_cmd_erase; flash->internal_erase = spi_flash_cmd_erase;
stm->flash.internal_status = spi_flash_cmd_status; flash->internal_status = spi_flash_cmd_status;
stm->flash.internal_read = spi_flash_cmd_read_fast; flash->internal_read = spi_flash_cmd_read_fast;
stm->flash.sector_size = SST_SECTOR_SIZE;
stm->flash.size = stm->flash.sector_size * params->nr_sectors;
stm->flash.erase_cmd = CMD_SST_SE;
stm->flash.status_cmd = CMD_SST_RDSR;
/* Flash powers up read-only, so clear BP# bits */ /* Flash powers up read-only, so clear BP# bits */
sst_unlock(&stm->flash); sst_unlock(flash);
return &stm->flash; return flash;
} }

37
src/drivers/spi/stmicro.c
View File

@ -66,18 +66,6 @@ struct stmicro_spi_flash_params {
const char *name; const char *name;
}; };
/* spi_flash needs to be first so upper layers can free() it */
struct stmicro_spi_flash {
struct spi_flash flash;
const struct stmicro_spi_flash_params *params;
};
static inline
struct stmicro_spi_flash *to_stmicro_spi_flash(const struct spi_flash *flash)
{
return container_of(flash, struct stmicro_spi_flash, flash);
}
static const struct stmicro_spi_flash_params stmicro_spi_flash_table[] = { static const struct stmicro_spi_flash_params stmicro_spi_flash_table[] = {
{ {
.device_id = STM_ID_M25P10, .device_id = STM_ID_M25P10,
@ -180,7 +168,6 @@ static const struct stmicro_spi_flash_params stmicro_spi_flash_table[] = {
static int stmicro_write(const struct spi_flash *flash, static int stmicro_write(const struct spi_flash *flash,
u32 offset, size_t len, const void *buf) u32 offset, size_t len, const void *buf)
{ {
struct stmicro_spi_flash *stm = to_stmicro_spi_flash(flash);
unsigned long byte_addr; unsigned long byte_addr;
unsigned long page_size; unsigned long page_size;
size_t chunk_len; size_t chunk_len;
@ -188,7 +175,7 @@ static int stmicro_write(const struct spi_flash *flash,
int ret = 0; int ret = 0;
u8 cmd[4]; u8 cmd[4];
page_size = stm->params->page_size; page_size = flash->page_size;
for (actual = 0; actual < len; actual += chunk_len) { for (actual = 0; actual < len; actual += chunk_len) {
byte_addr = offset % page_size; byte_addr = offset % page_size;
@ -235,7 +222,7 @@ out:
return ret; return ret;
} }
static struct stmicro_spi_flash stm; static struct spi_flash flash;
struct spi_flash *spi_flash_probe_stmicro(struct spi_slave *spi, u8 * idcode) struct spi_flash *spi_flash_probe_stmicro(struct spi_slave *spi, u8 * idcode)
{ {
@ -267,16 +254,16 @@ struct spi_flash *spi_flash_probe_stmicro(struct spi_slave *spi, u8 * idcode)
return NULL; return NULL;
} }
stm.params = params; memcpy(&flash.spi, spi, sizeof(*spi));
memcpy(&stm.flash.spi, spi, sizeof(*spi)); flash.name = params->name;
stm.flash.name = params->name; flash.page_size = params->page_size;
flash.sector_size = params->page_size * params->pages_per_sector;
flash.size = flash.sector_size * params->nr_sectors;
flash.erase_cmd = params->op_erase;
stm.flash.internal_write = stmicro_write; flash.internal_write = stmicro_write;
stm.flash.internal_erase = spi_flash_cmd_erase; flash.internal_erase = spi_flash_cmd_erase;
stm.flash.internal_read = spi_flash_cmd_read_fast; flash.internal_read = spi_flash_cmd_read_fast;
stm.flash.sector_size = params->page_size * params->pages_per_sector;
stm.flash.size = stm.flash.sector_size * params->nr_sectors;
stm.flash.erase_cmd = params->op_erase;
return &stm.flash; return &flash;
} }

50
src/drivers/spi/winbond.c
View File

@ -36,18 +36,6 @@ struct winbond_spi_flash_params {
const char *name; const char *name;
}; };
/* spi_flash needs to be first so upper layers can free() it */
struct winbond_spi_flash {
struct spi_flash flash;
const struct winbond_spi_flash_params *params;
};
static inline struct winbond_spi_flash *
to_winbond_spi_flash(const struct spi_flash *flash)
{
return container_of(flash, struct winbond_spi_flash, flash);
}
static const struct winbond_spi_flash_params winbond_spi_flash_table[] = { static const struct winbond_spi_flash_params winbond_spi_flash_table[] = {
{ {
.id = 0x3015, .id = 0x3015,
@ -142,7 +130,6 @@ static const struct winbond_spi_flash_params winbond_spi_flash_table[] = {
static int winbond_write(const struct spi_flash *flash, u32 offset, size_t len, static int winbond_write(const struct spi_flash *flash, u32 offset, size_t len,
const void *buf) const void *buf)
{ {
struct winbond_spi_flash *stm = to_winbond_spi_flash(flash);
unsigned long byte_addr; unsigned long byte_addr;
unsigned long page_size; unsigned long page_size;
size_t chunk_len; size_t chunk_len;
@ -150,7 +137,7 @@ static int winbond_write(const struct spi_flash *flash, u32 offset, size_t len,
int ret = 0; int ret = 0;
u8 cmd[4]; u8 cmd[4];
page_size = 1 << stm->params->l2_page_size; page_size = flash->page_size;
for (actual = 0; actual < len; actual += chunk_len) { for (actual = 0; actual < len; actual += chunk_len) {
byte_addr = offset % page_size; byte_addr = offset % page_size;
@ -197,12 +184,11 @@ out:
return ret; return ret;
} }
static struct winbond_spi_flash stm; static struct spi_flash flash;
struct spi_flash *spi_flash_probe_winbond(struct spi_slave *spi, u8 *idcode) struct spi_flash *spi_flash_probe_winbond(struct spi_slave *spi, u8 *idcode)
{ {
const struct winbond_spi_flash_params *params; const struct winbond_spi_flash_params *params;
unsigned page_size;
unsigned int i; unsigned int i;
for (i = 0; i < ARRAY_SIZE(winbond_spi_flash_table); i++) { for (i = 0; i < ARRAY_SIZE(winbond_spi_flash_table); i++) {
@ -217,28 +203,24 @@ struct spi_flash *spi_flash_probe_winbond(struct spi_slave *spi, u8 *idcode)
return NULL; return NULL;
} }
stm.params = params; memcpy(&flash.spi, spi, sizeof(*spi));
memcpy(&stm.flash.spi, spi, sizeof(*spi)); flash.name = params->name;
stm.flash.name = params->name;
/* Assuming power-of-two page size initially. */ /* Assuming power-of-two page size initially. */
page_size = 1 << params->l2_page_size; flash.page_size = 1 << params->l2_page_size;
flash.sector_size = flash.page_size * params->pages_per_sector;
flash.size = flash.sector_size * params->sectors_per_block *
params->nr_blocks;
flash.erase_cmd = CMD_W25_SE;
flash.status_cmd = CMD_W25_RDSR;
stm.flash.internal_write = winbond_write; flash.internal_write = winbond_write;
stm.flash.internal_erase = spi_flash_cmd_erase; flash.internal_erase = spi_flash_cmd_erase;
stm.flash.internal_status = spi_flash_cmd_status; flash.internal_status = spi_flash_cmd_status;
#if CONFIG_SPI_FLASH_NO_FAST_READ #if CONFIG_SPI_FLASH_NO_FAST_READ
stm.flash.internal_read = spi_flash_cmd_read_slow; flash.internal_read = spi_flash_cmd_read_slow;
#else #else
stm.flash.internal_read = spi_flash_cmd_read_fast; flash.internal_read = spi_flash_cmd_read_fast;
#endif #endif
stm.flash.sector_size = (1 << stm.params->l2_page_size) *
stm.params->pages_per_sector;
stm.flash.size = page_size * params->pages_per_sector
* params->sectors_per_block
* params->nr_blocks;
stm.flash.erase_cmd = CMD_W25_SE;
stm.flash.status_cmd = CMD_W25_RDSR;
return &stm.flash; return &flash;
} }

1
src/include/spi_flash.h
View File

@ -29,6 +29,7 @@ struct spi_flash {
const char *name; const char *name;
u32 size; u32 size;
u32 sector_size; u32 sector_size;
u32 page_size;
u8 erase_cmd; u8 erase_cmd;
u8 status_cmd; u8 status_cmd;
/* /*

12
src/soc/intel/common/block/fast_spi/fast_spi_flash.c
View File

@ -154,12 +154,13 @@ static int exec_sync_hwseq_xfer(struct fast_spi_flash_ctx *ctx,
/* /*
* Ensure read/write xfer len is not greater than SPIBAR_FDATA_FIFO_SIZE and * Ensure read/write xfer len is not greater than SPIBAR_FDATA_FIFO_SIZE and
* that the operation does not cross 256-byte boundary. * that the operation does not cross page boundary.
*/ */
static size_t get_xfer_len(uint32_t addr, size_t len) static size_t get_xfer_len(const struct spi_flash *flash, uint32_t addr,
size_t len)
{ {
size_t xfer_len = min(len, SPIBAR_FDATA_FIFO_SIZE); size_t xfer_len = min(len, SPIBAR_FDATA_FIFO_SIZE);
size_t bytes_left = ALIGN_UP(addr, 256) - addr; size_t bytes_left = ALIGN_UP(addr, flash->page_size) - addr;
if (bytes_left) if (bytes_left)
xfer_len = min(xfer_len, bytes_left); xfer_len = min(xfer_len, bytes_left);
@ -217,7 +218,7 @@ static int fast_spi_flash_read(const struct spi_flash *flash,
BOILERPLATE_CREATE_CTX(ctx); BOILERPLATE_CREATE_CTX(ctx);
while (len) { while (len) {
xfer_len = get_xfer_len(addr, len); xfer_len = get_xfer_len(flash, addr, len);
ret = exec_sync_hwseq_xfer(ctx, SPIBAR_HSFSTS_CYCLE_READ, ret = exec_sync_hwseq_xfer(ctx, SPIBAR_HSFSTS_CYCLE_READ,
addr, xfer_len); addr, xfer_len);
@ -244,7 +245,7 @@ static int fast_spi_flash_write(const struct spi_flash *flash,
BOILERPLATE_CREATE_CTX(ctx); BOILERPLATE_CREATE_CTX(ctx);
while (len) { while (len) {
xfer_len = get_xfer_len(addr, len); xfer_len = get_xfer_len(flash, addr, len);
fill_xfer_fifo(ctx, data, xfer_len); fill_xfer_fifo(ctx, data, xfer_len);
ret = exec_sync_hwseq_xfer(ctx, SPIBAR_HSFSTS_CYCLE_WRITE, ret = exec_sync_hwseq_xfer(ctx, SPIBAR_HSFSTS_CYCLE_WRITE,
@ -303,6 +304,7 @@ struct spi_flash *spi_flash_programmer_probe(struct spi_slave *dev, int force)
/* Can erase both 4 KiB and 64 KiB chunks. Declare the smaller size. */ /* Can erase both 4 KiB and 64 KiB chunks. Declare the smaller size. */
flash->sector_size = 4 * KiB; flash->sector_size = 4 * KiB;
flash->page_size = 256;
/* /*
* FIXME: Get erase+cmd, and status_cmd from SFDP. * FIXME: Get erase+cmd, and status_cmd from SFDP.
* *