1/*
2 * Copyright (c) 2013-2014, ARM Limited and Contributors. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * Redistributions of source code must retain the above copyright notice, this
8 * list of conditions and the following disclaimer.
9 *
10 * Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 *
14 * Neither the name of ARM nor the names of its contributors may be used
15 * to endorse or promote products derived from this software without specific
16 * prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 */
30
31#include <assert.h>
32#include <errno.h>
33#include <semihosting.h>
34#include <string.h>
35
36#ifndef SEMIHOSTING_SUPPORTED
37#define SEMIHOSTING_SUPPORTED  1
38#endif
39
40long semihosting_call(unsigned long operation,
41			void *system_block_address);
42
43typedef struct {
44	const char *file_name;
45	unsigned long mode;
46	size_t name_length;
47} smh_file_open_block_t;
48
49typedef struct {
50	long handle;
51	uintptr_t buffer;
52	size_t length;
53} smh_file_read_write_block_t;
54
55typedef struct {
56	long handle;
57	ssize_t location;
58} smh_file_seek_block_t;
59
60typedef struct {
61	char *command_line;
62	size_t command_length;
63} smh_system_block_t;
64
65long semihosting_connection_supported(void)
66{
67	return SEMIHOSTING_SUPPORTED;
68}
69
70long semihosting_file_open(const char *file_name, size_t mode)
71{
72	smh_file_open_block_t open_block;
73
74	open_block.file_name = file_name;
75	open_block.mode = mode;
76	open_block.name_length = strlen(file_name);
77
78	return semihosting_call(SEMIHOSTING_SYS_OPEN,
79				(void *) &open_block);
80}
81
82long semihosting_file_seek(long file_handle, ssize_t offset)
83{
84	smh_file_seek_block_t seek_block;
85	long result;
86
87	seek_block.handle = file_handle;
88	seek_block.location = offset;
89
90	result = semihosting_call(SEMIHOSTING_SYS_SEEK,
91				  (void *) &seek_block);
92
93	if (result)
94		result = semihosting_call(SEMIHOSTING_SYS_ERRNO, 0);
95
96	return result;
97}
98
99long semihosting_file_read(long file_handle, size_t *length, uintptr_t buffer)
100{
101	smh_file_read_write_block_t read_block;
102	long result = -EINVAL;
103
104	if ((length == NULL) || (buffer == (uintptr_t)NULL))
105		return result;
106
107	read_block.handle = file_handle;
108	read_block.buffer = buffer;
109	read_block.length = *length;
110
111	result = semihosting_call(SEMIHOSTING_SYS_READ,
112				  (void *) &read_block);
113
114	if (result == *length) {
115		return -EINVAL;
116	} else if (result < *length) {
117		*length -= result;
118		return 0;
119	} else
120		return result;
121}
122
123long semihosting_file_write(long file_handle,
124			    size_t *length,
125			    const uintptr_t buffer)
126{
127	smh_file_read_write_block_t write_block;
128
129	if ((length == NULL) || (buffer == (uintptr_t)NULL))
130		return -EINVAL;
131
132	write_block.handle = file_handle;
133	write_block.buffer = (uintptr_t)buffer; /* cast away const */
134	write_block.length = *length;
135
136	*length = semihosting_call(SEMIHOSTING_SYS_WRITE,
137				   (void *) &write_block);
138
139	return *length;
140}
141
142long semihosting_file_close(long file_handle)
143{
144	return semihosting_call(SEMIHOSTING_SYS_CLOSE,
145				(void *) &file_handle);
146}
147
148long semihosting_file_length(long file_handle)
149{
150	return semihosting_call(SEMIHOSTING_SYS_FLEN,
151				(void *) &file_handle);
152}
153
154char semihosting_read_char(void)
155{
156	return semihosting_call(SEMIHOSTING_SYS_READC, NULL);
157}
158
159void semihosting_write_char(char character)
160{
161	semihosting_call(SEMIHOSTING_SYS_WRITEC, (void *) &character);
162}
163
164void semihosting_write_string(char *string)
165{
166	semihosting_call(SEMIHOSTING_SYS_WRITE0, (void *) string);
167}
168
169long semihosting_system(char *command_line)
170{
171	smh_system_block_t system_block;
172
173	system_block.command_line = command_line;
174	system_block.command_length = strlen(command_line);
175
176	return semihosting_call(SEMIHOSTING_SYS_SYSTEM,
177				(void *) &system_block);
178}
179
180long semihosting_get_flen(const char *file_name)
181{
182	long file_handle;
183	size_t length;
184
185	assert(semihosting_connection_supported());
186
187	file_handle = semihosting_file_open(file_name, FOPEN_MODE_RB);
188	if (file_handle == -1)
189		return file_handle;
190
191	/* Find the length of the file */
192	length = semihosting_file_length(file_handle);
193
194	return semihosting_file_close(file_handle) ? -1 : length;
195}
196
197long semihosting_download_file(const char *file_name,
198			      size_t buf_size,
199			      uintptr_t buf)
200{
201	long ret = -EINVAL;
202	size_t length;
203	long file_handle;
204
205	/* Null pointer check */
206	if (!buf)
207		return ret;
208
209	assert(semihosting_connection_supported());
210
211	file_handle = semihosting_file_open(file_name, FOPEN_MODE_RB);
212	if (file_handle == -1)
213		return ret;
214
215	/* Find the actual length of the file */
216	length = semihosting_file_length(file_handle);
217	if (length == -1)
218		goto semihosting_fail;
219
220	/* Signal error if we do not have enough space for the file */
221	if (length > buf_size)
222		goto semihosting_fail;
223
224	/*
225	 * A successful read will return 0 in which case we pass back
226	 * the actual number of bytes read. Else we pass a negative
227	 * value indicating an error.
228	 */
229	ret = semihosting_file_read(file_handle, &length, buf);
230	if (ret)
231		goto semihosting_fail;
232	else
233		ret = length;
234
235semihosting_fail:
236	semihosting_file_close(file_handle);
237	return ret;
238}
239