]> git.sur5r.net Git - u-boot/blob - arch/arm/lib/semihosting.c
armv8: semihosting: add a command to load semihosted images
[u-boot] / arch / arm / lib / semihosting.c
1 /*
2  * Copyright 2014 Broadcom Corporation
3  *
4  * SPDX-License-Identifier:     GPL-2.0+
5  */
6
7 /*
8  * Minimal semihosting implementation for reading files into memory. If more
9  * features like writing files or console output are required they can be
10  * added later. This code has been tested on arm64/aarch64 fastmodel only.
11  * An untested placeholder exists for armv7 architectures, but since they
12  * are commonly available in silicon now, fastmodel usage makes less sense
13  * for them.
14  */
15 #include <common.h>
16 #include <command.h>
17 #include <asm/semihosting.h>
18
19 #define SYSOPEN         0x01
20 #define SYSCLOSE        0x02
21 #define SYSREAD         0x06
22 #define SYSFLEN         0x0C
23
24 #define MODE_READ       0x0
25 #define MODE_READBIN    0x1
26
27 /*
28  * Call the handler
29  */
30 static noinline long smh_trap(unsigned int sysnum, void *addr)
31 {
32         register long result asm("r0");
33 #if defined(CONFIG_ARM64)
34         asm volatile ("hlt #0xf000" : "=r" (result) : "0"(sysnum), "r"(addr));
35 #else
36         /* Note - untested placeholder */
37         asm volatile ("svc #0x123456" : "=r" (result) : "0"(sysnum), "r"(addr));
38 #endif
39         return result;
40 }
41
42 /*
43  * Open a file on the host. Mode is "r" or "rb" currently. Returns a file
44  * descriptor or -1 on error.
45  */
46 static long smh_open(const char *fname, char *modestr)
47 {
48         long fd;
49         unsigned long mode;
50         struct smh_open_s {
51                 const char *fname;
52                 unsigned long mode;
53                 size_t len;
54         } open;
55
56         debug("%s: file \'%s\', mode \'%s\'\n", __func__, fname, modestr);
57
58         /* Check the file mode */
59         if (!(strcmp(modestr, "r"))) {
60                 mode = MODE_READ;
61         } else if (!(strcmp(modestr, "rb"))) {
62                 mode = MODE_READBIN;
63         } else {
64                 printf("%s: ERROR mode \'%s\' not supported\n", __func__,
65                        modestr);
66                 return -1;
67         }
68
69         open.fname = fname;
70         open.len = strlen(fname);
71         open.mode = mode;
72
73         /* Open the file on the host */
74         fd = smh_trap(SYSOPEN, &open);
75         if (fd == -1)
76                 printf("%s: ERROR fd %ld for file \'%s\'\n", __func__, fd,
77                        fname);
78
79         return fd;
80 }
81
82 /*
83  * Read 'len' bytes of file into 'memp'. Returns 0 on success, else failure
84  */
85 static long smh_read(long fd, void *memp, size_t len)
86 {
87         long ret;
88         struct smh_read_s {
89                 long fd;
90                 void *memp;
91                 size_t len;
92         } read;
93
94         debug("%s: fd %ld, memp %p, len %lu\n", __func__, fd, memp, len);
95
96         read.fd = fd;
97         read.memp = memp;
98         read.len = len;
99
100         ret = smh_trap(SYSREAD, &read);
101         if (ret < 0) {
102                 /*
103                  * The ARM handler allows for returning partial lengths,
104                  * but in practice this never happens so rather than create
105                  * hard to maintain partial read loops and such, just fail
106                  * with an error message.
107                  */
108                 printf("%s: ERROR ret %ld, fd %ld, len %lu memp %p\n",
109                        __func__, ret, fd, len, memp);
110                 return -1;
111         }
112
113         return 0;
114 }
115
116 /*
117  * Close the file using the file descriptor
118  */
119 static long smh_close(long fd)
120 {
121         long ret;
122
123         debug("%s: fd %ld\n", __func__, fd);
124
125         ret = smh_trap(SYSCLOSE, &fd);
126         if (ret == -1)
127                 printf("%s: ERROR fd %ld\n", __func__, fd);
128
129         return ret;
130 }
131
132 /*
133  * Get the file length from the file descriptor
134  */
135 static long smh_len_fd(long fd)
136 {
137         long ret;
138
139         debug("%s: fd %ld\n", __func__, fd);
140
141         ret = smh_trap(SYSFLEN, &fd);
142         if (ret == -1)
143                 printf("%s: ERROR ret %ld, fd %ld\n", __func__, ret, fd);
144
145         return ret;
146 }
147
148 /*
149  * Open, load a file into memory, and close it. Check that the available space
150  * is sufficient to store the entire file. Return the bytes actually read from
151  * the file as seen by the read function. The verbose flag enables some extra
152  * printing of successful read status.
153  */
154 int smh_load(const char *fname, void *memp, int avail, int verbose)
155 {
156         long ret;
157         long fd;
158         size_t len;
159
160         ret = -1;
161
162         debug("%s: fname \'%s\', avail %u, memp %p\n", __func__, fname,
163               avail, memp);
164
165         /* Open the file */
166         fd = smh_open(fname, "rb");
167         if (fd == -1)
168                 return -1;
169
170         /* Get the file length */
171         ret = smh_len_fd(fd);
172         if (ret == -1) {
173                 smh_close(fd);
174                 return -1;
175         }
176
177         /* Check that the file will fit in the supplied buffer */
178         if (ret > avail) {
179                 printf("%s: ERROR ret %ld, avail %u\n", __func__, ret,
180                        avail);
181                 smh_close(fd);
182                 return -1;
183         }
184
185         len = ret;
186
187         /* Read the file into the buffer */
188         ret = smh_read(fd, memp, len);
189         if (ret == 0) {
190                 /* Print successful load information if requested */
191                 if (verbose) {
192                         printf("\n%s\n", fname);
193                         printf("    0x%8p dest\n", memp);
194                         printf("    0x%08lx size\n", len);
195                         printf("    0x%08x avail\n", avail);
196                 }
197         }
198
199         /* Close the file */
200         smh_close(fd);
201
202         return ret;
203 }
204
205 /*
206  * Get the file length from the filename
207  */
208 long smh_len(const char *fname)
209 {
210         long ret;
211         long fd;
212         long len;
213
214         debug("%s: file \'%s\'\n", __func__, fname);
215
216         /* Open the file */
217         fd = smh_open(fname, "rb");
218         if (fd < 0)
219                 return fd;
220
221         /* Get the file length */
222         len = smh_len_fd(fd);
223         if (len < 0) {
224                 smh_close(fd);
225                 return len;
226         }
227
228         /* Close the file */
229         ret = smh_close(fd);
230         if (ret < 0)
231                 return ret;
232
233         debug("%s: returning len %ld\n", __func__, len);
234
235         /* Return the file length (or -1 error indication) */
236         return len;
237 }
238
239 static int smh_load_file(const char * const name, ulong load_addr,
240                          ulong *end_addr)
241 {
242         long fd;
243         long len;
244         long ret;
245
246         fd = smh_open(name, "rb");
247         if (fd == -1)
248                 return -1;
249
250         len = smh_len_fd(fd);
251         if (len < 0) {
252                 smh_close(fd);
253                 return -1;
254         }
255
256         ret = smh_read(fd, (void *)load_addr, len);
257         smh_close(fd);
258
259         if (ret == 0) {
260                 *end_addr = load_addr + len - 1;
261                 printf("loaded file %s from %08lX to %08lX, %08lX bytes\n",
262                        name,
263                        load_addr,
264                        *end_addr,
265                        len);
266         } else {
267                 printf("read failed\n");
268                 return 0;
269         }
270
271         return 0;
272 }
273
274 static int do_smhload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
275 {
276         if (argc == 3 || argc == 4) {
277                 ulong load_addr;
278                 ulong end_addr = 0;
279                 ulong ret;
280                 char end_str[64];
281
282                 load_addr = simple_strtoul(argv[2], NULL, 16);
283                 if (!load_addr)
284                         return -1;
285
286                 ret = smh_load_file(argv[1], load_addr, &end_addr);
287                 if (ret < 0)
288                         return 1;
289
290                 /* Optionally save returned end to the environment */
291                 if (argc == 4) {
292                         sprintf(end_str, "0x%08lx", end_addr);
293                         setenv(argv[3], end_str);
294                 }
295         } else {
296                 return CMD_RET_USAGE;
297         }
298         return 0;
299 }
300
301 U_BOOT_CMD(smhload, 4, 0, do_smhload, "load a file using semihosting",
302            "<file> 0x<address> [end var]\n"
303            "    - load a semihosted file to the address specified\n"
304            "      if the optional [end var] is specified, the end\n"
305            "      address of the file will be stored in this environment\n"
306            "      variable.\n");