/* SPDX-License-Identifier: GPL-2.0-or-later */ #include <assert.h> #include <boot/coreboot_tables.h> #include <commonlib/region.h> #include <console/console.h> #include <string.h> #include <spi-generic.h> #include <spi_flash.h> #include <timer.h> #include <types.h> #include "spi_flash_internal.h" static void spi_flash_addr(u32 addr, u8 *cmd) { /* cmd[0] is actual command */ cmd[1] = addr >> 16; cmd[2] = addr >> 8; cmd[3] = addr >> 0; } static int do_spi_flash_cmd(const struct spi_slave *spi, const u8 *dout, size_t bytes_out, void *din, size_t bytes_in) { int ret; /* * SPI flash requires command-response kind of behavior. Thus, two * separate SPI vectors are required -- first to transmit dout and other * to receive in din. If some specialized SPI flash controllers * (e.g. x86) can perform both command and response together, it should * be handled at SPI flash controller driver level. */ struct spi_op vectors[] = { [0] = { .dout = dout, .bytesout = bytes_out, .din = NULL, .bytesin = 0, }, [1] = { .dout = NULL, .bytesout = 0, .din = din, .bytesin = bytes_in }, }; size_t count = ARRAY_SIZE(vectors); if (!bytes_in) count = 1; ret = spi_claim_bus(spi); if (ret) return ret; ret = spi_xfer_vector(spi, vectors, count); spi_release_bus(spi); return ret; } static int do_dual_output_cmd(const struct spi_slave *spi, const u8 *dout, size_t bytes_out, void *din, size_t bytes_in) { int ret; /* * spi_xfer_vector() will automatically fall back to .xfer() if * .xfer_vector() is unimplemented. So using vector API here is more * flexible, even though a controller that implements .xfer_vector() * and (the non-vector based) .xfer_dual() but not .xfer() would be * pretty odd. */ struct spi_op vector = { .dout = dout, .bytesout = bytes_out, .din = NULL, .bytesin = 0 }; ret = spi_claim_bus(spi); if (ret) return ret; ret = spi_xfer_vector(spi, &vector, 1); if (!ret) ret = spi->ctrlr->xfer_dual(spi, NULL, 0, din, bytes_in); spi_release_bus(spi); return ret; } static int do_dual_io_cmd(const struct spi_slave *spi, const u8 *dout, size_t bytes_out, void *din, size_t bytes_in) { int ret; /* Only the very first byte (opcode) is transferred in "single" mode. */ struct spi_op vector = { .dout = dout, .bytesout = 1, .din = NULL, .bytesin = 0 }; ret = spi_claim_bus(spi); if (ret) return ret; ret = spi_xfer_vector(spi, &vector, 1); if (!ret) ret = spi->ctrlr->xfer_dual(spi, &dout[1], bytes_out - 1, NULL, 0); if (!ret) ret = spi->ctrlr->xfer_dual(spi, NULL, 0, din, bytes_in); spi_release_bus(spi); return ret; } int spi_flash_cmd(const struct spi_slave *spi, u8 cmd, void *response, size_t len) { int ret = do_spi_flash_cmd(spi, &cmd, sizeof(cmd), response, len); if (ret) printk(BIOS_WARNING, "SF: Failed to send command %02x: %d\n", cmd, ret); return ret; } /* TODO: This code is quite possibly broken and overflowing stacks. Fix ASAP! */ #pragma GCC diagnostic push #if defined(__GNUC__) && !defined(__clang__) #pragma GCC diagnostic ignored "-Wstack-usage=" #endif #pragma GCC diagnostic ignored "-Wvla" int spi_flash_cmd_write(const struct spi_slave *spi, const u8 *cmd, size_t cmd_len, const void *data, size_t data_len) { int ret; u8 buff[cmd_len + data_len]; memcpy(buff, cmd, cmd_len); memcpy(buff + cmd_len, data, data_len); ret = do_spi_flash_cmd(spi, buff, cmd_len + data_len, NULL, 0); if (ret) { printk(BIOS_WARNING, "SF: Failed to send write command (%zu bytes): %d\n", data_len, ret); } return ret; } #pragma GCC diagnostic pop /* Perform the read operation honoring spi controller fifo size, reissuing * the read command until the full request completed. */ int spi_flash_cmd_read(const struct spi_flash *flash, u32 offset, size_t len, void *buf) { u8 cmd[5]; int ret, cmd_len; int (*do_cmd)(const struct spi_slave *spi, const u8 *din, size_t in_bytes, void *out, size_t out_bytes); if (CONFIG(SPI_FLASH_NO_FAST_READ)) { cmd_len = 4; cmd[0] = CMD_READ_ARRAY_SLOW; do_cmd = do_spi_flash_cmd; } else if (flash->flags.dual_io && flash->spi.ctrlr->xfer_dual) { cmd_len = 5; cmd[0] = CMD_READ_FAST_DUAL_IO; cmd[4] = 0; do_cmd = do_dual_io_cmd; } else if (flash->flags.dual_output && flash->spi.ctrlr->xfer_dual) { cmd_len = 5; cmd[0] = CMD_READ_FAST_DUAL_OUTPUT; cmd[4] = 0; do_cmd = do_dual_output_cmd; } else { cmd_len = 5; cmd[0] = CMD_READ_ARRAY_FAST; cmd[4] = 0; do_cmd = do_spi_flash_cmd; } uint8_t *data = buf; while (len) { size_t xfer_len = spi_crop_chunk(&flash->spi, cmd_len, len); spi_flash_addr(offset, cmd); ret = do_cmd(&flash->spi, cmd, cmd_len, data, xfer_len); if (ret) { printk(BIOS_WARNING, "SF: Failed to send read command %#.2x(%#x, %#zx): %d\n", cmd[0], offset, xfer_len, ret); return ret; } offset += xfer_len; data += xfer_len; len -= xfer_len; } return 0; } int spi_flash_cmd_poll_bit(const struct spi_flash *flash, unsigned long timeout, u8 cmd, u8 poll_bit) { const struct spi_slave *spi = &flash->spi; int ret; int attempt = 0; u8 status; struct stopwatch sw; stopwatch_init_msecs_expire(&sw, timeout); do { attempt++; ret = do_spi_flash_cmd(spi, &cmd, 1, &status, 1); if (ret) { printk(BIOS_WARNING, "SF: SPI command failed on attempt %d with rc %d\n", attempt, ret); return -1; } if ((status & poll_bit) == 0) return 0; } while (!stopwatch_expired(&sw)); printk(BIOS_WARNING, "SF: timeout at %ld msec after %d attempts\n", stopwatch_duration_msecs(&sw), attempt); return -1; } int spi_flash_cmd_wait_ready(const struct spi_flash *flash, unsigned long timeout) { return spi_flash_cmd_poll_bit(flash, timeout, CMD_READ_STATUS, STATUS_WIP); } int spi_flash_cmd_erase(const struct spi_flash *flash, u32 offset, size_t len) { u32 start, end, erase_size; int ret = -1; u8 cmd[4]; erase_size = flash->sector_size; if (offset % erase_size || len % erase_size) { printk(BIOS_WARNING, "SF: Erase offset/length not multiple of erase size\n"); return -1; } if (len == 0) { printk(BIOS_WARNING, "SF: Erase length cannot be 0\n"); return -1; } cmd[0] = flash->erase_cmd; start = offset; end = start + len; while (offset < end) { spi_flash_addr(offset, cmd); offset += erase_size; #if CONFIG(DEBUG_SPI_FLASH) printk(BIOS_SPEW, "SF: erase %2x %2x %2x %2x (%x)\n", cmd[0], cmd[1], cmd[2], cmd[3], offset); #endif ret = spi_flash_cmd(&flash->spi, CMD_WRITE_ENABLE, NULL, 0); if (ret) goto out; ret = spi_flash_cmd_write(&flash->spi, cmd, sizeof(cmd), NULL, 0); if (ret) goto out; ret = spi_flash_cmd_wait_ready(flash, SPI_FLASH_PAGE_ERASE_TIMEOUT_MS); if (ret) goto out; } printk(BIOS_DEBUG, "SF: Successfully erased %zu bytes @ %#x\n", len, start); out: return ret; } int spi_flash_cmd_status(const struct spi_flash *flash, u8 *reg) { return spi_flash_cmd(&flash->spi, flash->status_cmd, reg, sizeof(*reg)); } int spi_flash_cmd_write_page_program(const struct spi_flash *flash, u32 offset, size_t len, const void *buf) { unsigned long byte_addr; unsigned long page_size; size_t chunk_len; size_t actual; int ret = 0; u8 cmd[4]; page_size = flash->page_size; cmd[0] = flash->pp_cmd; for (actual = 0; actual < len; actual += chunk_len) { byte_addr = offset % page_size; chunk_len = MIN(len - actual, page_size - byte_addr); chunk_len = spi_crop_chunk(&flash->spi, sizeof(cmd), chunk_len); spi_flash_addr(offset, cmd); if (CONFIG(DEBUG_SPI_FLASH)) { printk(BIOS_SPEW, "PP: %p => cmd = { 0x%02x 0x%02x%02x%02x } chunk_len = %zu\n", buf + actual, cmd[0], cmd[1], cmd[2], cmd[3], chunk_len); } ret = spi_flash_cmd(&flash->spi, flash->wren_cmd, NULL, 0); if (ret < 0) { printk(BIOS_WARNING, "SF: Enabling Write failed\n"); goto out; } ret = spi_flash_cmd_write(&flash->spi, cmd, sizeof(cmd), buf + actual, chunk_len); if (ret < 0) { printk(BIOS_WARNING, "SF: Page Program failed\n"); goto out; } ret = spi_flash_cmd_wait_ready(flash, SPI_FLASH_PROG_TIMEOUT_MS); if (ret) goto out; offset += chunk_len; } if (CONFIG(DEBUG_SPI_FLASH)) printk(BIOS_SPEW, "SF: : Successfully programmed %zu bytes @ 0x%lx\n", len, (unsigned long)(offset - len)); ret = 0; out: return ret; } static const struct spi_flash_vendor_info *spi_flash_vendors[] = { #if CONFIG(SPI_FLASH_ADESTO) &spi_flash_adesto_vi, #endif #if CONFIG(SPI_FLASH_AMIC) &spi_flash_amic_vi, #endif #if CONFIG(SPI_FLASH_ATMEL) &spi_flash_atmel_vi, #endif #if CONFIG(SPI_FLASH_EON) &spi_flash_eon_vi, #endif #if CONFIG(SPI_FLASH_GIGADEVICE) &spi_flash_gigadevice_vi, #endif #if CONFIG(SPI_FLASH_MACRONIX) &spi_flash_macronix_vi, #endif #if CONFIG(SPI_FLASH_SPANSION) &spi_flash_spansion_ext1_vi, &spi_flash_spansion_ext2_vi, &spi_flash_spansion_vi, #endif #if CONFIG(SPI_FLASH_SST) &spi_flash_sst_ai_vi, &spi_flash_sst_vi, #endif #if CONFIG(SPI_FLASH_STMICRO) &spi_flash_stmicro1_vi, &spi_flash_stmicro2_vi, &spi_flash_stmicro3_vi, &spi_flash_stmicro4_vi, #endif #if CONFIG(SPI_FLASH_WINBOND) &spi_flash_winbond_vi, #endif }; #define IDCODE_LEN 5 static int fill_spi_flash(const struct spi_slave *spi, struct spi_flash *flash, const struct spi_flash_vendor_info *vi, const struct spi_flash_part_id *part) { memcpy(&flash->spi, spi, sizeof(*spi)); flash->vendor = vi->id; flash->model = part->id[0]; flash->page_size = 1U << vi->page_size_shift; flash->sector_size = (1U << vi->sector_size_kib_shift) * KiB; flash->size = flash->sector_size * (1U << part->nr_sectors_shift); flash->erase_cmd = vi->desc->erase_cmd; flash->status_cmd = vi->desc->status_cmd; flash->pp_cmd = vi->desc->pp_cmd; flash->wren_cmd = vi->desc->wren_cmd; flash->flags.dual_output = part->fast_read_dual_output_support; flash->flags.dual_io = part->fast_read_dual_io_support; flash->ops = &vi->desc->ops; flash->prot_ops = vi->prot_ops; flash->part = part; if (vi->after_probe) return vi->after_probe(flash); return 0; } static const struct spi_flash_part_id *find_part(const struct spi_flash_vendor_info *vi, uint16_t id[2]) { size_t i; const uint16_t lid[2] = { [0] = id[0] & vi->match_id_mask[0], [1] = id[1] & vi->match_id_mask[1], }; for (i = 0; i < vi->nr_part_ids; i++) { const struct spi_flash_part_id *part = &vi->ids[i]; if (part->id[0] == lid[0] && part->id[1] == lid[1]) return part; } return NULL; } static int find_match(const struct spi_slave *spi, struct spi_flash *flash, uint8_t manuf_id, uint16_t id[2]) { int i; for (i = 0; i < (int)ARRAY_SIZE(spi_flash_vendors); i++) { const struct spi_flash_vendor_info *vi; const struct spi_flash_part_id *part; vi = spi_flash_vendors[i]; if (manuf_id != vi->id) continue; part = find_part(vi, id); if (part == NULL) continue; return fill_spi_flash(spi, flash, vi, part); } return -1; } int spi_flash_generic_probe(const struct spi_slave *spi, struct spi_flash *flash) { int ret, i; u8 idcode[IDCODE_LEN]; u8 manuf_id; u16 id[2]; /* Read the ID codes */ ret = spi_flash_cmd(spi, CMD_READ_ID, idcode, sizeof(idcode)); if (ret) return -1; if (CONFIG(DEBUG_SPI_FLASH)) { printk(BIOS_SPEW, "SF: Got idcode: "); for (i = 0; i < sizeof(idcode); i++) printk(BIOS_SPEW, "%02x ", idcode[i]); printk(BIOS_SPEW, "\n"); } manuf_id = idcode[0]; printk(BIOS_INFO, "Manufacturer: %02x\n", manuf_id); /* If no result from RDID command and STMicro parts are enabled attempt to wake the part from deep sleep and obtain alternative id info. */ if (CONFIG(SPI_FLASH_STMICRO) && manuf_id == 0xff) { if (stmicro_release_deep_sleep_identify(spi, idcode)) return -1; manuf_id = idcode[0]; } id[0] = (idcode[1] << 8) | idcode[2]; id[1] = (idcode[3] << 8) | idcode[4]; return find_match(spi, flash, manuf_id, id); } int spi_flash_probe(unsigned int bus, unsigned int cs, struct spi_flash *flash) { struct spi_slave spi; int ret = -1; if (spi_setup_slave(bus, cs, &spi)) { printk(BIOS_WARNING, "SF: Failed to set up slave\n"); return -1; } /* Try special programmer probe if any. */ if (spi.ctrlr->flash_probe) ret = spi.ctrlr->flash_probe(&spi, flash); /* If flash is not found, try generic spi flash probe. */ if (ret) ret = spi_flash_generic_probe(&spi, flash); /* Give up -- nothing more to try if flash is not found. */ if (ret) { printk(BIOS_WARNING, "SF: Unsupported manufacturer!\n"); return -1; } const char *mode_string = ""; if (flash->flags.dual_io && spi.ctrlr->xfer_dual) mode_string = " (Dual I/O mode)"; else if (flash->flags.dual_output && spi.ctrlr->xfer_dual) mode_string = " (Dual Output mode)"; printk(BIOS_INFO, "SF: Detected %02x %04x with sector size 0x%x, total 0x%x%s\n", flash->vendor, flash->model, flash->sector_size, flash->size, mode_string); if (bus == CONFIG_BOOT_DEVICE_SPI_FLASH_BUS && flash->size != CONFIG_ROM_SIZE) { printk(BIOS_ERR, "SF size 0x%x does not correspond to" " CONFIG_ROM_SIZE 0x%x!!\n", flash->size, CONFIG_ROM_SIZE); } if (CONFIG(SPI_FLASH_EXIT_4_BYTE_ADDR_MODE) && ENV_INITIAL_STAGE) spi_flash_cmd(&flash->spi, CMD_EXIT_4BYTE_ADDR_MODE, NULL, 0); return 0; } int spi_flash_read(const struct spi_flash *flash, u32 offset, size_t len, void *buf) { return flash->ops->read(flash, offset, len, buf); } int spi_flash_write(const struct spi_flash *flash, u32 offset, size_t len, const void *buf) { int ret; if (spi_flash_volatile_group_begin(flash)) return -1; ret = flash->ops->write(flash, offset, len, buf); if (spi_flash_volatile_group_end(flash)) return -1; return ret; } int spi_flash_erase(const struct spi_flash *flash, u32 offset, size_t len) { int ret; if (spi_flash_volatile_group_begin(flash)) return -1; ret = flash->ops->erase(flash, offset, len); if (spi_flash_volatile_group_end(flash)) return -1; return ret; } int spi_flash_status(const struct spi_flash *flash, u8 *reg) { if (flash->ops->status) return flash->ops->status(flash, reg); return -1; } int spi_flash_is_write_protected(const struct spi_flash *flash, const struct region *region) { struct region flash_region = { 0 }; if (!flash || !region) return -1; flash_region.size = flash->size; if (!region_is_subregion(&flash_region, region)) return -1; if (!flash->prot_ops) { printk(BIOS_WARNING, "SPI: Write-protection gathering not " "implemented for this vendor.\n"); return -1; } return flash->prot_ops->get_write(flash, region); } int spi_flash_set_write_protected(const struct spi_flash *flash, const struct region *region, const enum spi_flash_status_reg_lockdown mode) { struct region flash_region = { 0 }; int ret; if (!flash) return -1; flash_region.size = flash->size; if (!region_is_subregion(&flash_region, region)) return -1; if (!flash->prot_ops) { printk(BIOS_WARNING, "SPI: Setting write-protection is not " "implemented for this vendor.\n"); return -1; } ret = flash->prot_ops->set_write(flash, region, mode); if (ret == 0 && mode != SPI_WRITE_PROTECTION_PRESERVE) { printk(BIOS_INFO, "SPI: SREG lock-down was set to "); switch (mode) { case SPI_WRITE_PROTECTION_NONE: printk(BIOS_INFO, "NEVER\n"); break; case SPI_WRITE_PROTECTION_PIN: printk(BIOS_INFO, "WP\n"); break; case SPI_WRITE_PROTECTION_REBOOT: printk(BIOS_INFO, "REBOOT\n"); break; case SPI_WRITE_PROTECTION_PERMANENT: printk(BIOS_INFO, "PERMANENT\n"); break; default: printk(BIOS_INFO, "UNKNOWN\n"); break; } } return ret; } static uint32_t volatile_group_count; int spi_flash_volatile_group_begin(const struct spi_flash *flash) { uint32_t count; int ret = 0; if (!CONFIG(SPI_FLASH_HAS_VOLATILE_GROUP)) return ret; count = volatile_group_count; if (count == 0) ret = chipset_volatile_group_begin(flash); count++; volatile_group_count = count; return ret; } int spi_flash_volatile_group_end(const struct spi_flash *flash) { uint32_t count; int ret = 0; if (!CONFIG(SPI_FLASH_HAS_VOLATILE_GROUP)) return ret; count = volatile_group_count; assert(count == 0); count--; volatile_group_count = count; if (count == 0) ret = chipset_volatile_group_end(flash); return ret; } void lb_spi_flash(struct lb_header *header) { struct lb_spi_flash *flash; const struct spi_flash *spi_flash_dev; if (!CONFIG(BOOT_DEVICE_SPI_FLASH)) return; flash = (struct lb_spi_flash *)lb_new_record(header); flash->tag = LB_TAG_SPI_FLASH; flash->size = sizeof(*flash); spi_flash_dev = boot_device_spi_flash(); if (spi_flash_dev) { flash->flash_size = spi_flash_dev->size; flash->sector_size = spi_flash_dev->sector_size; flash->erase_cmd = spi_flash_dev->erase_cmd; } else { flash->flash_size = CONFIG_ROM_SIZE; /* Default 64k erase command should work on most flash. * Uniform 4k erase only works on certain devices. */ flash->sector_size = 64 * KiB; flash->erase_cmd = CMD_BLOCK_ERASE; } if (!CONFIG(BOOT_DEVICE_MEMORY_MAPPED)) { flash->mmap_count = 0; } else { struct flash_mmap_window *table = (struct flash_mmap_window *)(flash + 1); flash->mmap_count = spi_flash_get_mmap_windows(table); flash->size += flash->mmap_count * sizeof(*table); } } int spi_flash_ctrlr_protect_region(const struct spi_flash *flash, const struct region *region, const enum ctrlr_prot_type type) { const struct spi_ctrlr *ctrlr; struct region flash_region = { 0 }; if (!flash) return -1; flash_region.size = flash->size; if (!region_is_subregion(&flash_region, region)) return -1; ctrlr = flash->spi.ctrlr; if (!ctrlr) return -1; if (ctrlr->flash_protect) return ctrlr->flash_protect(flash, region, type); return -1; } int spi_flash_vector_helper(const struct spi_slave *slave, struct spi_op vectors[], size_t count, int (*func)(const struct spi_slave *slave, const void *dout, size_t bytesout, void *din, size_t bytesin)) { int ret; void *din; size_t bytes_in; if (count < 1 || count > 2) return -1; /* SPI flash commands always have a command first... */ if (!vectors[0].dout || !vectors[0].bytesout) return -1; /* And not read any data during the command. */ if (vectors[0].din || vectors[0].bytesin) return -1; if (count == 2) { /* If response bytes requested ensure the buffer is valid. */ if (vectors[1].bytesin && !vectors[1].din) return -1; /* No sends can accompany a receive. */ if (vectors[1].dout || vectors[1].bytesout) return -1; din = vectors[1].din; bytes_in = vectors[1].bytesin; } else { din = NULL; bytes_in = 0; } ret = func(slave, vectors[0].dout, vectors[0].bytesout, din, bytes_in); if (ret) { vectors[0].status = SPI_OP_FAILURE; if (count == 2) vectors[1].status = SPI_OP_FAILURE; } else { vectors[0].status = SPI_OP_SUCCESS; if (count == 2) vectors[1].status = SPI_OP_SUCCESS; } return ret; } const struct spi_flash_ops_descriptor spi_flash_pp_0x20_sector_desc = { .erase_cmd = 0x20, /* Sector Erase */ .status_cmd = 0x05, /* Read Status */ .pp_cmd = 0x02, /* Page Program */ .wren_cmd = 0x06, /* Write Enable */ .ops = { .read = spi_flash_cmd_read, .write = spi_flash_cmd_write_page_program, .erase = spi_flash_cmd_erase, .status = spi_flash_cmd_status, }, }; const struct spi_flash_ops_descriptor spi_flash_pp_0xd8_sector_desc = { .erase_cmd = 0xd8, /* Sector Erase */ .status_cmd = 0x05, /* Read Status */ .pp_cmd = 0x02, /* Page Program */ .wren_cmd = 0x06, /* Write Enable */ .ops = { .read = spi_flash_cmd_read, .write = spi_flash_cmd_write_page_program, .erase = spi_flash_cmd_erase, .status = spi_flash_cmd_status, }, };