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");