]> git.sur5r.net Git - u-boot/blob - arch/arm/lib/semihosting.c
Merge branch 'master' of git://git.denx.de/u-boot-socfpga
[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 <asm/semihosting.h>
17
18 #define SYSOPEN         0x01
19 #define SYSCLOSE        0x02
20 #define SYSREAD         0x06
21 #define SYSFLEN         0x0C
22
23 #define MODE_READ       0x0
24 #define MODE_READBIN    0x1
25
26 /*
27  * Call the handler
28  */
29 static long smh_trap(unsigned int sysnum, void *addr)
30 {
31         register long result asm("r0");
32 #if defined(CONFIG_ARM64)
33         asm volatile ("hlt #0xf000" : "=r" (result) : "0"(sysnum), "r"(addr));
34 #else
35         /* Note - untested placeholder */
36         asm volatile ("svc #0x123456" : "=r" (result) : "0"(sysnum), "r"(addr));
37 #endif
38         return result;
39 }
40
41 /*
42  * Open a file on the host. Mode is "r" or "rb" currently. Returns a file
43  * descriptor or -1 on error.
44  */
45 static long smh_open(const char *fname, char *modestr)
46 {
47         long fd;
48         unsigned long mode;
49         struct smh_open_s {
50                 const char *fname;
51                 unsigned long mode;
52                 size_t len;
53         } open;
54
55         debug("%s: file \'%s\', mode \'%s\'\n", __func__, fname, modestr);
56
57         /* Check the file mode */
58         if (!(strcmp(modestr, "r"))) {
59                 mode = MODE_READ;
60         } else if (!(strcmp(modestr, "rb"))) {
61                 mode = MODE_READBIN;
62         } else {
63                 printf("%s: ERROR mode \'%s\' not supported\n", __func__,
64                        modestr);
65                 return -1;
66         }
67
68         open.fname = fname;
69         open.len = strlen(fname);
70         open.mode = mode;
71
72         /* Open the file on the host */
73         fd = smh_trap(SYSOPEN, &open);
74         if (fd == -1)
75                 printf("%s: ERROR fd %ld for file \'%s\'\n", __func__, fd,
76                        fname);
77
78         return fd;
79 }
80
81 /*
82  * Read 'len' bytes of file into 'memp'. Returns 0 on success, else failure
83  */
84 static long smh_read(long fd, void *memp, size_t len)
85 {
86         long ret;
87         struct smh_read_s {
88                 long fd;
89                 void *memp;
90                 size_t len;
91         } read;
92
93         debug("%s: fd %ld, memp %p, len %lu\n", __func__, fd, memp, len);
94
95         read.fd = fd;
96         read.memp = memp;
97         read.len = len;
98
99         ret = smh_trap(SYSREAD, &read);
100         if (ret < 0) {
101                 /*
102                  * The ARM handler allows for returning partial lengths,
103                  * but in practice this never happens so rather than create
104                  * hard to maintain partial read loops and such, just fail
105                  * with an error message.
106                  */
107                 printf("%s: ERROR ret %ld, fd %ld, len %lu memp %p\n",
108                        __func__, ret, fd, len, memp);
109                 return -1;
110         }
111
112         return 0;
113 }
114
115 /*
116  * Close the file using the file descriptor
117  */
118 static long smh_close(long fd)
119 {
120         long ret;
121
122         debug("%s: fd %ld\n", __func__, fd);
123
124         ret = smh_trap(SYSCLOSE, &fd);
125         if (ret == -1)
126                 printf("%s: ERROR fd %ld\n", __func__, fd);
127
128         return ret;
129 }
130
131 /*
132  * Get the file length from the file descriptor
133  */
134 static long smh_len_fd(long fd)
135 {
136         long ret;
137
138         debug("%s: fd %ld\n", __func__, fd);
139
140         ret = smh_trap(SYSFLEN, &fd);
141         if (ret == -1)
142                 printf("%s: ERROR ret %ld, fd %ld\n", __func__, ret, fd);
143
144         return ret;
145 }
146
147 /*
148  * Open, load a file into memory, and close it. Check that the available space
149  * is sufficient to store the entire file. Return the bytes actually read from
150  * the file as seen by the read function. The verbose flag enables some extra
151  * printing of successful read status.
152  */
153 int smh_load(const char *fname, void *memp, int avail, int verbose)
154 {
155         long ret;
156         long fd;
157         size_t len;
158
159         ret = -1;
160
161         debug("%s: fname \'%s\', avail %u, memp %p\n", __func__, fname,
162               avail, memp);
163
164         /* Open the file */
165         fd = smh_open(fname, "rb");
166         if (fd == -1)
167                 return -1;
168
169         /* Get the file length */
170         ret = smh_len_fd(fd);
171         if (ret == -1) {
172                 smh_close(fd);
173                 return -1;
174         }
175
176         /* Check that the file will fit in the supplied buffer */
177         if (ret > avail) {
178                 printf("%s: ERROR ret %ld, avail %u\n", __func__, ret,
179                        avail);
180                 smh_close(fd);
181                 return -1;
182         }
183
184         len = ret;
185
186         /* Read the file into the buffer */
187         ret = smh_read(fd, memp, len);
188         if (ret == 0) {
189                 /* Print successful load information if requested */
190                 if (verbose) {
191                         printf("\n%s\n", fname);
192                         printf("    0x%8p dest\n", memp);
193                         printf("    0x%08lx size\n", len);
194                         printf("    0x%08x avail\n", avail);
195                 }
196         }
197
198         /* Close the file */
199         smh_close(fd);
200
201         return ret;
202 }
203
204 /*
205  * Get the file length from the filename
206  */
207 long smh_len(const char *fname)
208 {
209         long ret;
210         long fd;
211         long len;
212
213         debug("%s: file \'%s\'\n", __func__, fname);
214
215         /* Open the file */
216         fd = smh_open(fname, "rb");
217         if (fd < 0)
218                 return fd;
219
220         /* Get the file length */
221         len = smh_len_fd(fd);
222         if (len < 0) {
223                 smh_close(fd);
224                 return len;
225         }
226
227         /* Close the file */
228         ret = smh_close(fd);
229         if (ret < 0)
230                 return ret;
231
232         debug("%s: returning len %ld\n", __func__, len);
233
234         /* Return the file length (or -1 error indication) */
235         return len;
236 }