1 /*
2 * Copyright (c) 2014-2017, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <io_driver.h>
9 #include <io_storage.h>
10 #include <platform_def.h>
11 #include <stddef.h>
12
13
14 /* Storage for a fixed maximum number of IO entities, definable by platform */
15 static io_entity_t entity_pool[MAX_IO_HANDLES];
16
17 /* Simple way of tracking used storage - each entry is NULL or a pointer to an
18 * entity */
19 static io_entity_t *entity_map[MAX_IO_HANDLES];
20
21 /* Track number of allocated entities */
22 static unsigned int entity_count;
23
24 /* Array of fixed maximum of registered devices, definable by platform */
25 static const io_dev_info_t *devices[MAX_IO_DEVICES];
26
27 /* Number of currently registered devices */
28 static unsigned int dev_count;
29
30 /* Extra validation functions only used when asserts are enabled */
31 #if ENABLE_ASSERTIONS
32
33 /* Return a boolean value indicating whether a device connector is valid */
is_valid_dev_connector(const io_dev_connector_t * dev_con)34 static int is_valid_dev_connector(const io_dev_connector_t *dev_con)
35 {
36 int result = (dev_con != NULL) && (dev_con->dev_open != NULL);
37 return result;
38 }
39
40
41 /* Return a boolean value indicating whether a device handle is valid */
is_valid_dev(const uintptr_t dev_handle)42 static int is_valid_dev(const uintptr_t dev_handle)
43 {
44 const io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
45 int result = (dev != NULL) && (dev->funcs != NULL) &&
46 (dev->funcs->type != NULL) &&
47 (dev->funcs->type() < IO_TYPE_MAX);
48 return result;
49 }
50
51
52 /* Return a boolean value indicating whether an IO entity is valid */
is_valid_entity(const uintptr_t handle)53 static int is_valid_entity(const uintptr_t handle)
54 {
55 const io_entity_t *entity = (io_entity_t *)handle;
56 int result = (entity != NULL) &&
57 (is_valid_dev((uintptr_t)entity->dev_handle));
58 return result;
59 }
60
61
62 /* Return a boolean value indicating whether a seek mode is valid */
is_valid_seek_mode(io_seek_mode_t mode)63 static int is_valid_seek_mode(io_seek_mode_t mode)
64 {
65 return ((mode != IO_SEEK_INVALID) && (mode < IO_SEEK_MAX));
66 }
67
68 #endif /* ENABLE_ASSERTIONS */
69 /* End of extra validation functions only used when asserts are enabled */
70
71
72 /* Open a connection to a specific device */
dev_open(const io_dev_connector_t * dev_con,const uintptr_t dev_spec,io_dev_info_t ** dev_info)73 static int dev_open(const io_dev_connector_t *dev_con, const uintptr_t dev_spec,
74 io_dev_info_t **dev_info)
75 {
76 int result;
77 assert(dev_info != NULL);
78 assert(is_valid_dev_connector(dev_con));
79
80 result = dev_con->dev_open(dev_spec, dev_info);
81 return result;
82 }
83
84
85 /* Set a handle to track an entity */
set_handle(uintptr_t * handle,io_entity_t * entity)86 static void set_handle(uintptr_t *handle, io_entity_t *entity)
87 {
88 assert(handle != NULL);
89 *handle = (uintptr_t)entity;
90 }
91
92
93 /* Locate an entity in the pool, specified by address */
find_first_entity(const io_entity_t * entity,unsigned int * index_out)94 static int find_first_entity(const io_entity_t *entity, unsigned int *index_out)
95 {
96 int result = -ENOENT;
97 for (unsigned int index = 0; index < MAX_IO_HANDLES; ++index) {
98 if (entity_map[index] == entity) {
99 result = 0;
100 *index_out = index;
101 break;
102 }
103 }
104 return result;
105 }
106
107
108 /* Allocate an entity from the pool and return a pointer to it */
allocate_entity(io_entity_t ** entity)109 static int allocate_entity(io_entity_t **entity)
110 {
111 int result = -ENOMEM;
112 assert(entity != NULL);
113
114 if (entity_count < MAX_IO_HANDLES) {
115 unsigned int index = 0;
116 result = find_first_entity(NULL, &index);
117 assert(result == 0);
118 *entity = entity_map[index] = &entity_pool[index];
119 ++entity_count;
120 }
121
122 return result;
123 }
124
125
126 /* Release an entity back to the pool */
free_entity(const io_entity_t * entity)127 static int free_entity(const io_entity_t *entity)
128 {
129 int result;
130 unsigned int index = 0;
131 assert(entity != NULL);
132
133 result = find_first_entity(entity, &index);
134 if (result == 0) {
135 entity_map[index] = NULL;
136 --entity_count;
137 }
138
139 return result;
140 }
141
142
143 /* Exported API */
144
145 /* Register a device driver */
io_register_device(const io_dev_info_t * dev_info)146 int io_register_device(const io_dev_info_t *dev_info)
147 {
148 int result = -ENOMEM;
149 assert(dev_info != NULL);
150
151 if (dev_count < MAX_IO_DEVICES) {
152 devices[dev_count] = dev_info;
153 dev_count++;
154 result = 0;
155 }
156
157 return result;
158 }
159
160
161 /* Open a connection to an IO device */
io_dev_open(const io_dev_connector_t * dev_con,const uintptr_t dev_spec,uintptr_t * handle)162 int io_dev_open(const io_dev_connector_t *dev_con, const uintptr_t dev_spec,
163 uintptr_t *handle)
164 {
165 int result;
166 assert(handle != NULL);
167
168 result = dev_open(dev_con, dev_spec, (io_dev_info_t **)handle);
169 return result;
170 }
171
172
173 /* Initialise an IO device explicitly - to permit lazy initialisation or
174 * re-initialisation */
io_dev_init(uintptr_t dev_handle,const uintptr_t init_params)175 int io_dev_init(uintptr_t dev_handle, const uintptr_t init_params)
176 {
177 int result = 0;
178 assert(dev_handle != (uintptr_t)NULL);
179 assert(is_valid_dev(dev_handle));
180
181 io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
182
183 /* Absence of registered function implies NOP here */
184 if (dev->funcs->dev_init != NULL) {
185 result = dev->funcs->dev_init(dev, init_params);
186 }
187
188 return result;
189 }
190
191
192 /* TODO: Consider whether an explicit "shutdown" API should be included */
193
194 /* Close a connection to a device */
io_dev_close(uintptr_t dev_handle)195 int io_dev_close(uintptr_t dev_handle)
196 {
197 int result = 0;
198 assert(dev_handle != (uintptr_t)NULL);
199 assert(is_valid_dev(dev_handle));
200
201 io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
202
203 /* Absence of registered function implies NOP here */
204 if (dev->funcs->dev_close != NULL) {
205 result = dev->funcs->dev_close(dev);
206 }
207
208 return result;
209 }
210
211
212 /* Synchronous operations */
213
214
215 /* Open an IO entity */
io_open(uintptr_t dev_handle,const uintptr_t spec,uintptr_t * handle)216 int io_open(uintptr_t dev_handle, const uintptr_t spec, uintptr_t *handle)
217 {
218 int result;
219 assert((spec != (uintptr_t)NULL) && (handle != NULL));
220 assert(is_valid_dev(dev_handle));
221
222 io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
223 io_entity_t *entity;
224
225 result = allocate_entity(&entity);
226
227 if (result == 0) {
228 assert(dev->funcs->open != NULL);
229 result = dev->funcs->open(dev, spec, entity);
230
231 if (result == 0) {
232 entity->dev_handle = dev;
233 set_handle(handle, entity);
234 } else
235 free_entity(entity);
236 }
237 return result;
238 }
239
240
241 /* Seek to a specific position in an IO entity */
io_seek(uintptr_t handle,io_seek_mode_t mode,ssize_t offset)242 int io_seek(uintptr_t handle, io_seek_mode_t mode, ssize_t offset)
243 {
244 int result = -ENODEV;
245 assert(is_valid_entity(handle) && is_valid_seek_mode(mode));
246
247 io_entity_t *entity = (io_entity_t *)handle;
248
249 io_dev_info_t *dev = entity->dev_handle;
250
251 if (dev->funcs->seek != NULL)
252 result = dev->funcs->seek(entity, mode, offset);
253
254 return result;
255 }
256
257
258 /* Determine the length of an IO entity */
io_size(uintptr_t handle,size_t * length)259 int io_size(uintptr_t handle, size_t *length)
260 {
261 int result = -ENODEV;
262 assert(is_valid_entity(handle) && (length != NULL));
263
264 io_entity_t *entity = (io_entity_t *)handle;
265
266 io_dev_info_t *dev = entity->dev_handle;
267
268 if (dev->funcs->size != NULL)
269 result = dev->funcs->size(entity, length);
270
271 return result;
272 }
273
274
275 /* Read data from an IO entity */
io_read(uintptr_t handle,uintptr_t buffer,size_t length,size_t * length_read)276 int io_read(uintptr_t handle,
277 uintptr_t buffer,
278 size_t length,
279 size_t *length_read)
280 {
281 int result = -ENODEV;
282 assert(is_valid_entity(handle) && (buffer != (uintptr_t)NULL));
283
284 io_entity_t *entity = (io_entity_t *)handle;
285
286 io_dev_info_t *dev = entity->dev_handle;
287
288 if (dev->funcs->read != NULL)
289 result = dev->funcs->read(entity, buffer, length, length_read);
290
291 return result;
292 }
293
294
295 /* Write data to an IO entity */
io_write(uintptr_t handle,const uintptr_t buffer,size_t length,size_t * length_written)296 int io_write(uintptr_t handle,
297 const uintptr_t buffer,
298 size_t length,
299 size_t *length_written)
300 {
301 int result = -ENODEV;
302 assert(is_valid_entity(handle) && (buffer != (uintptr_t)NULL));
303
304 io_entity_t *entity = (io_entity_t *)handle;
305
306 io_dev_info_t *dev = entity->dev_handle;
307
308 if (dev->funcs->write != NULL) {
309 result = dev->funcs->write(entity, buffer, length,
310 length_written);
311 }
312
313 return result;
314 }
315
316
317 /* Close an IO entity */
io_close(uintptr_t handle)318 int io_close(uintptr_t handle)
319 {
320 int result = 0;
321 assert(is_valid_entity(handle));
322
323 io_entity_t *entity = (io_entity_t *)handle;
324
325 io_dev_info_t *dev = entity->dev_handle;
326
327 /* Absence of registered function implies NOP here */
328 if (dev->funcs->close != NULL)
329 result = dev->funcs->close(entity);
330
331 /* Ignore improbable free_entity failure */
332 (void)free_entity(entity);
333
334 return result;
335 }
336