]>
Commit | Line | Data |
---|---|---|
500856eb RJ |
1 | /* |
2 | * (C) Copyright 2007 Semihalf | |
3 | * | |
4 | * Written by: Rafal Jaworowski <raj@semihalf.com> | |
5 | * | |
6 | * See file CREDITS for list of people who contributed to this | |
7 | * project. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or | |
10 | * modify it under the terms of the GNU General Public License as | |
11 | * published by the Free Software Foundation; either version 2 of | |
12 | * the License, or (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
22 | * MA 02111-1307 USA | |
23 | * | |
24 | */ | |
25 | ||
26 | #include <config.h> | |
27 | ||
28 | #if defined(CONFIG_API) | |
29 | ||
30 | #include <command.h> | |
31 | #include <common.h> | |
32 | #include <malloc.h> | |
33 | #include <linux/types.h> | |
34 | #include <api_public.h> | |
35 | ||
36 | #include "api_private.h" | |
37 | ||
38 | #define DEBUG | |
39 | #undef DEBUG | |
40 | ||
41 | /* U-Boot routines needed */ | |
42 | extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]); | |
43 | extern uchar (*env_get_char)(int); | |
44 | extern uchar *env_get_addr(int); | |
45 | ||
46 | /***************************************************************************** | |
47 | * | |
48 | * This is the API core. | |
49 | * | |
50 | * API_ functions are part of U-Boot code and constitute the lowest level | |
51 | * calls: | |
52 | * | |
53 | * - they know what values they need as arguments | |
54 | * - their direct return value pertains to the API_ "shell" itself (0 on | |
55 | * success, some error code otherwise) | |
56 | * - if the call returns a value it is buried within arguments | |
57 | * | |
58 | ****************************************************************************/ | |
59 | ||
60 | #ifdef DEBUG | |
61 | #define debugf(fmt, args...) do { printf("%s(): ", __func__); printf(fmt, ##args); } while (0) | |
62 | #else | |
63 | #define debugf(fmt, args...) | |
64 | #endif | |
65 | ||
66 | typedef int (*cfp_t)(va_list argp); | |
67 | ||
68 | static int calls_no; | |
69 | ||
70 | /* | |
71 | * pseudo signature: | |
72 | * | |
73 | * int API_getc(int *c) | |
74 | */ | |
75 | static int API_getc(va_list ap) | |
76 | { | |
77 | int *c; | |
78 | ||
79 | if ((c = (int *)va_arg(ap, u_int32_t)) == NULL) | |
80 | return API_EINVAL; | |
81 | ||
82 | *c = getc(); | |
83 | return 0; | |
84 | } | |
85 | ||
86 | /* | |
87 | * pseudo signature: | |
88 | * | |
89 | * int API_tstc(int *c) | |
90 | */ | |
91 | static int API_tstc(va_list ap) | |
92 | { | |
93 | int *t; | |
94 | ||
95 | if ((t = (int *)va_arg(ap, u_int32_t)) == NULL) | |
96 | return API_EINVAL; | |
97 | ||
98 | *t = tstc(); | |
99 | return 0; | |
100 | } | |
101 | ||
102 | /* | |
103 | * pseudo signature: | |
104 | * | |
105 | * int API_putc(char *ch) | |
106 | */ | |
107 | static int API_putc(va_list ap) | |
108 | { | |
109 | char *c; | |
110 | ||
111 | if ((c = (char *)va_arg(ap, u_int32_t)) == NULL) | |
112 | return API_EINVAL; | |
113 | ||
114 | putc(*c); | |
115 | return 0; | |
116 | } | |
117 | ||
118 | /* | |
119 | * pseudo signature: | |
120 | * | |
121 | * int API_puts(char **s) | |
122 | */ | |
123 | static int API_puts(va_list ap) | |
124 | { | |
125 | char *s; | |
126 | ||
127 | if ((s = (char *)va_arg(ap, u_int32_t)) == NULL) | |
128 | return API_EINVAL; | |
129 | ||
130 | puts(s); | |
131 | return 0; | |
132 | } | |
133 | ||
134 | /* | |
135 | * pseudo signature: | |
136 | * | |
137 | * int API_reset(void) | |
138 | */ | |
139 | static int API_reset(va_list ap) | |
140 | { | |
141 | do_reset(NULL, 0, 0, NULL); | |
142 | ||
143 | /* NOT REACHED */ | |
144 | return 0; | |
145 | } | |
146 | ||
147 | /* | |
148 | * pseudo signature: | |
149 | * | |
150 | * int API_get_sys_info(struct sys_info *si) | |
151 | * | |
152 | * fill out the sys_info struct containing selected parameters about the | |
153 | * machine | |
154 | */ | |
155 | static int API_get_sys_info(va_list ap) | |
156 | { | |
157 | struct sys_info *si; | |
158 | ||
159 | si = (struct sys_info *)va_arg(ap, u_int32_t); | |
160 | if (si == NULL) | |
161 | return API_ENOMEM; | |
162 | ||
163 | return (platform_sys_info(si)) ? 0 : API_ENODEV; | |
164 | } | |
165 | ||
166 | /* | |
167 | * pseudo signature: | |
168 | * | |
169 | * int API_udelay(unsigned long *udelay) | |
170 | */ | |
171 | static int API_udelay(va_list ap) | |
172 | { | |
173 | unsigned long *d; | |
174 | ||
175 | if ((d = (unsigned long *)va_arg(ap, u_int32_t)) == NULL) | |
176 | return API_EINVAL; | |
177 | ||
178 | udelay(*d); | |
179 | return 0; | |
180 | } | |
181 | ||
182 | /* | |
183 | * pseudo signature: | |
184 | * | |
185 | * int API_get_timer(unsigned long *current, unsigned long *base) | |
186 | */ | |
187 | static int API_get_timer(va_list ap) | |
188 | { | |
189 | unsigned long *base, *cur; | |
190 | ||
191 | cur = (unsigned long *)va_arg(ap, u_int32_t); | |
192 | if (cur == NULL) | |
193 | return API_EINVAL; | |
194 | ||
195 | base = (unsigned long *)va_arg(ap, u_int32_t); | |
196 | if (base == NULL) | |
197 | return API_EINVAL; | |
198 | ||
199 | *cur = get_timer(*base); | |
200 | return 0; | |
201 | } | |
202 | ||
203 | ||
204 | /***************************************************************************** | |
205 | * | |
206 | * pseudo signature: | |
207 | * | |
208 | * int API_dev_enum(struct device_info *) | |
209 | * | |
210 | * | |
211 | * cookies uniqely identify the previously enumerated device instance and | |
212 | * provide a hint for what to inspect in current enum iteration: | |
213 | * | |
214 | * - net: ð_device struct address from list pointed to by eth_devices | |
215 | * | |
216 | * - storage: block_dev_desc_t struct address from &ide_dev_desc[n], | |
217 | * &scsi_dev_desc[n] and similar tables | |
218 | * | |
219 | ****************************************************************************/ | |
220 | ||
221 | static int API_dev_enum(va_list ap) | |
222 | { | |
223 | struct device_info *di; | |
224 | ||
225 | /* arg is ptr to the device_info struct we are going to fill out */ | |
226 | di = (struct device_info *)va_arg(ap, u_int32_t); | |
227 | if (di == NULL) | |
228 | return API_EINVAL; | |
229 | ||
230 | if (di->cookie == NULL) { | |
231 | /* start over - clean up enumeration */ | |
232 | dev_enum_reset(); /* XXX shouldn't the name contain 'stor'? */ | |
233 | debugf("RESTART ENUM\n"); | |
234 | ||
235 | /* net device enumeration first */ | |
236 | if (dev_enum_net(di)) | |
237 | return 0; | |
238 | } | |
239 | ||
240 | /* | |
241 | * The hidden assumption is there can only be one active network | |
242 | * device and it is identified upon enumeration (re)start, so there's | |
243 | * no point in trying to find network devices in other cases than the | |
244 | * (re)start and hence the 'next' device can only be storage | |
245 | */ | |
246 | if (!dev_enum_storage(di)) | |
247 | /* make sure we mark there are no more devices */ | |
248 | di->cookie = NULL; | |
249 | ||
250 | return 0; | |
251 | } | |
252 | ||
253 | ||
254 | static int API_dev_open(va_list ap) | |
255 | { | |
256 | struct device_info *di; | |
257 | int err = 0; | |
258 | ||
259 | /* arg is ptr to the device_info struct */ | |
260 | di = (struct device_info *)va_arg(ap, u_int32_t); | |
261 | if (di == NULL) | |
262 | return API_EINVAL; | |
263 | ||
264 | /* Allow only one consumer of the device at a time */ | |
265 | if (di->state == DEV_STA_OPEN) | |
266 | return API_EBUSY; | |
267 | ||
268 | if (di->cookie == NULL) | |
269 | return API_ENODEV; | |
270 | ||
271 | if (di->type & DEV_TYP_STOR) | |
272 | err = dev_open_stor(di->cookie); | |
273 | ||
274 | else if (di->type & DEV_TYP_NET) | |
275 | err = dev_open_net(di->cookie); | |
276 | else | |
277 | err = API_ENODEV; | |
278 | ||
279 | if (!err) | |
280 | di->state = DEV_STA_OPEN; | |
281 | ||
282 | return err; | |
283 | } | |
284 | ||
285 | ||
286 | static int API_dev_close(va_list ap) | |
287 | { | |
288 | struct device_info *di; | |
289 | int err = 0; | |
290 | ||
291 | /* arg is ptr to the device_info struct */ | |
292 | di = (struct device_info *)va_arg(ap, u_int32_t); | |
293 | if (di == NULL) | |
294 | return API_EINVAL; | |
295 | ||
296 | if (di->state == DEV_STA_CLOSED) | |
297 | return 0; | |
298 | ||
299 | if (di->cookie == NULL) | |
300 | return API_ENODEV; | |
301 | ||
302 | if (di->type & DEV_TYP_STOR) | |
303 | err = dev_close_stor(di->cookie); | |
304 | ||
305 | else if (di->type & DEV_TYP_NET) | |
306 | err = dev_close_net(di->cookie); | |
307 | else | |
308 | /* | |
309 | * In case of unknown device we cannot change its state, so | |
310 | * only return error code | |
311 | */ | |
312 | err = API_ENODEV; | |
313 | ||
314 | if (!err) | |
315 | di->state = DEV_STA_CLOSED; | |
316 | ||
317 | return err; | |
318 | } | |
319 | ||
320 | ||
321 | /* | |
322 | * Notice: this is for sending network packets only, as U-Boot does not | |
323 | * support writing to storage at the moment (12.2007) | |
324 | * | |
325 | * pseudo signature: | |
326 | * | |
327 | * int API_dev_write( | |
328 | * struct device_info *di, | |
329 | * void *buf, | |
330 | * int *len | |
331 | * ) | |
332 | * | |
333 | * buf: ptr to buffer from where to get the data to send | |
334 | * | |
335 | * len: length of packet to be sent (in bytes) | |
336 | * | |
337 | */ | |
338 | static int API_dev_write(va_list ap) | |
339 | { | |
340 | struct device_info *di; | |
341 | void *buf; | |
342 | int *len; | |
343 | int err = 0; | |
344 | ||
345 | /* 1. arg is ptr to the device_info struct */ | |
346 | di = (struct device_info *)va_arg(ap, u_int32_t); | |
347 | if (di == NULL) | |
348 | return API_EINVAL; | |
349 | ||
350 | /* XXX should we check if device is open? i.e. the ->state ? */ | |
351 | ||
352 | if (di->cookie == NULL) | |
353 | return API_ENODEV; | |
354 | ||
355 | /* 2. arg is ptr to buffer from where to get data to write */ | |
356 | buf = (void *)va_arg(ap, u_int32_t); | |
357 | if (buf == NULL) | |
358 | return API_EINVAL; | |
359 | ||
360 | /* 3. arg is length of buffer */ | |
361 | len = (int *)va_arg(ap, u_int32_t); | |
362 | if (len == NULL) | |
363 | return API_EINVAL; | |
364 | if (*len <= 0) | |
365 | return API_EINVAL; | |
366 | ||
367 | if (di->type & DEV_TYP_STOR) | |
368 | /* | |
369 | * write to storage is currently not supported by U-Boot: | |
370 | * no storage device implements block_write() method | |
371 | */ | |
372 | return API_ENODEV; | |
373 | ||
374 | else if (di->type & DEV_TYP_NET) | |
375 | err = dev_write_net(di->cookie, buf, *len); | |
376 | else | |
377 | err = API_ENODEV; | |
378 | ||
379 | return err; | |
380 | } | |
381 | ||
382 | ||
383 | /* | |
384 | * pseudo signature: | |
385 | * | |
386 | * int API_dev_read( | |
387 | * struct device_info *di, | |
388 | * void *buf, | |
389 | * size_t *len, | |
390 | * unsigned long *start | |
391 | * size_t *act_len | |
392 | * ) | |
393 | * | |
394 | * buf: ptr to buffer where to put the read data | |
395 | * | |
396 | * len: ptr to length to be read | |
397 | * - network: len of packet to read (in bytes) | |
398 | * - storage: # of blocks to read (can vary in size depending on define) | |
399 | * | |
400 | * start: ptr to start block (only used for storage devices, ignored for | |
401 | * network) | |
402 | * | |
403 | * act_len: ptr to where to put the len actually read | |
404 | */ | |
405 | static int API_dev_read(va_list ap) | |
406 | { | |
407 | struct device_info *di; | |
408 | void *buf; | |
409 | lbasize_t *len_stor, *act_len_stor; | |
410 | lbastart_t *start; | |
411 | int *len_net, *act_len_net; | |
412 | ||
413 | /* 1. arg is ptr to the device_info struct */ | |
414 | di = (struct device_info *)va_arg(ap, u_int32_t); | |
415 | if (di == NULL) | |
416 | return API_EINVAL; | |
417 | ||
418 | /* XXX should we check if device is open? i.e. the ->state ? */ | |
419 | ||
420 | if (di->cookie == NULL) | |
421 | return API_ENODEV; | |
422 | ||
423 | /* 2. arg is ptr to buffer from where to put the read data */ | |
424 | buf = (void *)va_arg(ap, u_int32_t); | |
425 | if (buf == NULL) | |
426 | return API_EINVAL; | |
427 | ||
428 | if (di->type & DEV_TYP_STOR) { | |
429 | /* 3. arg - ptr to var with # of blocks to read */ | |
430 | len_stor = (lbasize_t *)va_arg(ap, u_int32_t); | |
431 | if (!len_stor) | |
432 | return API_EINVAL; | |
433 | if (*len_stor <= 0) | |
434 | return API_EINVAL; | |
435 | ||
436 | /* 4. arg - ptr to var with start block */ | |
437 | start = (lbastart_t *)va_arg(ap, u_int32_t); | |
438 | ||
439 | /* 5. arg - ptr to var where to put the len actually read */ | |
440 | act_len_stor = (lbasize_t *)va_arg(ap, u_int32_t); | |
441 | if (!act_len_stor) | |
442 | return API_EINVAL; | |
443 | ||
444 | *act_len_stor = dev_read_stor(di->cookie, buf, *len_stor, *start); | |
445 | ||
446 | } else if (di->type & DEV_TYP_NET) { | |
447 | ||
448 | /* 3. arg points to the var with length of packet to read */ | |
449 | len_net = (int *)va_arg(ap, u_int32_t); | |
450 | if (!len_net) | |
451 | return API_EINVAL; | |
452 | if (*len_net <= 0) | |
453 | return API_EINVAL; | |
454 | ||
455 | /* 4. - ptr to var where to put the len actually read */ | |
456 | act_len_net = (int *)va_arg(ap, u_int32_t); | |
457 | if (!act_len_net) | |
458 | return API_EINVAL; | |
459 | ||
460 | *act_len_net = dev_read_net(di->cookie, buf, *len_net); | |
461 | ||
462 | } else | |
463 | return API_ENODEV; | |
464 | ||
465 | return 0; | |
466 | } | |
467 | ||
468 | ||
469 | /* | |
470 | * pseudo signature: | |
471 | * | |
472 | * int API_env_get(const char *name, char **value) | |
473 | * | |
474 | * name: ptr to name of env var | |
475 | */ | |
476 | static int API_env_get(va_list ap) | |
477 | { | |
478 | char *name, **value; | |
479 | ||
480 | if ((name = (char *)va_arg(ap, u_int32_t)) == NULL) | |
481 | return API_EINVAL; | |
482 | if ((value = (char **)va_arg(ap, u_int32_t)) == NULL) | |
483 | return API_EINVAL; | |
484 | ||
485 | *value = getenv(name); | |
486 | ||
487 | return 0; | |
488 | } | |
489 | ||
490 | /* | |
491 | * pseudo signature: | |
492 | * | |
493 | * int API_env_set(const char *name, const char *value) | |
494 | * | |
495 | * name: ptr to name of env var | |
496 | * | |
497 | * value: ptr to value to be set | |
498 | */ | |
499 | static int API_env_set(va_list ap) | |
500 | { | |
501 | char *name, *value; | |
502 | ||
503 | if ((name = (char *)va_arg(ap, u_int32_t)) == NULL) | |
504 | return API_EINVAL; | |
505 | if ((value = (char *)va_arg(ap, u_int32_t)) == NULL) | |
506 | return API_EINVAL; | |
507 | ||
508 | setenv(name, value); | |
509 | ||
510 | return 0; | |
511 | } | |
512 | ||
513 | /* | |
514 | * pseudo signature: | |
515 | * | |
516 | * int API_env_enum(const char *last, char **next) | |
517 | * | |
518 | * last: ptr to name of env var found in last iteration | |
519 | */ | |
520 | static int API_env_enum(va_list ap) | |
521 | { | |
522 | int i, n; | |
523 | char *last, **next; | |
524 | ||
525 | last = (char *)va_arg(ap, u_int32_t); | |
526 | ||
527 | if ((next = (char **)va_arg(ap, u_int32_t)) == NULL) | |
528 | return API_EINVAL; | |
529 | ||
530 | if (last == NULL) | |
531 | /* start over */ | |
532 | *next = ((char *)env_get_addr(0)); | |
533 | else { | |
534 | *next = last; | |
535 | ||
536 | for (i = 0; env_get_char(i) != '\0'; i = n + 1) { | |
537 | for (n = i; env_get_char(n) != '\0'; ++n) { | |
538 | if (n >= CFG_ENV_SIZE) { | |
539 | /* XXX shouldn't we set *next = NULL?? */ | |
540 | return 0; | |
541 | } | |
542 | } | |
543 | ||
544 | if (envmatch((uchar *)last, i) < 0) | |
545 | continue; | |
546 | ||
547 | /* try to get next name */ | |
548 | i = n + 1; | |
549 | if (env_get_char(i) == '\0') { | |
550 | /* no more left */ | |
551 | *next = NULL; | |
552 | return 0; | |
553 | } | |
554 | ||
555 | *next = ((char *)env_get_addr(i)); | |
556 | return 0; | |
557 | } | |
558 | } | |
559 | ||
560 | return 0; | |
561 | } | |
562 | ||
563 | static cfp_t calls_table[API_MAXCALL] = { NULL, }; | |
564 | ||
565 | /* | |
566 | * The main syscall entry point - this is not reentrant, only one call is | |
567 | * serviced until finished. | |
568 | * | |
569 | * e.g. syscall(1, int *, u_int32_t, u_int32_t, u_int32_t, u_int32_t); | |
570 | * | |
571 | * call: syscall number | |
572 | * | |
573 | * retval: points to the return value placeholder, this is the place the | |
574 | * syscall puts its return value, if NULL the caller does not | |
575 | * expect a return value | |
576 | * | |
577 | * ... syscall arguments (variable number) | |
578 | * | |
579 | * returns: 0 if the call not found, 1 if serviced | |
580 | */ | |
581 | int syscall(int call, int *retval, ...) | |
582 | { | |
583 | va_list ap; | |
584 | int rv; | |
585 | ||
586 | if (call < 0 || call >= calls_no || calls_table[call] == NULL) { | |
587 | debugf("invalid call #%d\n", call); | |
588 | return 0; | |
589 | } | |
590 | ||
591 | if (calls_table[call] == NULL) { | |
592 | debugf("syscall #%d does not have a handler\n", call); | |
593 | return 0; | |
594 | } | |
595 | ||
596 | va_start(ap, retval); | |
597 | rv = calls_table[call](ap); | |
598 | if (retval != NULL) | |
599 | *retval = rv; | |
600 | ||
601 | return 1; | |
602 | } | |
603 | ||
604 | void api_init(void) | |
605 | { | |
606 | struct api_signature *sig = NULL; | |
607 | ||
608 | /* TODO put this into linker set one day... */ | |
609 | calls_table[API_RSVD] = NULL; | |
610 | calls_table[API_GETC] = &API_getc; | |
611 | calls_table[API_PUTC] = &API_putc; | |
612 | calls_table[API_TSTC] = &API_tstc; | |
613 | calls_table[API_PUTS] = &API_puts; | |
614 | calls_table[API_RESET] = &API_reset; | |
615 | calls_table[API_GET_SYS_INFO] = &API_get_sys_info; | |
616 | calls_table[API_UDELAY] = &API_udelay; | |
617 | calls_table[API_GET_TIMER] = &API_get_timer; | |
618 | calls_table[API_DEV_ENUM] = &API_dev_enum; | |
619 | calls_table[API_DEV_OPEN] = &API_dev_open; | |
620 | calls_table[API_DEV_CLOSE] = &API_dev_close; | |
621 | calls_table[API_DEV_READ] = &API_dev_read; | |
622 | calls_table[API_DEV_WRITE] = &API_dev_write; | |
623 | calls_table[API_ENV_GET] = &API_env_get; | |
624 | calls_table[API_ENV_SET] = &API_env_set; | |
625 | calls_table[API_ENV_ENUM] = &API_env_enum; | |
626 | calls_no = API_MAXCALL; | |
627 | ||
628 | debugf("API initialized with %d calls\n", calls_no); | |
629 | ||
630 | dev_stor_init(); | |
631 | ||
632 | /* | |
633 | * Produce the signature so the API consumers can find it | |
634 | */ | |
635 | sig = malloc(sizeof(struct api_signature)); | |
636 | if (sig == NULL) { | |
637 | printf("API: could not allocate memory for the signature!\n"); | |
638 | return; | |
639 | } | |
640 | ||
641 | debugf("API sig @ 0x%08x\n", sig); | |
642 | memcpy(sig->magic, API_SIG_MAGIC, 8); | |
643 | sig->version = API_SIG_VERSION; | |
644 | sig->syscall = &syscall; | |
645 | sig->checksum = 0; | |
646 | sig->checksum = crc32(0, (unsigned char *)sig, | |
647 | sizeof(struct api_signature)); | |
648 | debugf("syscall entry: 0x%08x\n", sig->syscall); | |
649 | } | |
650 | ||
651 | void platform_set_mr(struct sys_info *si, unsigned long start, unsigned long size, | |
652 | int flags) | |
653 | { | |
654 | int i; | |
655 | ||
656 | if (!si->mr || !size || (flags == 0)) | |
657 | return; | |
658 | ||
659 | /* find free slot */ | |
660 | for (i = 0; i < si->mr_no; i++) | |
661 | if (si->mr[i].flags == 0) { | |
662 | /* insert new mem region */ | |
663 | si->mr[i].start = start; | |
664 | si->mr[i].size = size; | |
665 | si->mr[i].flags = flags; | |
666 | return; | |
667 | } | |
668 | } | |
669 | ||
670 | #endif /* CONFIG_API */ |