1 /*
2 * Copyright (c) 2013-2014, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <errno.h>
9 #include <semihosting.h>
10 #include <string.h>
11
12 #ifndef SEMIHOSTING_SUPPORTED
13 #define SEMIHOSTING_SUPPORTED 1
14 #endif
15
16 long semihosting_call(unsigned long operation,
17 void *system_block_address);
18
19 typedef struct {
20 const char *file_name;
21 unsigned long mode;
22 size_t name_length;
23 } smh_file_open_block_t;
24
25 typedef struct {
26 long handle;
27 uintptr_t buffer;
28 size_t length;
29 } smh_file_read_write_block_t;
30
31 typedef struct {
32 long handle;
33 ssize_t location;
34 } smh_file_seek_block_t;
35
36 typedef struct {
37 char *command_line;
38 size_t command_length;
39 } smh_system_block_t;
40
semihosting_connection_supported(void)41 long semihosting_connection_supported(void)
42 {
43 return SEMIHOSTING_SUPPORTED;
44 }
45
semihosting_file_open(const char * file_name,size_t mode)46 long semihosting_file_open(const char *file_name, size_t mode)
47 {
48 smh_file_open_block_t open_block;
49
50 open_block.file_name = file_name;
51 open_block.mode = mode;
52 open_block.name_length = strlen(file_name);
53
54 return semihosting_call(SEMIHOSTING_SYS_OPEN,
55 (void *) &open_block);
56 }
57
semihosting_file_seek(long file_handle,ssize_t offset)58 long semihosting_file_seek(long file_handle, ssize_t offset)
59 {
60 smh_file_seek_block_t seek_block;
61 long result;
62
63 seek_block.handle = file_handle;
64 seek_block.location = offset;
65
66 result = semihosting_call(SEMIHOSTING_SYS_SEEK,
67 (void *) &seek_block);
68
69 if (result)
70 result = semihosting_call(SEMIHOSTING_SYS_ERRNO, 0);
71
72 return result;
73 }
74
semihosting_file_read(long file_handle,size_t * length,uintptr_t buffer)75 long semihosting_file_read(long file_handle, size_t *length, uintptr_t buffer)
76 {
77 smh_file_read_write_block_t read_block;
78 long result = -EINVAL;
79
80 if ((length == NULL) || (buffer == (uintptr_t)NULL))
81 return result;
82
83 read_block.handle = file_handle;
84 read_block.buffer = buffer;
85 read_block.length = *length;
86
87 result = semihosting_call(SEMIHOSTING_SYS_READ,
88 (void *) &read_block);
89
90 if (result == *length) {
91 return -EINVAL;
92 } else if (result < *length) {
93 *length -= result;
94 return 0;
95 } else
96 return result;
97 }
98
semihosting_file_write(long file_handle,size_t * length,const uintptr_t buffer)99 long semihosting_file_write(long file_handle,
100 size_t *length,
101 const uintptr_t buffer)
102 {
103 smh_file_read_write_block_t write_block;
104 long result = -EINVAL;
105
106 if ((length == NULL) || (buffer == (uintptr_t)NULL))
107 return -EINVAL;
108
109 write_block.handle = file_handle;
110 write_block.buffer = (uintptr_t)buffer; /* cast away const */
111 write_block.length = *length;
112
113 result = semihosting_call(SEMIHOSTING_SYS_WRITE,
114 (void *) &write_block);
115
116 *length = result;
117
118 return (result == 0) ? 0 : -EINVAL;
119 }
120
semihosting_file_close(long file_handle)121 long semihosting_file_close(long file_handle)
122 {
123 return semihosting_call(SEMIHOSTING_SYS_CLOSE,
124 (void *) &file_handle);
125 }
126
semihosting_file_length(long file_handle)127 long semihosting_file_length(long file_handle)
128 {
129 return semihosting_call(SEMIHOSTING_SYS_FLEN,
130 (void *) &file_handle);
131 }
132
semihosting_read_char(void)133 char semihosting_read_char(void)
134 {
135 return semihosting_call(SEMIHOSTING_SYS_READC, NULL);
136 }
137
semihosting_write_char(char character)138 void semihosting_write_char(char character)
139 {
140 semihosting_call(SEMIHOSTING_SYS_WRITEC, (void *) &character);
141 }
142
semihosting_write_string(char * string)143 void semihosting_write_string(char *string)
144 {
145 semihosting_call(SEMIHOSTING_SYS_WRITE0, (void *) string);
146 }
147
semihosting_system(char * command_line)148 long semihosting_system(char *command_line)
149 {
150 smh_system_block_t system_block;
151
152 system_block.command_line = command_line;
153 system_block.command_length = strlen(command_line);
154
155 return semihosting_call(SEMIHOSTING_SYS_SYSTEM,
156 (void *) &system_block);
157 }
158
semihosting_get_flen(const char * file_name)159 long semihosting_get_flen(const char *file_name)
160 {
161 long file_handle;
162 size_t length;
163
164 assert(semihosting_connection_supported());
165
166 file_handle = semihosting_file_open(file_name, FOPEN_MODE_RB);
167 if (file_handle == -1)
168 return file_handle;
169
170 /* Find the length of the file */
171 length = semihosting_file_length(file_handle);
172
173 return semihosting_file_close(file_handle) ? -1 : length;
174 }
175
semihosting_download_file(const char * file_name,size_t buf_size,uintptr_t buf)176 long semihosting_download_file(const char *file_name,
177 size_t buf_size,
178 uintptr_t buf)
179 {
180 long ret = -EINVAL;
181 size_t length;
182 long file_handle;
183
184 /* Null pointer check */
185 if (!buf)
186 return ret;
187
188 assert(semihosting_connection_supported());
189
190 file_handle = semihosting_file_open(file_name, FOPEN_MODE_RB);
191 if (file_handle == -1)
192 return ret;
193
194 /* Find the actual length of the file */
195 length = semihosting_file_length(file_handle);
196 if (length == -1)
197 goto semihosting_fail;
198
199 /* Signal error if we do not have enough space for the file */
200 if (length > buf_size)
201 goto semihosting_fail;
202
203 /*
204 * A successful read will return 0 in which case we pass back
205 * the actual number of bytes read. Else we pass a negative
206 * value indicating an error.
207 */
208 ret = semihosting_file_read(file_handle, &length, buf);
209 if (ret)
210 goto semihosting_fail;
211 else
212 ret = length;
213
214 semihosting_fail:
215 semihosting_file_close(file_handle);
216 return ret;
217 }
218