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