]> git.ipfire.org Git - people/ms/u-boot.git/blob - examples/api/glue.c
usbtty: fix typos
[people/ms/u-boot.git] / examples / api / glue.c
1 /*
2 * (C) Copyright 2007-2008 Semihalf, Rafal Jaworowski <raj@semihalf.com>
3 *
4 * SPDX-License-Identifier: GPL-2.0+
5 */
6
7 #include <common.h>
8 #include <linux/types.h>
9 #include <api_public.h>
10
11 #include "glue.h"
12
13 static int valid_sig(struct api_signature *sig)
14 {
15 uint32_t checksum;
16 struct api_signature s;
17
18 if (sig == NULL)
19 return 0;
20 /*
21 * Clear the checksum field (in the local copy) so as to calculate the
22 * CRC with the same initial contents as at the time when the sig was
23 * produced
24 */
25 s = *sig;
26 s.checksum = 0;
27
28 checksum = crc32(0, (unsigned char *)&s, sizeof(struct api_signature));
29
30 if (checksum != sig->checksum)
31 return 0;
32
33 return 1;
34 }
35
36 /*
37 * Searches for the U-Boot API signature
38 *
39 * returns 1/0 depending on found/not found result
40 */
41 int api_search_sig(struct api_signature **sig)
42 {
43 unsigned char *sp;
44 uint32_t search_start = 0;
45 uint32_t search_end = 0;
46
47 if (sig == NULL)
48 return 0;
49
50 if (search_hint == 0)
51 search_hint = 255 * 1024 * 1024;
52
53 search_start = search_hint & ~0x000fffff;
54 search_end = search_start + API_SEARCH_LEN - API_SIG_MAGLEN;
55
56 sp = (unsigned char *)search_start;
57 while ((sp + API_SIG_MAGLEN) < (unsigned char *)search_end) {
58 if (!memcmp(sp, API_SIG_MAGIC, API_SIG_MAGLEN)) {
59 *sig = (struct api_signature *)sp;
60 if (valid_sig(*sig))
61 return 1;
62 }
63 sp += API_SIG_MAGLEN;
64 }
65
66 *sig = NULL;
67 return 0;
68 }
69
70 /****************************************
71 *
72 * console
73 *
74 ****************************************/
75
76 int ub_getc(void)
77 {
78 int c;
79
80 if (!syscall(API_GETC, NULL, &c))
81 return -1;
82
83 return c;
84 }
85
86 int ub_tstc(void)
87 {
88 int t;
89
90 if (!syscall(API_TSTC, NULL, &t))
91 return -1;
92
93 return t;
94 }
95
96 void ub_putc(char c)
97 {
98 syscall(API_PUTC, NULL, &c);
99 }
100
101 void ub_puts(const char *s)
102 {
103 syscall(API_PUTS, NULL, s);
104 }
105
106 /****************************************
107 *
108 * system
109 *
110 ****************************************/
111
112 void ub_reset(void)
113 {
114 syscall(API_RESET, NULL);
115 }
116
117 static struct mem_region mr[UB_MAX_MR];
118 static struct sys_info si;
119
120 struct sys_info * ub_get_sys_info(void)
121 {
122 int err = 0;
123
124 memset(&si, 0, sizeof(struct sys_info));
125 si.mr = mr;
126 si.mr_no = UB_MAX_MR;
127 memset(&mr, 0, sizeof(mr));
128
129 if (!syscall(API_GET_SYS_INFO, &err, &si))
130 return NULL;
131
132 return ((err) ? NULL : &si);
133 }
134
135 /****************************************
136 *
137 * timing
138 *
139 ****************************************/
140
141 void ub_udelay(unsigned long usec)
142 {
143 syscall(API_UDELAY, NULL, &usec);
144 }
145
146 unsigned long ub_get_timer(unsigned long base)
147 {
148 unsigned long cur;
149
150 if (!syscall(API_GET_TIMER, NULL, &cur, &base))
151 return 0;
152
153 return cur;
154 }
155
156
157 /****************************************************************************
158 *
159 * devices
160 *
161 * Devices are identified by handles: numbers 0, 1, 2, ..., UB_MAX_DEV-1
162 *
163 ***************************************************************************/
164
165 static struct device_info devices[UB_MAX_DEV];
166
167 struct device_info * ub_dev_get(int i)
168 {
169 return ((i < 0 || i >= UB_MAX_DEV) ? NULL : &devices[i]);
170 }
171
172 /*
173 * Enumerates the devices: fills out device_info elements in the devices[]
174 * array.
175 *
176 * returns: number of devices found
177 */
178 int ub_dev_enum(void)
179 {
180 struct device_info *di;
181 int n = 0;
182
183 memset(&devices, 0, sizeof(struct device_info) * UB_MAX_DEV);
184 di = &devices[0];
185
186 if (!syscall(API_DEV_ENUM, NULL, di))
187 return 0;
188
189 while (di->cookie != NULL) {
190
191 if (++n >= UB_MAX_DEV)
192 break;
193
194 /* take another device_info */
195 di++;
196
197 /* pass on the previous cookie */
198 di->cookie = devices[n - 1].cookie;
199
200 if (!syscall(API_DEV_ENUM, NULL, di))
201 return 0;
202 }
203
204 return n;
205 }
206
207 /*
208 * handle: 0-based id of the device
209 *
210 * returns: 0 when OK, err otherwise
211 */
212 int ub_dev_open(int handle)
213 {
214 struct device_info *di;
215 int err = 0;
216
217 if (handle < 0 || handle >= UB_MAX_DEV)
218 return API_EINVAL;
219
220 di = &devices[handle];
221
222 if (!syscall(API_DEV_OPEN, &err, di))
223 return -1;
224
225 return err;
226 }
227
228 int ub_dev_close(int handle)
229 {
230 struct device_info *di;
231
232 if (handle < 0 || handle >= UB_MAX_DEV)
233 return API_EINVAL;
234
235 di = &devices[handle];
236 if (!syscall(API_DEV_CLOSE, NULL, di))
237 return -1;
238
239 return 0;
240 }
241
242 /*
243 *
244 * Validates device for read/write, it has to:
245 *
246 * - have sane handle
247 * - be opened
248 *
249 * returns: 0/1 accordingly
250 */
251 static int dev_valid(int handle)
252 {
253 if (handle < 0 || handle >= UB_MAX_DEV)
254 return 0;
255
256 if (devices[handle].state != DEV_STA_OPEN)
257 return 0;
258
259 return 1;
260 }
261
262 static int dev_stor_valid(int handle)
263 {
264 if (!dev_valid(handle))
265 return 0;
266
267 if (!(devices[handle].type & DEV_TYP_STOR))
268 return 0;
269
270 return 1;
271 }
272
273 int ub_dev_read(int handle, void *buf, lbasize_t len, lbastart_t start,
274 lbasize_t *rlen)
275 {
276 struct device_info *di;
277 lbasize_t act_len;
278 int err = 0;
279
280 if (!dev_stor_valid(handle))
281 return API_ENODEV;
282
283 di = &devices[handle];
284 if (!syscall(API_DEV_READ, &err, di, buf, &len, &start, &act_len))
285 return API_ESYSC;
286
287 if (!err && rlen)
288 *rlen = act_len;
289
290 return err;
291 }
292
293 static int dev_net_valid(int handle)
294 {
295 if (!dev_valid(handle))
296 return 0;
297
298 if (devices[handle].type != DEV_TYP_NET)
299 return 0;
300
301 return 1;
302 }
303
304 int ub_dev_recv(int handle, void *buf, int len, int *rlen)
305 {
306 struct device_info *di;
307 int err = 0, act_len;
308
309 if (!dev_net_valid(handle))
310 return API_ENODEV;
311
312 di = &devices[handle];
313 if (!syscall(API_DEV_READ, &err, di, buf, &len, &act_len))
314 return API_ESYSC;
315
316 if (!err && rlen)
317 *rlen = act_len;
318
319 return (err);
320 }
321
322 int ub_dev_send(int handle, void *buf, int len)
323 {
324 struct device_info *di;
325 int err = 0;
326
327 if (!dev_net_valid(handle))
328 return API_ENODEV;
329
330 di = &devices[handle];
331 if (!syscall(API_DEV_WRITE, &err, di, buf, &len))
332 return API_ESYSC;
333
334 return err;
335 }
336
337 /****************************************
338 *
339 * env vars
340 *
341 ****************************************/
342
343 char * ub_env_get(const char *name)
344 {
345 char *value;
346
347 if (!syscall(API_ENV_GET, NULL, name, &value))
348 return NULL;
349
350 return value;
351 }
352
353 void ub_env_set(const char *name, char *value)
354 {
355 syscall(API_ENV_SET, NULL, name, value);
356 }
357
358 static char env_name[256];
359
360 const char * ub_env_enum(const char *last)
361 {
362 const char *env, *str;
363 int i;
364
365 env = NULL;
366
367 /*
368 * It's OK to pass only the name piece as last (and not the whole
369 * 'name=val' string), since the API_ENUM_ENV call uses envmatch()
370 * internally, which handles such case
371 */
372 if (!syscall(API_ENV_ENUM, NULL, last, &env))
373 return NULL;
374
375 if (!env)
376 /* no more env. variables to enumerate */
377 return NULL;
378
379 /* next enumerated env var */
380 memset(env_name, 0, 256);
381 for (i = 0, str = env; *str != '=' && *str != '\0';)
382 env_name[i++] = *str++;
383
384 env_name[i] = '\0';
385
386 return env_name;
387 }
388
389 /****************************************
390 *
391 * display
392 *
393 ****************************************/
394
395 int ub_display_get_info(int type, struct display_info *di)
396 {
397 int err = 0;
398
399 if (!syscall(API_DISPLAY_GET_INFO, &err, type, di))
400 return API_ESYSC;
401
402 return err;
403 }
404
405 int ub_display_draw_bitmap(ulong bitmap, int x, int y)
406 {
407 int err = 0;
408
409 if (!syscall(API_DISPLAY_DRAW_BITMAP, &err, bitmap, x, y))
410 return API_ESYSC;
411
412 return err;
413 }
414
415 void ub_display_clear(void)
416 {
417 syscall(API_DISPLAY_CLEAR, NULL);
418 }
419
420 __weak void *memcpy(void *dest, const void *src, size_t size)
421 {
422 unsigned char *dptr = dest;
423 const unsigned char *ptr = src;
424 const unsigned char *end = src + size;
425
426 while (ptr < end)
427 *dptr++ = *ptr++;
428
429 return dest;
430 }