1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
/*
* Copyright (c) 2014-2018, ARM Limited and Contributors. All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include <assert.h>
#include <platform_def.h>
#include <drivers/io/io_driver.h>
#include <drivers/io/io_semihosting.h>
#include <drivers/io/io_storage.h>
#include <lib/semihosting.h>
/* Identify the device type as semihosting */
static io_type_t device_type_sh(void)
{
return IO_TYPE_SEMIHOSTING;
}
/* Semi-hosting functions, device info and handle */
static int sh_dev_open(const uintptr_t dev_spec, io_dev_info_t **dev_info);
static int sh_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
io_entity_t *entity);
static int sh_file_seek(io_entity_t *entity, int mode, ssize_t offset);
static int sh_file_len(io_entity_t *entity, size_t *length);
static int sh_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
size_t *length_read);
static int sh_file_write(io_entity_t *entity, const uintptr_t buffer,
size_t length, size_t *length_written);
static int sh_file_close(io_entity_t *entity);
static const io_dev_connector_t sh_dev_connector = {
.dev_open = sh_dev_open
};
static const io_dev_funcs_t sh_dev_funcs = {
.type = device_type_sh,
.open = sh_file_open,
.seek = sh_file_seek,
.size = sh_file_len,
.read = sh_file_read,
.write = sh_file_write,
.close = sh_file_close,
.dev_init = NULL, /* NOP */
.dev_close = NULL, /* NOP */
};
/* No state associated with this device so structure can be const */
static const io_dev_info_t sh_dev_info = {
.funcs = &sh_dev_funcs,
.info = (uintptr_t)NULL
};
/* Open a connection to the semi-hosting device */
static int sh_dev_open(const uintptr_t dev_spec __unused,
io_dev_info_t **dev_info)
{
assert(dev_info != NULL);
*dev_info = (io_dev_info_t *)&sh_dev_info; /* cast away const */
return 0;
}
/* Open a file on the semi-hosting device */
static int sh_file_open(io_dev_info_t *dev_info __unused,
const uintptr_t spec, io_entity_t *entity)
{
int result = -ENOENT;
long sh_result;
const io_file_spec_t *file_spec = (const io_file_spec_t *)spec;
assert(file_spec != NULL);
assert(entity != NULL);
sh_result = semihosting_file_open(file_spec->path, file_spec->mode);
if (sh_result > 0) {
entity->info = (uintptr_t)sh_result;
result = 0;
}
return result;
}
/* Seek to a particular file offset on the semi-hosting device */
static int sh_file_seek(io_entity_t *entity, int mode, ssize_t offset)
{
long file_handle, sh_result;
assert(entity != NULL);
file_handle = (long)entity->info;
sh_result = semihosting_file_seek(file_handle, offset);
return (sh_result == 0) ? 0 : -ENOENT;
}
/* Return the size of a file on the semi-hosting device */
static int sh_file_len(io_entity_t *entity, size_t *length)
{
int result = -ENOENT;
assert(entity != NULL);
assert(length != NULL);
long sh_handle = (long)entity->info;
long sh_result = semihosting_file_length(sh_handle);
if (sh_result >= 0) {
result = 0;
*length = (size_t)sh_result;
}
return result;
}
/* Read data from a file on the semi-hosting device */
static int sh_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
size_t *length_read)
{
int result = -ENOENT;
long sh_result;
size_t bytes = length;
long file_handle;
assert(entity != NULL);
assert(length_read != NULL);
file_handle = (long)entity->info;
sh_result = semihosting_file_read(file_handle, &bytes, buffer);
if (sh_result >= 0) {
*length_read = (bytes != length) ? bytes : length;
result = 0;
}
return result;
}
/* Write data to a file on the semi-hosting device */
static int sh_file_write(io_entity_t *entity, const uintptr_t buffer,
size_t length, size_t *length_written)
{
long sh_result;
long file_handle;
size_t bytes = length;
assert(entity != NULL);
assert(length_written != NULL);
file_handle = (long)entity->info;
sh_result = semihosting_file_write(file_handle, &bytes, buffer);
*length_written = length - bytes;
return (sh_result == 0) ? 0 : -ENOENT;
}
/* Close a file on the semi-hosting device */
static int sh_file_close(io_entity_t *entity)
{
long sh_result;
long file_handle;
assert(entity != NULL);
file_handle = (long)entity->info;
sh_result = semihosting_file_close(file_handle);
return (sh_result >= 0) ? 0 : -ENOENT;
}
/* Exported functions */
/* Register the semi-hosting driver with the IO abstraction */
int register_io_dev_sh(const io_dev_connector_t **dev_con)
{
int result;
assert(dev_con != NULL);
result = io_register_device(&sh_dev_info);
if (result == 0)
*dev_con = &sh_dev_connector;
return result;
}