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