arch/arm/lib/semihosting.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2014 Broadcom Corporation
   4  */
   5
   6 /*
   7  * Minimal semihosting implementation for reading files into memory. If more
   8  * features like writing files or console output are required they can be
   9  * added later. This code has been tested on arm64/aarch64 fastmodel only.
  10  * An untested placeholder exists for armv7 architectures, but since they
  11  * are commonly available in silicon now, fastmodel usage makes less sense
  12  * for them.
  13  */
  14 #include <common.h>
  15 #include <command.h>
  16 #include <env.h>
  17 #include <log.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 #elif defined(CONFIG_CPU_V7M)
  36         asm volatile ("bkpt #0xAB" : "=r" (result) : "0"(sysnum), "r"(addr));
  37 #else
  38         /* Note - untested placeholder */
  39         asm volatile ("svc #0x123456" : "=r" (result) : "0"(sysnum), "r"(addr));
  40 #endif
  41         return result;
  42 }
  43
  44 /*
  45  * Open a file on the host. Mode is "r" or "rb" currently. Returns a file
  46  * descriptor or -1 on error.
  47  */
  48 static long smh_open(const char *fname, char *modestr)
  49 {
  50         long fd;
  51         unsigned long mode;
  52         struct smh_open_s {
  53                 const char *fname;
  54                 unsigned long mode;
  55                 size_t len;
  56         } open;
  57
  58         debug("%s: file \'%s\', mode \'%s\'\n", __func__, fname, modestr);
  59
  60         /* Check the file mode */
  61         if (!(strcmp(modestr, "r"))) {
  62                 mode = MODE_READ;
  63         } else if (!(strcmp(modestr, "rb"))) {
  64                 mode = MODE_READBIN;
  65         } else {
  66                 printf("%s: ERROR mode \'%s\' not supported\n", __func__,
  67                        modestr);
  68                 return -1;
  69         }
  70
  71         open.fname = fname;
  72         open.len = strlen(fname);
  73         open.mode = mode;
  74
  75         /* Open the file on the host */
  76         fd = smh_trap(SYSOPEN, &open);
  77         if (fd == -1)
  78                 printf("%s: ERROR fd %ld for file \'%s\'\n", __func__, fd,
  79                        fname);
  80
  81         return fd;
  82 }
  83
  84 /*
  85  * Read 'len' bytes of file into 'memp'. Returns 0 on success, else failure
  86  */
  87 static long smh_read(long fd, void *memp, size_t len)
  88 {
  89         long ret;
  90         struct smh_read_s {
  91                 long fd;
  92                 void *memp;
  93                 size_t len;
  94         } read;
  95
  96         debug("%s: fd %ld, memp %p, len %zu\n", __func__, fd, memp, len);
  97
  98         read.fd = fd;
  99         read.memp = memp;
 100         read.len = len;
 101
 102         ret = smh_trap(SYSREAD, &read);
 103         if (ret < 0) {
 104                 /*
 105                  * The ARM handler allows for returning partial lengths,
 106                  * but in practice this never happens so rather than create
 107                  * hard to maintain partial read loops and such, just fail
 108                  * with an error message.
 109                  */
 110                 printf("%s: ERROR ret %ld, fd %ld, len %zu memp %p\n",
 111                        __func__, ret, fd, len, memp);
 112                 return -1;
 113         }
 114
 115         return 0;
 116 }
 117
 118 /*
 119  * Close the file using the file descriptor
 120  */
 121 static long smh_close(long fd)
 122 {
 123         long ret;
 124
 125         debug("%s: fd %ld\n", __func__, fd);
 126
 127         ret = smh_trap(SYSCLOSE, &fd);
 128         if (ret == -1)
 129                 printf("%s: ERROR fd %ld\n", __func__, fd);
 130
 131         return ret;
 132 }
 133
 134 /*
 135  * Get the file length from the file descriptor
 136  */
 137 static long smh_len_fd(long fd)
 138 {
 139         long ret;
 140
 141         debug("%s: fd %ld\n", __func__, fd);
 142
 143         ret = smh_trap(SYSFLEN, &fd);
 144         if (ret == -1)
 145                 printf("%s: ERROR ret %ld, fd %ld\n", __func__, ret, fd);
 146
 147         return ret;
 148 }
 149
 150 static int smh_load_file(const char * const name, ulong load_addr,
 151                          ulong *end_addr)
 152 {
 153         long fd;
 154         long len;
 155         long ret;
 156
 157         fd = smh_open(name, "rb");
 158         if (fd == -1)
 159                 return -1;
 160
 161         len = smh_len_fd(fd);
 162         if (len < 0) {
 163                 smh_close(fd);
 164                 return -1;
 165         }
 166
 167         ret = smh_read(fd, (void *)load_addr, len);
 168         smh_close(fd);
 169
 170         if (ret == 0) {
 171                 *end_addr = load_addr + len - 1;
 172                 printf("loaded file %s from %08lX to %08lX, %08lX bytes\n",
 173                        name,
 174                        load_addr,
 175                        *end_addr,
 176                        len);
 177         } else {
 178                 printf("read failed\n");
 179                 return 0;
 180         }
 181
 182         return 0;
 183 }
 184
 185 static int do_smhload(struct cmd_tbl *cmdtp, int flag, int argc,
 186                       char *const argv[])
 187 {
 188         if (argc == 3 || argc == 4) {
 189                 ulong load_addr;
 190                 ulong end_addr = 0;
 191                 int ret;
 192                 char end_str[64];
 193
 194                 load_addr = simple_strtoul(argv[2], NULL, 16);
 195                 if (!load_addr)
 196                         return -1;
 197
 198                 ret = smh_load_file(argv[1], load_addr, &end_addr);
 199                 if (ret < 0)
 200                         return CMD_RET_FAILURE;
 201
 202                 /* Optionally save returned end to the environment */
 203                 if (argc == 4) {
 204                         sprintf(end_str, "0x%08lx", end_addr);
 205                         env_set(argv[3], end_str);
 206                 }
 207         } else {
 208                 return CMD_RET_USAGE;
 209         }
 210         return 0;
 211 }
 212
 213 U_BOOT_CMD(smhload, 4, 0, do_smhload, "load a file using semihosting",
 214            "<file> 0x<address> [end var]\n"
 215            "    - load a semihosted file to the address specified\n"
 216            "      if the optional [end var] is specified, the end\n"
 217            "      address of the file will be stored in this environment\n"
 218            "      variable.\n");