common/cmd_sf.c

   1 /*
   2  * Command for accessing SPI flash.
   3  *
   4  * Copyright (C) 2008 Atmel Corporation
   5  * Licensed under the GPL-2 or later.
   6  */
   7
   8 #include <common.h>
   9 #include <malloc.h>
  10 #include <spi_flash.h>
  11
  12 #include <asm/io.h>
  13
  14 #ifndef CONFIG_SF_DEFAULT_SPEED
  15 # define CONFIG_SF_DEFAULT_SPEED        1000000
  16 #endif
  17 #ifndef CONFIG_SF_DEFAULT_MODE
  18 # define CONFIG_SF_DEFAULT_MODE         SPI_MODE_3
  19 #endif
  20
  21 static struct spi_flash *flash;
  22
  23
  24 /*
  25  * This function computes the length argument for the erase command.
  26  * The length on which the command is to operate can be given in two forms:
  27  * 1. <cmd> offset len  - operate on <'offset',  'len')
  28  * 2. <cmd> offset +len - operate on <'offset',  'round_up(len)')
  29  * If the second form is used and the length doesn't fall on the
  30  * sector boundary, than it will be adjusted to the next sector boundary.
  31  * If it isn't in the flash, the function will fail (return -1).
  32  * Input:
  33  *    arg: length specification (i.e. both command arguments)
  34  * Output:
  35  *    len: computed length for operation
  36  * Return:
  37  *    1: success
  38  *   -1: failure (bad format, bad address).
  39  */
  40 static int sf_parse_len_arg(char *arg, ulong *len)
  41 {
  42         char *ep;
  43         char round_up_len; /* indicates if the "+length" form used */
  44         ulong len_arg;
  45
  46         round_up_len = 0;
  47         if (*arg == '+') {
  48                 round_up_len = 1;
  49                 ++arg;
  50         }
  51
  52         len_arg = simple_strtoul(arg, &ep, 16);
  53         if (ep == arg || *ep != '\0')
  54                 return -1;
  55
  56         if (round_up_len && flash->sector_size > 0)
  57                 *len = ROUND(len_arg, flash->sector_size);
  58         else
  59                 *len = len_arg;
  60
  61         return 1;
  62 }
  63
  64 static int do_spi_flash_probe(int argc, char * const argv[])
  65 {
  66         unsigned int bus = 0;
  67         unsigned int cs;
  68         unsigned int speed = CONFIG_SF_DEFAULT_SPEED;
  69         unsigned int mode = CONFIG_SF_DEFAULT_MODE;
  70         char *endp;
  71         struct spi_flash *new;
  72
  73         if (argc < 2)
  74                 return -1;
  75
  76         cs = simple_strtoul(argv[1], &endp, 0);
  77         if (*argv[1] == 0 || (*endp != 0 && *endp != ':'))
  78                 return -1;
  79         if (*endp == ':') {
  80                 if (endp[1] == 0)
  81                         return -1;
  82
  83                 bus = cs;
  84                 cs = simple_strtoul(endp + 1, &endp, 0);
  85                 if (*endp != 0)
  86                         return -1;
  87         }
  88
  89         if (argc >= 3) {
  90                 speed = simple_strtoul(argv[2], &endp, 0);
  91                 if (*argv[2] == 0 || *endp != 0)
  92                         return -1;
  93         }
  94         if (argc >= 4) {
  95                 mode = simple_strtoul(argv[3], &endp, 16);
  96                 if (*argv[3] == 0 || *endp != 0)
  97                         return -1;
  98         }
  99
 100         new = spi_flash_probe(bus, cs, speed, mode);
 101         if (!new) {
 102                 printf("Failed to initialize SPI flash at %u:%u\n", bus, cs);
 103                 return 1;
 104         }
 105
 106         if (flash)
 107                 spi_flash_free(flash);
 108         flash = new;
 109
 110         return 0;
 111 }
 112
 113 /**
 114  * Write a block of data to SPI flash, first checking if it is different from
 115  * what is already there.
 116  *
 117  * If the data being written is the same, then *skipped is incremented by len.
 118  *
 119  * @param flash         flash context pointer
 120  * @param offset        flash offset to write
 121  * @param len           number of bytes to write
 122  * @param buf           buffer to write from
 123  * @param cmp_buf       read buffer to use to compare data
 124  * @param skipped       Count of skipped data (incremented by this function)
 125  * @return NULL if OK, else a string containing the stage which failed
 126  */
 127 static const char *spi_flash_update_block(struct spi_flash *flash, u32 offset,
 128                 size_t len, const char *buf, char *cmp_buf, size_t *skipped)
 129 {
 130         debug("offset=%#x, sector_size=%#x, len=%#x\n",
 131                 offset, flash->sector_size, len);
 132         if (spi_flash_read(flash, offset, len, cmp_buf))
 133                 return "read";
 134         if (memcmp(cmp_buf, buf, len) == 0) {
 135                 debug("Skip region %x size %x: no change\n",
 136                         offset, len);
 137                 *skipped += len;
 138                 return NULL;
 139         }
 140         if (spi_flash_erase(flash, offset, len))
 141                 return "erase";
 142         if (spi_flash_write(flash, offset, len, buf))
 143                 return "write";
 144         return NULL;
 145 }
 146
 147 /**
 148  * Update an area of SPI flash by erasing and writing any blocks which need
 149  * to change. Existing blocks with the correct data are left unchanged.
 150  *
 151  * @param flash         flash context pointer
 152  * @param offset        flash offset to write
 153  * @param len           number of bytes to write
 154  * @param buf           buffer to write from
 155  * @return 0 if ok, 1 on error
 156  */
 157 static int spi_flash_update(struct spi_flash *flash, u32 offset,
 158                 size_t len, const char *buf)
 159 {
 160         const char *err_oper = NULL;
 161         char *cmp_buf;
 162         const char *end = buf + len;
 163         size_t todo;            /* number of bytes to do in this pass */
 164         size_t skipped;         /* statistics */
 165
 166         cmp_buf = malloc(flash->sector_size);
 167         if (cmp_buf) {
 168                 for (skipped = 0; buf < end && !err_oper;
 169                                 buf += todo, offset += todo) {
 170                         todo = min(end - buf, flash->sector_size);
 171                         err_oper = spi_flash_update_block(flash, offset, todo,
 172                                         buf, cmp_buf, &skipped);
 173                 }
 174         } else {
 175                 err_oper = "malloc";
 176         }
 177         free(cmp_buf);
 178         if (err_oper) {
 179                 printf("SPI flash failed in %s step\n", err_oper);
 180                 return 1;
 181         }
 182         printf("%zu bytes written, %zu bytes skipped\n", len - skipped,
 183                skipped);
 184         return 0;
 185 }
 186
 187 static int do_spi_flash_read_write(int argc, char * const argv[])
 188 {
 189         unsigned long addr;
 190         unsigned long offset;
 191         unsigned long len;
 192         void *buf;
 193         char *endp;
 194         int ret;
 195
 196         if (argc < 4)
 197                 return -1;
 198
 199         addr = simple_strtoul(argv[1], &endp, 16);
 200         if (*argv[1] == 0 || *endp != 0)
 201                 return -1;
 202         offset = simple_strtoul(argv[2], &endp, 16);
 203         if (*argv[2] == 0 || *endp != 0)
 204                 return -1;
 205         len = simple_strtoul(argv[3], &endp, 16);
 206         if (*argv[3] == 0 || *endp != 0)
 207                 return -1;
 208
 209         buf = map_physmem(addr, len, MAP_WRBACK);
 210         if (!buf) {
 211                 puts("Failed to map physical memory\n");
 212                 return 1;
 213         }
 214
 215         if (strcmp(argv[0], "update") == 0)
 216                 ret = spi_flash_update(flash, offset, len, buf);
 217         else if (strcmp(argv[0], "read") == 0)
 218                 ret = spi_flash_read(flash, offset, len, buf);
 219         else
 220                 ret = spi_flash_write(flash, offset, len, buf);
 221
 222         unmap_physmem(buf, len);
 223
 224         if (ret) {
 225                 printf("SPI flash %s failed\n", argv[0]);
 226                 return 1;
 227         }
 228
 229         return 0;
 230 }
 231
 232 static int do_spi_flash_erase(int argc, char * const argv[])
 233 {
 234         unsigned long offset;
 235         unsigned long len;
 236         char *endp;
 237         int ret;
 238
 239         if (argc < 3)
 240                 return -1;
 241
 242         offset = simple_strtoul(argv[1], &endp, 16);
 243         if (*argv[1] == 0 || *endp != 0)
 244                 return -1;
 245
 246         ret = sf_parse_len_arg(argv[2], &len);
 247         if (ret != 1)
 248                 return -1;
 249
 250         ret = spi_flash_erase(flash, offset, len);
 251         if (ret) {
 252                 printf("SPI flash %s failed\n", argv[0]);
 253                 return 1;
 254         }
 255
 256         return 0;
 257 }
 258
 259 static int do_spi_flash(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 260 {
 261         const char *cmd;
 262         int ret;
 263
 264         /* need at least two arguments */
 265         if (argc < 2)
 266                 goto usage;
 267
 268         cmd = argv[1];
 269         --argc;
 270         ++argv;
 271
 272         if (strcmp(cmd, "probe") == 0) {
 273                 ret = do_spi_flash_probe(argc, argv);
 274                 goto done;
 275         }
 276
 277         /* The remaining commands require a selected device */
 278         if (!flash) {
 279                 puts("No SPI flash selected. Please run `sf probe'\n");
 280                 return 1;
 281         }
 282
 283         if (strcmp(cmd, "read") == 0 || strcmp(cmd, "write") == 0 ||
 284             strcmp(cmd, "update") == 0)
 285                 ret = do_spi_flash_read_write(argc, argv);
 286         else if (strcmp(cmd, "erase") == 0)
 287                 ret = do_spi_flash_erase(argc, argv);
 288         else
 289                 ret = -1;
 290
 291 done:
 292         if (ret != -1)
 293                 return ret;
 294
 295 usage:
 296         return cmd_usage(cmdtp);
 297 }
 298
 299 U_BOOT_CMD(
 300         sf,     5,      1,      do_spi_flash,
 301         "SPI flash sub-system",
 302         "probe [bus:]cs [hz] [mode]     - init flash device on given SPI bus\n"
 303         "                                 and chip select\n"
 304         "sf read addr offset len        - read `len' bytes starting at\n"
 305         "                                 `offset' to memory at `addr'\n"
 306         "sf write addr offset len       - write `len' bytes from memory\n"
 307         "                                 at `addr' to flash at `offset'\n"
 308         "sf erase offset [+]len         - erase `len' bytes from `offset'\n"
 309         "                                 `+len' round up `len' to block size\n"
 310         "sf update addr offset len      - erase and write `len' bytes from memory\n"
 311         "                                 at `addr' to flash at `offset'"
 312 );