| /* |
| * Command for accessing SPI flash. |
| * |
| * Copyright (C) 2008 Atmel Corporation |
| * Licensed under the GPL-2 or later. |
| */ |
| |
| #include <common.h> |
| #include <malloc.h> |
| #include <spi_flash.h> |
| |
| #include <asm/io.h> |
| |
| #ifndef CONFIG_SF_DEFAULT_SPEED |
| # define CONFIG_SF_DEFAULT_SPEED 1000000 |
| #endif |
| #ifndef CONFIG_SF_DEFAULT_MODE |
| # define CONFIG_SF_DEFAULT_MODE SPI_MODE_3 |
| #endif |
| |
| static struct spi_flash *flash; |
| |
| static int do_spi_flash_probe(int argc, char * const argv[]) |
| { |
| unsigned int bus = 0; |
| unsigned int cs; |
| unsigned int speed = CONFIG_SF_DEFAULT_SPEED; |
| unsigned int mode = CONFIG_SF_DEFAULT_MODE; |
| char *endp; |
| struct spi_flash *new; |
| |
| if (argc < 2) |
| goto usage; |
| |
| cs = simple_strtoul(argv[1], &endp, 0); |
| if (*argv[1] == 0 || (*endp != 0 && *endp != ':')) |
| goto usage; |
| if (*endp == ':') { |
| if (endp[1] == 0) |
| goto usage; |
| |
| bus = cs; |
| cs = simple_strtoul(endp + 1, &endp, 0); |
| if (*endp != 0) |
| goto usage; |
| } |
| |
| if (argc >= 3) { |
| speed = simple_strtoul(argv[2], &endp, 0); |
| if (*argv[2] == 0 || *endp != 0) |
| goto usage; |
| } |
| if (argc >= 4) { |
| mode = simple_strtoul(argv[3], &endp, 16); |
| if (*argv[3] == 0 || *endp != 0) |
| goto usage; |
| } |
| |
| new = spi_flash_probe(bus, cs, speed, mode); |
| if (!new) { |
| printf("Failed to initialize SPI flash at %u:%u\n", bus, cs); |
| return 1; |
| } |
| |
| if (flash) |
| spi_flash_free(flash); |
| flash = new; |
| |
| printf("%u KiB %s at %u:%u is now current device\n", |
| flash->size >> 10, flash->name, bus, cs); |
| |
| return 0; |
| |
| usage: |
| puts("Usage: sf probe [bus:]cs [hz] [mode]\n"); |
| return 1; |
| } |
| |
| /** |
| * Update an area of SPI flash by erasing and writing any blocks which need |
| * to change. Existing blocks with the correct data are left unchanged. |
| * |
| * @param flash flash context pointer |
| * @param offset flash offset to write |
| * @param len number of bytes to write |
| * @param buf buffer to write from |
| */ |
| static int spi_flash_update(struct spi_flash *flash, u32 offset, |
| size_t len, const char *buf) |
| { |
| const char *oper; |
| int err = 0; |
| char *cmp_buf = NULL; |
| size_t cmp_size = 0; |
| size_t todo; /* number of bytes to do in this pass */ |
| size_t skipped, written; /* statistics */ |
| |
| for (skipped = written = 0; !err && len > 0; |
| buf += todo, offset += todo, len -= todo) { |
| size_t program_len; |
| size_t erase_len; |
| |
| oper = "probe"; |
| err = flash->probe_block(flash, offset, &program_len, |
| &erase_len); |
| todo = min(len, erase_len); |
| debug("offset=%#x, program_len=%#x, erase_len=%#x, todo=%#x\n", |
| offset, program_len, erase_len, todo); |
| if (!err) { |
| oper = "malloc"; |
| if (erase_len > cmp_size) { |
| if (cmp_buf) |
| free(cmp_buf); |
| cmp_buf = malloc(erase_len); |
| cmp_size = erase_len; |
| } |
| err = cmp_buf == NULL; |
| } |
| if (!err) { |
| oper = "read"; |
| err = spi_flash_read(flash, offset, todo, cmp_buf); |
| } |
| if (!err) { |
| if (0 == memcmp(cmp_buf, buf, todo)) { |
| debug("Skip region %x size %x: no change\n", |
| offset, todo); |
| skipped += todo; |
| continue; |
| } |
| } |
| if (!err) { |
| oper = "erase"; |
| err = spi_flash_erase(flash, offset, todo); |
| } |
| if (!err) { |
| oper = "write"; |
| err = spi_flash_write(flash, offset, todo, buf); |
| written += todo; |
| } |
| } |
| printf("%d bytes written, %d bytes skipped\n", written, skipped); |
| if (err) |
| printf("SPI flash %s failed\n", oper); |
| if (cmp_buf) |
| free(cmp_buf); |
| return err; |
| } |
| |
| static int do_spi_flash_read_write(int argc, char * const argv[]) |
| { |
| unsigned long addr; |
| unsigned long offset; |
| unsigned long len; |
| void *buf; |
| char *endp; |
| int ret; |
| |
| if (argc < 4) |
| goto usage; |
| |
| addr = simple_strtoul(argv[1], &endp, 16); |
| if (*argv[1] == 0 || *endp != 0) |
| goto usage; |
| offset = simple_strtoul(argv[2], &endp, 16); |
| if (*argv[2] == 0 || *endp != 0) |
| goto usage; |
| len = simple_strtoul(argv[3], &endp, 16); |
| if (*argv[3] == 0 || *endp != 0) |
| goto usage; |
| |
| buf = map_physmem(addr, len, MAP_WRBACK); |
| if (!buf) { |
| puts("Failed to map physical memory\n"); |
| return 1; |
| } |
| |
| if (strcmp(argv[0], "update") == 0 && flash->probe_block) |
| ret = spi_flash_update(flash, offset, len, buf); |
| else if (strcmp(argv[0], "read") == 0) |
| ret = spi_flash_read(flash, offset, len, buf); |
| else |
| ret = spi_flash_write(flash, offset, len, buf); |
| |
| unmap_physmem(buf, len); |
| |
| if (ret) { |
| printf("SPI flash %s failed\n", argv[0]); |
| return 1; |
| } |
| |
| return 0; |
| |
| usage: |
| printf("Usage: sf %s addr offset len\n", argv[0]); |
| return 1; |
| } |
| |
| static int do_spi_flash_erase(int argc, char * const argv[]) |
| { |
| unsigned long offset; |
| unsigned long len; |
| char *endp; |
| int ret; |
| |
| if (argc < 3) |
| goto usage; |
| |
| offset = simple_strtoul(argv[1], &endp, 16); |
| if (*argv[1] == 0 || *endp != 0) |
| goto usage; |
| len = simple_strtoul(argv[2], &endp, 16); |
| if (*argv[2] == 0 || *endp != 0) |
| goto usage; |
| |
| ret = spi_flash_erase(flash, offset, len); |
| if (ret) { |
| printf("SPI flash %s failed\n", argv[0]); |
| return 1; |
| } |
| |
| return 0; |
| |
| usage: |
| puts("Usage: sf erase offset len\n"); |
| return 1; |
| } |
| |
| static int do_spi_flash(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
| { |
| const char *cmd; |
| |
| /* need at least two arguments */ |
| if (argc < 2) |
| goto usage; |
| |
| cmd = argv[1]; |
| |
| if (strcmp(cmd, "probe") == 0) |
| return do_spi_flash_probe(argc - 1, argv + 1); |
| |
| /* The remaining commands require a selected device */ |
| if (!flash) { |
| puts("No SPI flash selected. Please run `sf probe'\n"); |
| return 1; |
| } |
| |
| if (strcmp(cmd, "read") == 0 || strcmp(cmd, "write") == 0 || |
| strcmp(cmd, "update") == 0) |
| return do_spi_flash_read_write(argc - 1, argv + 1); |
| if (strcmp(cmd, "erase") == 0) |
| return do_spi_flash_erase(argc - 1, argv + 1); |
| |
| usage: |
| return cmd_usage(cmdtp); |
| } |
| |
| U_BOOT_CMD( |
| sf, 5, 1, do_spi_flash, |
| "SPI flash sub-system", |
| "probe [bus:]cs [hz] [mode] - init flash device on given SPI bus\n" |
| " and chip select\n" |
| "sf read addr offset len - read `len' bytes starting at\n" |
| " `offset' to memory at `addr'\n" |
| "sf write addr offset len - write `len' bytes from memory\n" |
| " at `addr' to flash at `offset'\n" |
| "sf erase offset len - erase `len' bytes from `offset'" |
| "sf update addr offset len - erase and write `len' bytes from " |
| "memory\n" |
| " at `addr' to flash at `offset'\n" |
| ); |