]> git.sur5r.net Git - u-boot/blob - api/api.c
ARM: implement relocation for arm1176
[u-boot] / 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  */
25
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>
33
34 #include "api_private.h"
35
36 #define DEBUG
37 #undef DEBUG
38
39 /* U-Boot routines needed */
40 extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
41
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
62 typedef int (*cfp_t)(va_list argp);
63
64 static int calls_no;
65
66 /*
67  * pseudo signature:
68  *
69  * int API_getc(int *c)
70  */
71 static 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  */
87 static 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  */
103 static 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  */
119 static 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  */
135 static 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  */
151 static 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  */
167 static 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  */
183 static 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
217 static 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");
230
231                 /* 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
250 static 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
282 static 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  */
334 static 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)
364                 /*
365                  * 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  */
401 static 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  */
472 static 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  */
495 static 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  */
516 static 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);
522
523         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) {
534                                 if (n >= CONFIG_ENV_SIZE) {
535                                         /* XXX shouldn't we set *next = NULL?? */
536                                         return 0;
537                                 }
538                         }
539
540                         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
559 static 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);
566  *
567  * 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  */
577 int syscall(int call, int *retval, ...)
578 {
579         va_list ap;
580         int rv;
581
582         if (call < 0 || call >= calls_no) {
583                 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
600 void 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
647 void 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;
654
655         /* 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 }