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 noinline 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 }