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