HACK: ARM: DRA7xx: Add VPE crossbar setting
[glsdk/glsdk-u-boot.git] / api / api.c
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  */
26 #include <config.h>
27 #include <command.h>
28 #include <common.h>
29 #include <malloc.h>
30 #include <environment.h>
31 #include <linux/types.h>
32 #include <api_public.h>
34 #include "api_private.h"
36 #define DEBUG
37 #undef DEBUG
39 /*****************************************************************************
40  *
41  * This is the API core.
42  *
43  * API_ functions are part of U-Boot code and constitute the lowest level
44  * calls:
45  *
46  *  - they know what values they need as arguments
47  *  - their direct return value pertains to the API_ "shell" itself (0 on
48  *    success, some error code otherwise)
49  *  - if the call returns a value it is buried within arguments
50  *
51  ****************************************************************************/
53 #ifdef DEBUG
54 #define debugf(fmt, args...) do { printf("%s(): ", __func__); printf(fmt, ##args); } while (0)
55 #else
56 #define debugf(fmt, args...)
57 #endif
59 typedef int (*cfp_t)(va_list argp);
61 static int calls_no;
63 /*
64  * pseudo signature:
65  *
66  * int API_getc(int *c)
67  */
68 static int API_getc(va_list ap)
69 {
70         int *c;
72         if ((c = (int *)va_arg(ap, u_int32_t)) == NULL)
73                 return API_EINVAL;
75         *c = getc();
76         return 0;
77 }
79 /*
80  * pseudo signature:
81  *
82  * int API_tstc(int *c)
83  */
84 static int API_tstc(va_list ap)
85 {
86         int *t;
88         if ((t = (int *)va_arg(ap, u_int32_t)) == NULL)
89                 return API_EINVAL;
91         *t = tstc();
92         return 0;
93 }
95 /*
96  * pseudo signature:
97  *
98  * int API_putc(char *ch)
99  */
100 static int API_putc(va_list ap)
102         char *c;
104         if ((c = (char *)va_arg(ap, u_int32_t)) == NULL)
105                 return API_EINVAL;
107         putc(*c);
108         return 0;
111 /*
112  * pseudo signature:
113  *
114  * int API_puts(char **s)
115  */
116 static int API_puts(va_list ap)
118         char *s;
120         if ((s = (char *)va_arg(ap, u_int32_t)) == NULL)
121                 return API_EINVAL;
123         puts(s);
124         return 0;
127 /*
128  * pseudo signature:
129  *
130  * int API_reset(void)
131  */
132 static int API_reset(va_list ap)
134         do_reset(NULL, 0, 0, NULL);
136         /* NOT REACHED */
137         return 0;
140 /*
141  * pseudo signature:
142  *
143  * int API_get_sys_info(struct sys_info *si)
144  *
145  * fill out the sys_info struct containing selected parameters about the
146  * machine
147  */
148 static int API_get_sys_info(va_list ap)
150         struct sys_info *si;
152         si = (struct sys_info *)va_arg(ap, u_int32_t);
153         if (si == NULL)
154                 return API_ENOMEM;
156         return (platform_sys_info(si)) ? 0 : API_ENODEV;
159 /*
160  * pseudo signature:
161  *
162  * int API_udelay(unsigned long *udelay)
163  */
164 static int API_udelay(va_list ap)
166         unsigned long *d;
168         if ((d = (unsigned long *)va_arg(ap, u_int32_t)) == NULL)
169                 return API_EINVAL;
171         udelay(*d);
172         return 0;
175 /*
176  * pseudo signature:
177  *
178  * int API_get_timer(unsigned long *current, unsigned long *base)
179  */
180 static int API_get_timer(va_list ap)
182         unsigned long *base, *cur;
184         cur = (unsigned long *)va_arg(ap, u_int32_t);
185         if (cur == NULL)
186                 return API_EINVAL;
188         base = (unsigned long *)va_arg(ap, u_int32_t);
189         if (base == NULL)
190                 return API_EINVAL;
192         *cur = get_timer(*base);
193         return 0;
197 /*****************************************************************************
198  *
199  * pseudo signature:
200  *
201  * int API_dev_enum(struct device_info *)
202  *
203  *
204  * cookies uniqely identify the previously enumerated device instance and
205  * provide a hint for what to inspect in current enum iteration:
206  *
207  *   - net: &eth_device struct address from list pointed to by eth_devices
208  *
209  *   - storage: block_dev_desc_t struct address from &ide_dev_desc[n],
210  *     &scsi_dev_desc[n] and similar tables
211  *
212  ****************************************************************************/
214 static int API_dev_enum(va_list ap)
216         struct device_info *di;
218         /* arg is ptr to the device_info struct we are going to fill out */
219         di = (struct device_info *)va_arg(ap, u_int32_t);
220         if (di == NULL)
221                 return API_EINVAL;
223         if (di->cookie == NULL) {
224                 /* start over - clean up enumeration */
225                 dev_enum_reset();       /* XXX shouldn't the name contain 'stor'? */
226                 debugf("RESTART ENUM\n");
228                 /* net device enumeration first */
229                 if (dev_enum_net(di))
230                         return 0;
231         }
233         /*
234          * The hidden assumption is there can only be one active network
235          * device and it is identified upon enumeration (re)start, so there's
236          * no point in trying to find network devices in other cases than the
237          * (re)start and hence the 'next' device can only be storage
238          */
239         if (!dev_enum_storage(di))
240                 /* make sure we mark there are no more devices */
241                 di->cookie = NULL;
243         return 0;
247 static int API_dev_open(va_list ap)
249         struct device_info *di;
250         int err = 0;
252         /* arg is ptr to the device_info struct */
253         di = (struct device_info *)va_arg(ap, u_int32_t);
254         if (di == NULL)
255                 return API_EINVAL;
257         /* Allow only one consumer of the device at a time */
258         if (di->state == DEV_STA_OPEN)
259                 return API_EBUSY;
261         if (di->cookie == NULL)
262                 return API_ENODEV;
264         if (di->type & DEV_TYP_STOR)
265                 err = dev_open_stor(di->cookie);
267         else if (di->type & DEV_TYP_NET)
268                 err = dev_open_net(di->cookie);
269         else
270                 err = API_ENODEV;
272         if (!err)
273                 di->state = DEV_STA_OPEN;
275         return err;
279 static int API_dev_close(va_list ap)
281         struct device_info *di;
282         int err = 0;
284         /* arg is ptr to the device_info struct */
285         di = (struct device_info *)va_arg(ap, u_int32_t);
286         if (di == NULL)
287                 return API_EINVAL;
289         if (di->state == DEV_STA_CLOSED)
290                 return 0;
292         if (di->cookie == NULL)
293                 return API_ENODEV;
295         if (di->type & DEV_TYP_STOR)
296                 err = dev_close_stor(di->cookie);
298         else if (di->type & DEV_TYP_NET)
299                 err = dev_close_net(di->cookie);
300         else
301                 /*
302                  * In case of unknown device we cannot change its state, so
303                  * only return error code
304                  */
305                 err = API_ENODEV;
307         if (!err)
308                 di->state = DEV_STA_CLOSED;
310         return err;
314 /*
315  * Notice: this is for sending network packets only, as U-Boot does not
316  * support writing to storage at the moment (12.2007)
317  *
318  * pseudo signature:
319  *
320  * int API_dev_write(
321  *      struct device_info *di,
322  *      void *buf,
323  *      int *len
324  * )
325  *
326  * buf: ptr to buffer from where to get the data to send
327  *
328  * len: length of packet to be sent (in bytes)
329  *
330  */
331 static int API_dev_write(va_list ap)
333         struct device_info *di;
334         void *buf;
335         int *len;
336         int err = 0;
338         /* 1. arg is ptr to the device_info struct */
339         di = (struct device_info *)va_arg(ap, u_int32_t);
340         if (di == NULL)
341                 return API_EINVAL;
343         /* XXX should we check if device is open? i.e. the ->state ? */
345         if (di->cookie == NULL)
346                 return API_ENODEV;
348         /* 2. arg is ptr to buffer from where to get data to write */
349         buf = (void *)va_arg(ap, u_int32_t);
350         if (buf == NULL)
351                 return API_EINVAL;
353         /* 3. arg is length of buffer */
354         len = (int *)va_arg(ap, u_int32_t);
355         if (len == NULL)
356                 return API_EINVAL;
357         if (*len <= 0)
358                 return API_EINVAL;
360         if (di->type & DEV_TYP_STOR)
361                 /*
362                  * write to storage is currently not supported by U-Boot:
363                  * no storage device implements block_write() method
364                  */
365                 return API_ENODEV;
367         else if (di->type & DEV_TYP_NET)
368                 err = dev_write_net(di->cookie, buf, *len);
369         else
370                 err = API_ENODEV;
372         return err;
376 /*
377  * pseudo signature:
378  *
379  * int API_dev_read(
380  *      struct device_info *di,
381  *      void *buf,
382  *      size_t *len,
383  *      unsigned long *start
384  *      size_t *act_len
385  * )
386  *
387  * buf: ptr to buffer where to put the read data
388  *
389  * len: ptr to length to be read
390  *      - network: len of packet to read (in bytes)
391  *      - storage: # of blocks to read (can vary in size depending on define)
392  *
393  * start: ptr to start block (only used for storage devices, ignored for
394  *        network)
395  *
396  * act_len: ptr to where to put the len actually read
397  */
398 static int API_dev_read(va_list ap)
400         struct device_info *di;
401         void *buf;
402         lbasize_t *len_stor, *act_len_stor;
403         lbastart_t *start;
404         int *len_net, *act_len_net;
406         /* 1. arg is ptr to the device_info struct */
407         di = (struct device_info *)va_arg(ap, u_int32_t);
408         if (di == NULL)
409                 return API_EINVAL;
411         /* XXX should we check if device is open? i.e. the ->state ? */
413         if (di->cookie == NULL)
414                 return API_ENODEV;
416         /* 2. arg is ptr to buffer from where to put the read data */
417         buf = (void *)va_arg(ap, u_int32_t);
418         if (buf == NULL)
419                 return API_EINVAL;
421         if (di->type & DEV_TYP_STOR) {
422                 /* 3. arg - ptr to var with # of blocks to read */
423                 len_stor = (lbasize_t *)va_arg(ap, u_int32_t);
424                 if (!len_stor)
425                         return API_EINVAL;
426                 if (*len_stor <= 0)
427                         return API_EINVAL;
429                 /* 4. arg - ptr to var with start block */
430                 start = (lbastart_t *)va_arg(ap, u_int32_t);
432                 /* 5. arg - ptr to var where to put the len actually read */
433                 act_len_stor = (lbasize_t *)va_arg(ap, u_int32_t);
434                 if (!act_len_stor)
435                         return API_EINVAL;
437                 *act_len_stor = dev_read_stor(di->cookie, buf, *len_stor, *start);
439         } else if (di->type & DEV_TYP_NET) {
441                 /* 3. arg points to the var with length of packet to read */
442                 len_net = (int *)va_arg(ap, u_int32_t);
443                 if (!len_net)
444                         return API_EINVAL;
445                 if (*len_net <= 0)
446                         return API_EINVAL;
448                 /* 4. - ptr to var where to put the len actually read */
449                 act_len_net = (int *)va_arg(ap, u_int32_t);
450                 if (!act_len_net)
451                         return API_EINVAL;
453                 *act_len_net = dev_read_net(di->cookie, buf, *len_net);
455         } else
456                 return API_ENODEV;
458         return 0;
462 /*
463  * pseudo signature:
464  *
465  * int API_env_get(const char *name, char **value)
466  *
467  * name: ptr to name of env var
468  */
469 static int API_env_get(va_list ap)
471         char *name, **value;
473         if ((name = (char *)va_arg(ap, u_int32_t)) == NULL)
474                 return API_EINVAL;
475         if ((value = (char **)va_arg(ap, u_int32_t)) == NULL)
476                 return API_EINVAL;
478         *value = getenv(name);
480         return 0;
483 /*
484  * pseudo signature:
485  *
486  * int API_env_set(const char *name, const char *value)
487  *
488  * name: ptr to name of env var
489  *
490  * value: ptr to value to be set
491  */
492 static int API_env_set(va_list ap)
494         char *name, *value;
496         if ((name = (char *)va_arg(ap, u_int32_t)) == NULL)
497                 return API_EINVAL;
498         if ((value = (char *)va_arg(ap, u_int32_t)) == NULL)
499                 return API_EINVAL;
501         setenv(name, value);
503         return 0;
506 /*
507  * pseudo signature:
508  *
509  * int API_env_enum(const char *last, char **next)
510  *
511  * last: ptr to name of env var found in last iteration
512  */
513 static int API_env_enum(va_list ap)
515         int i, n;
516         char *last, **next;
518         last = (char *)va_arg(ap, u_int32_t);
520         if ((next = (char **)va_arg(ap, u_int32_t)) == NULL)
521                 return API_EINVAL;
523         if (last == NULL)
524                 /* start over */
525                 *next = ((char *)env_get_addr(0));
526         else {
527                 *next = last;
529                 for (i = 0; env_get_char(i) != '\0'; i = n + 1) {
530                         for (n = i; env_get_char(n) != '\0'; ++n) {
531                                 if (n >= CONFIG_ENV_SIZE) {
532                                         /* XXX shouldn't we set *next = NULL?? */
533                                         return 0;
534                                 }
535                         }
537                         if (envmatch((uchar *)last, i) < 0)
538                                 continue;
540                         /* try to get next name */
541                         i = n + 1;
542                         if (env_get_char(i) == '\0') {
543                                 /* no more left */
544                                 *next = NULL;
545                                 return 0;
546                         }
548                         *next = ((char *)env_get_addr(i));
549                         return 0;
550                 }
551         }
553         return 0;
556 /*
557  * pseudo signature:
558  *
559  * int API_display_get_info(int type, struct display_info *di)
560  */
561 static int API_display_get_info(va_list ap)
563         int type;
564         struct display_info *di;
566         type = va_arg(ap, int);
567         di = va_arg(ap, struct display_info *);
569         return display_get_info(type, di);
572 /*
573  * pseudo signature:
574  *
575  * int API_display_draw_bitmap(ulong bitmap, int x, int y)
576  */
577 static int API_display_draw_bitmap(va_list ap)
579         ulong bitmap;
580         int x, y;
582         bitmap = va_arg(ap, ulong);
583         x = va_arg(ap, int);
584         y = va_arg(ap, int);
586         return display_draw_bitmap(bitmap, x, y);
589 /*
590  * pseudo signature:
591  *
592  * void API_display_clear(void)
593  */
594 static int API_display_clear(va_list ap)
596         display_clear();
597         return 0;
600 static cfp_t calls_table[API_MAXCALL] = { NULL, };
602 /*
603  * The main syscall entry point - this is not reentrant, only one call is
604  * serviced until finished.
605  *
606  * e.g. syscall(1, int *, u_int32_t, u_int32_t, u_int32_t, u_int32_t);
607  *
608  * call:        syscall number
609  *
610  * retval:      points to the return value placeholder, this is the place the
611  *              syscall puts its return value, if NULL the caller does not
612  *              expect a return value
613  *
614  * ...          syscall arguments (variable number)
615  *
616  * returns:     0 if the call not found, 1 if serviced
617  */
618 int syscall(int call, int *retval, ...)
620         va_list ap;
621         int rv;
623         if (call < 0 || call >= calls_no) {
624                 debugf("invalid call #%d\n", call);
625                 return 0;
626         }
628         if (calls_table[call] == NULL) {
629                 debugf("syscall #%d does not have a handler\n", call);
630                 return 0;
631         }
633         va_start(ap, retval);
634         rv = calls_table[call](ap);
635         if (retval != NULL)
636                 *retval = rv;
638         return 1;
641 void api_init(void)
643         struct api_signature *sig = NULL;
645         /* TODO put this into linker set one day... */
646         calls_table[API_RSVD] = NULL;
647         calls_table[API_GETC] = &API_getc;
648         calls_table[API_PUTC] = &API_putc;
649         calls_table[API_TSTC] = &API_tstc;
650         calls_table[API_PUTS] = &API_puts;
651         calls_table[API_RESET] = &API_reset;
652         calls_table[API_GET_SYS_INFO] = &API_get_sys_info;
653         calls_table[API_UDELAY] = &API_udelay;
654         calls_table[API_GET_TIMER] = &API_get_timer;
655         calls_table[API_DEV_ENUM] = &API_dev_enum;
656         calls_table[API_DEV_OPEN] = &API_dev_open;
657         calls_table[API_DEV_CLOSE] = &API_dev_close;
658         calls_table[API_DEV_READ] = &API_dev_read;
659         calls_table[API_DEV_WRITE] = &API_dev_write;
660         calls_table[API_ENV_GET] = &API_env_get;
661         calls_table[API_ENV_SET] = &API_env_set;
662         calls_table[API_ENV_ENUM] = &API_env_enum;
663         calls_table[API_DISPLAY_GET_INFO] = &API_display_get_info;
664         calls_table[API_DISPLAY_DRAW_BITMAP] = &API_display_draw_bitmap;
665         calls_table[API_DISPLAY_CLEAR] = &API_display_clear;
666         calls_no = API_MAXCALL;
668         debugf("API initialized with %d calls\n", calls_no);
670         dev_stor_init();
672         /*
673          * Produce the signature so the API consumers can find it
674          */
675         sig = malloc(sizeof(struct api_signature));
676         if (sig == NULL) {
677                 printf("API: could not allocate memory for the signature!\n");
678                 return;
679         }
681         debugf("API sig @ 0x%08x\n", sig);
682         memcpy(sig->magic, API_SIG_MAGIC, 8);
683         sig->version = API_SIG_VERSION;
684         sig->syscall = &syscall;
685         sig->checksum = 0;
686         sig->checksum = crc32(0, (unsigned char *)sig,
687                               sizeof(struct api_signature));
688         debugf("syscall entry: 0x%08x\n", sig->syscall);
691 void platform_set_mr(struct sys_info *si, unsigned long start, unsigned long size,
692                         int flags)
694         int i;
696         if (!si->mr || !size || (flags == 0))
697                 return;
699         /* find free slot */
700         for (i = 0; i < si->mr_no; i++)
701                 if (si->mr[i].flags == 0) {
702                         /* insert new mem region */
703                         si->mr[i].start = start;
704                         si->mr[i].size = size;
705                         si->mr[i].flags = flags;
706                         return;
707                 }