[J-u-boot.git] / api / api.c

/*
 * (C) Copyright 2007 Semihalf
 *
 * Written by: Rafal Jaworowski <[email protected]>
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 *
 */

#include <config.h>
#include <command.h>
#include <common.h>
#include <malloc.h>
#include <environment.h>
#include <linux/types.h>
#include <api_public.h>

#include "api_private.h"

#define DEBUG
#undef DEBUG

/*****************************************************************************
 *
 * This is the API core.
 *
 * API_ functions are part of U-Boot code and constitute the lowest level
 * calls:
 *
 *  - they know what values they need as arguments
 *  - their direct return value pertains to the API_ "shell" itself (0 on
 *    success, some error code otherwise)
 *  - if the call returns a value it is buried within arguments
 *
 ****************************************************************************/

#ifdef DEBUG
#define debugf(fmt, args...) do { printf("%s(): ", __func__); printf(fmt, ##args); } while (0)
#else
#define debugf(fmt, args...)
#endif

typedef	int (*cfp_t)(va_list argp);

static int calls_no;

/*
 * pseudo signature:
 *
 * int API_getc(int *c)
 */
static int API_getc(va_list ap)
{
	int *c;

	if ((c = (int *)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;

	*c = getc();
	return 0;
}

/*
 * pseudo signature:
 *
 * int API_tstc(int *c)
 */
static int API_tstc(va_list ap)
{
	int *t;

	if ((t = (int *)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;

	*t = tstc();
	return 0;
}

/*
 * pseudo signature:
 *
 * int API_putc(char *ch)
 */
static int API_putc(va_list ap)
{
	char *c;

	if ((c = (char *)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;

	putc(*c);
	return 0;
}

/*
 * pseudo signature:
 *
 * int API_puts(char **s)
 */
static int API_puts(va_list ap)
{
	char *s;

	if ((s = (char *)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;

	puts(s);
	return 0;
}

/*
 * pseudo signature:
 *
 * int API_reset(void)
 */
static int API_reset(va_list ap)
{
	do_reset(NULL, 0, 0, NULL);

	/* NOT REACHED */
	return 0;
}

/*
 * pseudo signature:
 *
 * int API_get_sys_info(struct sys_info *si)
 *
 * fill out the sys_info struct containing selected parameters about the
 * machine
 */
static int API_get_sys_info(va_list ap)
{
	struct sys_info *si;

	si = (struct sys_info *)va_arg(ap, u_int32_t);
	if (si == NULL)
		return API_ENOMEM;

	return (platform_sys_info(si)) ? 0 : API_ENODEV;
}

/*
 * pseudo signature:
 *
 * int API_udelay(unsigned long *udelay)
 */
static int API_udelay(va_list ap)
{
	unsigned long *d;

	if ((d = (unsigned long *)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;

	udelay(*d);
	return 0;
}

/*
 * pseudo signature:
 *
 * int API_get_timer(unsigned long *current, unsigned long *base)
 */
static int API_get_timer(va_list ap)
{
	unsigned long *base, *cur;

	cur = (unsigned long *)va_arg(ap, u_int32_t);
	if (cur == NULL)
		return API_EINVAL;

	base = (unsigned long *)va_arg(ap, u_int32_t);
	if (base == NULL)
		return API_EINVAL;

	*cur = get_timer(*base);
	return 0;
}


/*****************************************************************************
 *
 * pseudo signature:
 *
 * int API_dev_enum(struct device_info *)
 *
 *
 * cookies uniqely identify the previously enumerated device instance and
 * provide a hint for what to inspect in current enum iteration:
 *
 *   - net: &eth_device struct address from list pointed to by eth_devices
 *
 *   - storage: block_dev_desc_t struct address from &ide_dev_desc[n],
 *     &scsi_dev_desc[n] and similar tables
 *
 ****************************************************************************/

static int API_dev_enum(va_list ap)
{
	struct device_info *di;

	/* arg is ptr to the device_info struct we are going to fill out */
	di = (struct device_info *)va_arg(ap, u_int32_t);
	if (di == NULL)
		return API_EINVAL;

	if (di->cookie == NULL) {
		/* start over - clean up enumeration */
		dev_enum_reset();	/* XXX shouldn't the name contain 'stor'? */
		debugf("RESTART ENUM\n");

		/* net device enumeration first */
		if (dev_enum_net(di))
			return 0;
	}

	/*
	 * The hidden assumption is there can only be one active network
	 * device and it is identified upon enumeration (re)start, so there's
	 * no point in trying to find network devices in other cases than the
	 * (re)start and hence the 'next' device can only be storage
	 */
	if (!dev_enum_storage(di))
		/* make sure we mark there are no more devices */
		di->cookie = NULL;

	return 0;
}


static int API_dev_open(va_list ap)
{
	struct device_info *di;
	int err = 0;

	/* arg is ptr to the device_info struct */
	di = (struct device_info *)va_arg(ap, u_int32_t);
	if (di == NULL)
		return API_EINVAL;

	/* Allow only one consumer of the device at a time */
	if (di->state == DEV_STA_OPEN)
		return API_EBUSY;

	if (di->cookie == NULL)
		return API_ENODEV;

	if (di->type & DEV_TYP_STOR)
		err = dev_open_stor(di->cookie);

	else if (di->type & DEV_TYP_NET)
		err = dev_open_net(di->cookie);
	else
		err = API_ENODEV;

	if (!err)
		di->state = DEV_STA_OPEN;

	return err;
}


static int API_dev_close(va_list ap)
{
	struct device_info *di;
	int err = 0;

	/* arg is ptr to the device_info struct */
	di = (struct device_info *)va_arg(ap, u_int32_t);
	if (di == NULL)
		return API_EINVAL;

	if (di->state == DEV_STA_CLOSED)
		return 0;

	if (di->cookie == NULL)
		return API_ENODEV;

	if (di->type & DEV_TYP_STOR)
		err = dev_close_stor(di->cookie);

	else if (di->type & DEV_TYP_NET)
		err = dev_close_net(di->cookie);
	else
		/*
		 * In case of unknown device we cannot change its state, so
		 * only return error code
		 */
		err = API_ENODEV;

	if (!err)
		di->state = DEV_STA_CLOSED;

	return err;
}


/*
 * Notice: this is for sending network packets only, as U-Boot does not
 * support writing to storage at the moment (12.2007)
 *
 * pseudo signature:
 *
 * int API_dev_write(
 *	struct device_info *di,
 *	void *buf,
 *	int *len
 * )
 *
 * buf:	ptr to buffer from where to get the data to send
 *
 * len: length of packet to be sent (in bytes)
 *
 */
static int API_dev_write(va_list ap)
{
	struct device_info *di;
	void *buf;
	int *len;
	int err = 0;

	/* 1. arg is ptr to the device_info struct */
	di = (struct device_info *)va_arg(ap, u_int32_t);
	if (di == NULL)
		return API_EINVAL;

	/* XXX should we check if device is open? i.e. the ->state ? */

	if (di->cookie == NULL)
		return API_ENODEV;

	/* 2. arg is ptr to buffer from where to get data to write */
	buf = (void *)va_arg(ap, u_int32_t);
	if (buf == NULL)
		return API_EINVAL;

	/* 3. arg is length of buffer */
	len = (int *)va_arg(ap, u_int32_t);
	if (len == NULL)
		return API_EINVAL;
	if (*len <= 0)
		return API_EINVAL;

	if (di->type & DEV_TYP_STOR)
		/*
		 * write to storage is currently not supported by U-Boot:
		 * no storage device implements block_write() method
		 */
		return API_ENODEV;

	else if (di->type & DEV_TYP_NET)
		err = dev_write_net(di->cookie, buf, *len);
	else
		err = API_ENODEV;

	return err;
}


/*
 * pseudo signature:
 *
 * int API_dev_read(
 *	struct device_info *di,
 *	void *buf,
 *	size_t *len,
 *	unsigned long *start
 *	size_t *act_len
 * )
 *
 * buf:	ptr to buffer where to put the read data
 *
 * len: ptr to length to be read
 *      - network: len of packet to read (in bytes)
 *      - storage: # of blocks to read (can vary in size depending on define)
 *
 * start: ptr to start block (only used for storage devices, ignored for
 *        network)
 *
 * act_len: ptr to where to put the len actually read
 */
static int API_dev_read(va_list ap)
{
	struct device_info *di;
	void *buf;
	lbasize_t *len_stor, *act_len_stor;
	lbastart_t *start;
	int *len_net, *act_len_net;

	/* 1. arg is ptr to the device_info struct */
	di = (struct device_info *)va_arg(ap, u_int32_t);
	if (di == NULL)
		return API_EINVAL;

	/* XXX should we check if device is open? i.e. the ->state ? */

	if (di->cookie == NULL)
		return API_ENODEV;

	/* 2. arg is ptr to buffer from where to put the read data */
	buf = (void *)va_arg(ap, u_int32_t);
	if (buf == NULL)
		return API_EINVAL;

	if (di->type & DEV_TYP_STOR) {
		/* 3. arg - ptr to var with # of blocks to read */
		len_stor = (lbasize_t *)va_arg(ap, u_int32_t);
		if (!len_stor)
			return API_EINVAL;
		if (*len_stor <= 0)
			return API_EINVAL;

		/* 4. arg - ptr to var with start block */
		start = (lbastart_t *)va_arg(ap, u_int32_t);

		/* 5. arg - ptr to var where to put the len actually read */
		act_len_stor = (lbasize_t *)va_arg(ap, u_int32_t);
		if (!act_len_stor)
			return API_EINVAL;

		*act_len_stor = dev_read_stor(di->cookie, buf, *len_stor, *start);

	} else if (di->type & DEV_TYP_NET) {

		/* 3. arg points to the var with length of packet to read */
		len_net = (int *)va_arg(ap, u_int32_t);
		if (!len_net)
			return API_EINVAL;
		if (*len_net <= 0)
			return API_EINVAL;

		/* 4. - ptr to var where to put the len actually read */
		act_len_net = (int *)va_arg(ap, u_int32_t);
		if (!act_len_net)
			return API_EINVAL;

		*act_len_net = dev_read_net(di->cookie, buf, *len_net);

	} else
		return API_ENODEV;

	return 0;
}


/*
 * pseudo signature:
 *
 * int API_env_get(const char *name, char **value)
 *
 * name: ptr to name of env var
 */
static int API_env_get(va_list ap)
{
	char *name, **value;

	if ((name = (char *)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;
	if ((value = (char **)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;

	*value = getenv(name);

	return 0;
}

/*
 * pseudo signature:
 *
 * int API_env_set(const char *name, const char *value)
 *
 * name: ptr to name of env var
 *
 * value: ptr to value to be set
 */
static int API_env_set(va_list ap)
{
	char *name, *value;

	if ((name = (char *)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;
	if ((value = (char *)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;

	setenv(name, value);

	return 0;
}

/*
 * pseudo signature:
 *
 * int API_env_enum(const char *last, char **next)
 *
 * last: ptr to name of env var found in last iteration
 */
static int API_env_enum(va_list ap)
{
	int i, n;
	char *last, **next;

	last = (char *)va_arg(ap, u_int32_t);

	if ((next = (char **)va_arg(ap, u_int32_t)) == NULL)
		return API_EINVAL;

	if (last == NULL)
		/* start over */
		*next = ((char *)env_get_addr(0));
	else {
		*next = last;

		for (i = 0; env_get_char(i) != '\0'; i = n + 1) {
			for (n = i; env_get_char(n) != '\0'; ++n) {
				if (n >= CONFIG_ENV_SIZE) {
					/* XXX shouldn't we set *next = NULL?? */
					return 0;
				}
			}

			if (envmatch((uchar *)last, i) < 0)
				continue;

			/* try to get next name */
			i = n + 1;
			if (env_get_char(i) == '\0') {
				/* no more left */
				*next = NULL;
				return 0;
			}

			*next = ((char *)env_get_addr(i));
			return 0;
		}
	}

	return 0;
}

/*
 * pseudo signature:
 *
 * int API_display_get_info(int type, struct display_info *di)
 */
static int API_display_get_info(va_list ap)
{
	int type;
	struct display_info *di;

	type = va_arg(ap, int);
	di = va_arg(ap, struct display_info *);

	return display_get_info(type, di);
}

/*
 * pseudo signature:
 *
 * int API_display_draw_bitmap(ulong bitmap, int x, int y)
 */
static int API_display_draw_bitmap(va_list ap)
{
	ulong bitmap;
	int x, y;

	bitmap = va_arg(ap, ulong);
	x = va_arg(ap, int);
	y = va_arg(ap, int);

	return display_draw_bitmap(bitmap, x, y);
}

/*
 * pseudo signature:
 *
 * void API_display_clear(void)
 */
static int API_display_clear(va_list ap)
{
	display_clear();
	return 0;
}

static cfp_t calls_table[API_MAXCALL] = { NULL, };

/*
 * The main syscall entry point - this is not reentrant, only one call is
 * serviced until finished.
 *
 * e.g. syscall(1, int *, u_int32_t, u_int32_t, u_int32_t, u_int32_t);
 *
 * call:	syscall number
 *
 * retval:	points to the return value placeholder, this is the place the
 *		syscall puts its return value, if NULL the caller does not
 *		expect a return value
 *
 * ...		syscall arguments (variable number)
 *
 * returns:	0 if the call not found, 1 if serviced
 */
int syscall(int call, int *retval, ...)
{
	va_list	ap;
	int rv;

	if (call < 0 || call >= calls_no) {
		debugf("invalid call #%d\n", call);
		return 0;
	}

	if (calls_table[call] == NULL) {
		debugf("syscall #%d does not have a handler\n", call);
		return 0;
	}

	va_start(ap, retval);
	rv = calls_table[call](ap);
	if (retval != NULL)
		*retval = rv;

	return 1;
}

void api_init(void)
{
	struct api_signature *sig = NULL;

	/* TODO put this into linker set one day... */
	calls_table[API_RSVD] = NULL;
	calls_table[API_GETC] = &API_getc;
	calls_table[API_PUTC] = &API_putc;
	calls_table[API_TSTC] = &API_tstc;
	calls_table[API_PUTS] = &API_puts;
	calls_table[API_RESET] = &API_reset;
	calls_table[API_GET_SYS_INFO] = &API_get_sys_info;
	calls_table[API_UDELAY] = &API_udelay;
	calls_table[API_GET_TIMER] = &API_get_timer;
	calls_table[API_DEV_ENUM] = &API_dev_enum;
	calls_table[API_DEV_OPEN] = &API_dev_open;
	calls_table[API_DEV_CLOSE] = &API_dev_close;
	calls_table[API_DEV_READ] = &API_dev_read;
	calls_table[API_DEV_WRITE] = &API_dev_write;
	calls_table[API_ENV_GET] = &API_env_get;
	calls_table[API_ENV_SET] = &API_env_set;
	calls_table[API_ENV_ENUM] = &API_env_enum;
	calls_table[API_DISPLAY_GET_INFO] = &API_display_get_info;
	calls_table[API_DISPLAY_DRAW_BITMAP] = &API_display_draw_bitmap;
	calls_table[API_DISPLAY_CLEAR] = &API_display_clear;
	calls_no = API_MAXCALL;

	debugf("API initialized with %d calls\n", calls_no);

	dev_stor_init();

	/*
	 * Produce the signature so the API consumers can find it
	 */
	sig = malloc(sizeof(struct api_signature));
	if (sig == NULL) {
		printf("API: could not allocate memory for the signature!\n");
		return;
	}

	debugf("API sig @ 0x%08x\n", sig);
	memcpy(sig->magic, API_SIG_MAGIC, 8);
	sig->version = API_SIG_VERSION;
	sig->syscall = &syscall;
	sig->checksum = 0;
	sig->checksum = crc32(0, (unsigned char *)sig,
			      sizeof(struct api_signature));
	debugf("syscall entry: 0x%08x\n", sig->syscall);
}

void platform_set_mr(struct sys_info *si, unsigned long start, unsigned long size,
			int flags)
{
	int i;

	if (!si->mr || !size || (flags == 0))
		return;

	/* find free slot */
	for (i = 0; i < si->mr_no; i++)
		if (si->mr[i].flags == 0) {
			/* insert new mem region */
			si->mr[i].start = start;
			si->mr[i].size = size;
			si->mr[i].flags = flags;
			return;
		}
}
Commit	Line	Data
500856eb RJ	1	/*
	2	* (C) Copyright 2007 Semihalf
	3	*
	4	* Written by: Rafal Jaworowski <[email protected]>
	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>
500856eb RJ	27	#include <command.h>
	28	#include <common.h>
	29	#include <malloc.h>
a8409f4f	30	#include <environment.h>
500856eb RJ	31	#include <linux/types.h>
	32	#include <api_public.h>
	33
	34	#include "api_private.h"
	35
	36	#define DEBUG
	37	#undef DEBUG
	38
500856eb RJ	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	****************************************************************************/
	52
	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
	58
	59	typedef int (*cfp_t)(va_list argp);
	60
	61	static int calls_no;
	62
	63	/*
	64	* pseudo signature:
	65	*
	66	* int API_getc(int *c)
	67	*/
	68	static int API_getc(va_list ap)
	69	{
	70	int *c;
	71
	72	if ((c = (int *)va_arg(ap, u_int32_t)) == NULL)
	73	return API_EINVAL;
	74
	75	*c = getc();
	76	return 0;
	77	}
	78
	79	/*
	80	* pseudo signature:
	81	*
	82	* int API_tstc(int *c)
	83	*/
	84	static int API_tstc(va_list ap)
	85	{
	86	int *t;
	87
	88	if ((t = (int *)va_arg(ap, u_int32_t)) == NULL)
	89	return API_EINVAL;
	90
	91	*t = tstc();
	92	return 0;
	93	}
	94
	95	/*
	96	* pseudo signature:
	97	*
	98	* int API_putc(char *ch)
	99	*/
	100	static int API_putc(va_list ap)
	101	{
	102	char *c;
103
104	if ((c = (char *)va_arg(ap, u_int32_t)) == NULL)
105	return API_EINVAL;
106
107	putc(*c);
108	return 0;
109	}
110
111	/*
112	* pseudo signature:
113	*
114	* int API_puts(char **s)
115	*/
116	static int API_puts(va_list ap)
117	{
118	char *s;
119
120	if ((s = (char *)va_arg(ap, u_int32_t)) == NULL)
121	return API_EINVAL;
122
123	puts(s);
124	return 0;
125	}
126
127	/*
128	* pseudo signature:
129	*
130	* int API_reset(void)
131	*/
132	static int API_reset(va_list ap)
133	{
134	do_reset(NULL, 0, 0, NULL);
135
136	/* NOT REACHED */
137	return 0;
138	}
139
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)
149	{
150	struct sys_info *si;
151
152	si = (struct sys_info *)va_arg(ap, u_int32_t);
153	if (si == NULL)
154	return API_ENOMEM;
155
156	return (platform_sys_info(si)) ? 0 : API_ENODEV;
157	}
158
159	/*
160	* pseudo signature:
161	*
162	* int API_udelay(unsigned long *udelay)
163	*/
164	static int API_udelay(va_list ap)
165	{
166	unsigned long *d;
167
168	if ((d = (unsigned long *)va_arg(ap, u_int32_t)) == NULL)
169	return API_EINVAL;
170
171	udelay(*d);
172	return 0;
173	}
174
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)
181	{
182	unsigned long base, cur;
183
184	cur = (unsigned long *)va_arg(ap, u_int32_t);
185	if (cur == NULL)
186	return API_EINVAL;
187
188	base = (unsigned long *)va_arg(ap, u_int32_t);
189	if (base == NULL)
190	return API_EINVAL;
191
192	cur = get_timer(base);
193	return 0;
194	}
195
196
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	****************************************************************************/
213
214	static int API_dev_enum(va_list ap)
215	{
216	struct device_info *di;
217
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;
222
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");
d3a6532c	227
500856eb RJ	228	/* net device enumeration first */
	229	if (dev_enum_net(di))
	230	return 0;
	231	}
	232
	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;
	242
	243	return 0;
	244	}
	245
	246
	247	static int API_dev_open(va_list ap)
	248	{
	249	struct device_info *di;
	250	int err = 0;
	251
	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;
	256
	257	/* Allow only one consumer of the device at a time */
	258	if (di->state == DEV_STA_OPEN)
	259	return API_EBUSY;
	260
	261	if (di->cookie == NULL)
	262	return API_ENODEV;
	263
	264	if (di->type & DEV_TYP_STOR)
	265	err = dev_open_stor(di->cookie);
	266
	267	else if (di->type & DEV_TYP_NET)
	268	err = dev_open_net(di->cookie);
	269	else
	270	err = API_ENODEV;
	271
	272	if (!err)
	273	di->state = DEV_STA_OPEN;
	274
	275	return err;
	276	}
	277
	278
	279	static int API_dev_close(va_list ap)
	280	{
	281	struct device_info *di;
	282	int err = 0;
	283
	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;
	288
	289	if (di->state == DEV_STA_CLOSED)
	290	return 0;
	291
292	if (di->cookie == NULL)
293	return API_ENODEV;
294
295	if (di->type & DEV_TYP_STOR)
296	err = dev_close_stor(di->cookie);
297
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;
306
307	if (!err)
308	di->state = DEV_STA_CLOSED;
309
310	return err;
311	}
312
313
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)
332	{
333	struct device_info *di;
334	void *buf;
335	int *len;
336	int err = 0;
337
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;
342
343	/* XXX should we check if device is open? i.e. the ->state ? */
344
345	if (di->cookie == NULL)
346	return API_ENODEV;
347
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;
352
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;
359
360	if (di->type & DEV_TYP_STOR)
d3a6532c	361	/*
500856eb RJ	362	* write to storage is currently not supported by U-Boot:
	363	* no storage device implements block_write() method
	364	*/
	365	return API_ENODEV;
	366
	367	else if (di->type & DEV_TYP_NET)
	368	err = dev_write_net(di->cookie, buf, *len);
	369	else
	370	err = API_ENODEV;
	371
	372	return err;
	373	}
	374
	375
	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)
	399	{
	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;
	405
	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;
	410
	411	/* XXX should we check if device is open? i.e. the ->state ? */
	412
	413	if (di->cookie == NULL)
	414	return API_ENODEV;
	415
	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;
	420
	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;
428
429	/* 4. arg - ptr to var with start block */
430	start = (lbastart_t *)va_arg(ap, u_int32_t);
431
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;
436
437	act_len_stor = dev_read_stor(di->cookie, buf, len_stor, *start);
438
439	} else if (di->type & DEV_TYP_NET) {
440
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;
447
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;
452
453	act_len_net = dev_read_net(di->cookie, buf, len_net);
454
455	} else
456	return API_ENODEV;
457
458	return 0;
459	}
460
461
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)
470	{
471	char name, *value;
472
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;
477
478	*value = getenv(name);
479
480	return 0;
481	}
482
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)
493	{
494	char name, value;
495
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;
500
501	setenv(name, value);
502
503	return 0;
504	}
505
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)
514	{
515	int i, n;
516	char last, *next;
517
518	last = (char *)va_arg(ap, u_int32_t);
d3a6532c	519
500856eb RJ	520	if ((next = (char **)va_arg(ap, u_int32_t)) == NULL)
	521	return API_EINVAL;
	522
	523	if (last == NULL)
	524	/* start over */
	525	next = ((char )env_get_addr(0));
	526	else {
	527	*next = last;
	528
	529	for (i = 0; env_get_char(i) != '\0'; i = n + 1) {
	530	for (n = i; env_get_char(n) != '\0'; ++n) {
0e8d1586	531	if (n >= CONFIG_ENV_SIZE) {
500856eb RJ	532	/* XXX shouldn't we set next = NULL?? /
	533	return 0;
	534	}
	535	}
d3a6532c	536
500856eb RJ	537	if (envmatch((uchar *)last, i) < 0)
	538	continue;
	539
	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	}
	547
	548	next = ((char )env_get_addr(i));
	549	return 0;
	550	}
	551	}
	552
	553	return 0;
	554	}
	555
a2a5729f CLC	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)
	562	{
	563	int type;
	564	struct display_info *di;
	565
	566	type = va_arg(ap, int);
	567	di = va_arg(ap, struct display_info *);
	568
	569	return display_get_info(type, di);
	570	}
	571
	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)
	578	{
	579	ulong bitmap;
	580	int x, y;
	581
	582	bitmap = va_arg(ap, ulong);
	583	x = va_arg(ap, int);
	584	y = va_arg(ap, int);
	585
	586	return display_draw_bitmap(bitmap, x, y);
	587	}
	588
	589	/*
	590	* pseudo signature:
	591	*
	592	* void API_display_clear(void)
	593	*/
	594	static int API_display_clear(va_list ap)
	595	{
	596	display_clear();
	597	return 0;
	598	}
	599
500856eb RJ	600	static cfp_t calls_table[API_MAXCALL] = { NULL, };
	601
	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);
d3a6532c	607	*
500856eb RJ	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, ...)
	619	{
	620	va_list ap;
	621	int rv;
	622
20e5ed13	623	if (call < 0 \|\| call >= calls_no) {
500856eb RJ	624	debugf("invalid call #%d\n", call);
	625	return 0;
	626	}
	627
	628	if (calls_table[call] == NULL) {
	629	debugf("syscall #%d does not have a handler\n", call);
	630	return 0;
	631	}
	632
	633	va_start(ap, retval);
	634	rv = calls_table[call](ap);
	635	if (retval != NULL)
	636	*retval = rv;
	637
	638	return 1;
	639	}
	640
	641	void api_init(void)
	642	{
	643	struct api_signature *sig = NULL;
	644
	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;
a2a5729f CLC	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;
500856eb RJ	666	calls_no = API_MAXCALL;
	667
	668	debugf("API initialized with %d calls\n", calls_no);
	669
	670	dev_stor_init();
	671
	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	}
	680
	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);
	689	}
	690
	691	void platform_set_mr(struct sys_info *si, unsigned long start, unsigned long size,
	692	int flags)
	693	{
	694	int i;
	695
	696	if (!si->mr \|\| !size \|\| (flags == 0))
	697	return;
d3a6532c	698
500856eb RJ	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	}
	708	}