[net-next-2.6.git] / arch / mips / fw / cfe / cfe_api.c

/*
 * Copyright (C) 2000, 2001, 2002 Broadcom Corporation
 *
 * 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.
 */

/*  *********************************************************************
    *
    *  Broadcom Common Firmware Environment (CFE)
    *
    *  Device Function stubs			File: cfe_api.c
    *
    *  This module contains device function stubs (small routines to
    *  call the standard "iocb" interface entry point to CFE).
    *  There should be one routine here per iocb function call.
    *
    *  Authors:  Mitch Lichtenberg, Chris Demetriou
    *
    ********************************************************************* */

#include <asm/fw/cfe/cfe_api.h>
#include "cfe_api_int.h"

/* Cast from a native pointer to a cfe_xptr_t and back.	 */
#define XPTR_FROM_NATIVE(n)	((cfe_xptr_t) (intptr_t) (n))
#define NATIVE_FROM_XPTR(x)	((void *) (intptr_t) (x))

#ifdef CFE_API_IMPL_NAMESPACE
#define cfe_iocb_dispatch(a)		__cfe_iocb_dispatch(a)
#endif
int cfe_iocb_dispatch(cfe_xiocb_t * xiocb);

#if defined(CFE_API_common) || defined(CFE_API_ALL)
/*
 * Declare the dispatch function with args of "intptr_t".
 * This makes sure whatever model we're compiling in
 * puts the pointers in a single register.  For example,
 * combining -mlong64 and -mips1 or -mips2 would lead to
 * trouble, since the handle and IOCB pointer will be
 * passed in two registers each, and CFE expects one.
 */

static int (*cfe_dispfunc) (intptr_t handle, intptr_t xiocb) = 0;
static cfe_xuint_t cfe_handle = 0;

int cfe_init(cfe_xuint_t handle, cfe_xuint_t ept)
{
	cfe_dispfunc = NATIVE_FROM_XPTR(ept);
	cfe_handle = handle;
	return 0;
}

int cfe_iocb_dispatch(cfe_xiocb_t * xiocb)
{
	if (!cfe_dispfunc)
		return -1;
	return (*cfe_dispfunc) ((intptr_t) cfe_handle, (intptr_t) xiocb);
}
#endif				/* CFE_API_common || CFE_API_ALL */

#if defined(CFE_API_close) || defined(CFE_API_ALL)
int cfe_close(int handle)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_DEV_CLOSE;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = handle;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = 0;

	cfe_iocb_dispatch(&xiocb);

	return xiocb.xiocb_status;

}
#endif				/* CFE_API_close || CFE_API_ALL */

#if defined(CFE_API_cpu_start) || defined(CFE_API_ALL)
int cfe_cpu_start(int cpu, void (*fn) (void), long sp, long gp, long a1)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_cpuctl_t);
	xiocb.plist.xiocb_cpuctl.cpu_number = cpu;
	xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_START;
	xiocb.plist.xiocb_cpuctl.gp_val = gp;
	xiocb.plist.xiocb_cpuctl.sp_val = sp;
	xiocb.plist.xiocb_cpuctl.a1_val = a1;
	xiocb.plist.xiocb_cpuctl.start_addr = (long) fn;

	cfe_iocb_dispatch(&xiocb);

	return xiocb.xiocb_status;
}
#endif				/* CFE_API_cpu_start || CFE_API_ALL */

#if defined(CFE_API_cpu_stop) || defined(CFE_API_ALL)
int cfe_cpu_stop(int cpu)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_cpuctl_t);
	xiocb.plist.xiocb_cpuctl.cpu_number = cpu;
	xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_STOP;

	cfe_iocb_dispatch(&xiocb);

	return xiocb.xiocb_status;
}
#endif				/* CFE_API_cpu_stop || CFE_API_ALL */

#if defined(CFE_API_enumenv) || defined(CFE_API_ALL)
int cfe_enumenv(int idx, char *name, int namelen, char *val, int vallen)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_ENV_SET;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
	xiocb.plist.xiocb_envbuf.enum_idx = idx;
	xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
	xiocb.plist.xiocb_envbuf.name_length = namelen;
	xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(val);
	xiocb.plist.xiocb_envbuf.val_length = vallen;

	cfe_iocb_dispatch(&xiocb);

	return xiocb.xiocb_status;
}
#endif				/* CFE_API_enumenv || CFE_API_ALL */

#if defined(CFE_API_enummem) || defined(CFE_API_ALL)
int
cfe_enummem(int idx, int flags, cfe_xuint_t * start, cfe_xuint_t * length,
	    cfe_xuint_t * type)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_FW_MEMENUM;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = flags;
	xiocb.xiocb_psize = sizeof(xiocb_meminfo_t);
	xiocb.plist.xiocb_meminfo.mi_idx = idx;

	cfe_iocb_dispatch(&xiocb);

	if (xiocb.xiocb_status < 0)
		return xiocb.xiocb_status;

	*start = xiocb.plist.xiocb_meminfo.mi_addr;
	*length = xiocb.plist.xiocb_meminfo.mi_size;
	*type = xiocb.plist.xiocb_meminfo.mi_type;

	return 0;
}
#endif				/* CFE_API_enummem || CFE_API_ALL */

#if defined(CFE_API_exit) || defined(CFE_API_ALL)
int cfe_exit(int warm, int status)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_FW_RESTART;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = warm ? CFE_FLG_WARMSTART : 0;
	xiocb.xiocb_psize = sizeof(xiocb_exitstat_t);
	xiocb.plist.xiocb_exitstat.status = status;

	cfe_iocb_dispatch(&xiocb);

	return xiocb.xiocb_status;
}
#endif				/* CFE_API_exit || CFE_API_ALL */

#if defined(CFE_API_flushcache) || defined(CFE_API_ALL)
int cfe_flushcache(int flg)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_FW_FLUSHCACHE;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = flg;
	xiocb.xiocb_psize = 0;

	cfe_iocb_dispatch(&xiocb);

	return xiocb.xiocb_status;
}
#endif				/* CFE_API_flushcache || CFE_API_ALL */

#if defined(CFE_API_getdevinfo) || defined(CFE_API_ALL)
int cfe_getdevinfo(char *name)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_DEV_GETINFO;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
	xiocb.plist.xiocb_buffer.buf_offset = 0;
	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(name);
	xiocb.plist.xiocb_buffer.buf_length = cfe_strlen(name);

	cfe_iocb_dispatch(&xiocb);

	if (xiocb.xiocb_status < 0)
		return xiocb.xiocb_status;
	return xiocb.plist.xiocb_buffer.buf_devflags;
}
#endif				/* CFE_API_getdevinfo || CFE_API_ALL */

#if defined(CFE_API_getenv) || defined(CFE_API_ALL)
int cfe_getenv(char *name, char *dest, int destlen)
{
	cfe_xiocb_t xiocb;

	*dest = 0;

	xiocb.xiocb_fcode = CFE_CMD_ENV_GET;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
	xiocb.plist.xiocb_envbuf.enum_idx = 0;
	xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
	xiocb.plist.xiocb_envbuf.name_length = cfe_strlen(name);
	xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(dest);
	xiocb.plist.xiocb_envbuf.val_length = destlen;

	cfe_iocb_dispatch(&xiocb);

	return xiocb.xiocb_status;
}
#endif				/* CFE_API_getenv || CFE_API_ALL */

#if defined(CFE_API_getfwinfo) || defined(CFE_API_ALL)
int cfe_getfwinfo(cfe_fwinfo_t * info)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_FW_GETINFO;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_fwinfo_t);

	cfe_iocb_dispatch(&xiocb);

	if (xiocb.xiocb_status < 0)
		return xiocb.xiocb_status;

	info->fwi_version = xiocb.plist.xiocb_fwinfo.fwi_version;
	info->fwi_totalmem = xiocb.plist.xiocb_fwinfo.fwi_totalmem;
	info->fwi_flags = xiocb.plist.xiocb_fwinfo.fwi_flags;
	info->fwi_boardid = xiocb.plist.xiocb_fwinfo.fwi_boardid;
	info->fwi_bootarea_va = xiocb.plist.xiocb_fwinfo.fwi_bootarea_va;
	info->fwi_bootarea_pa = xiocb.plist.xiocb_fwinfo.fwi_bootarea_pa;
	info->fwi_bootarea_size =
	    xiocb.plist.xiocb_fwinfo.fwi_bootarea_size;
#if 0
	info->fwi_reserved1 = xiocb.plist.xiocb_fwinfo.fwi_reserved1;
	info->fwi_reserved2 = xiocb.plist.xiocb_fwinfo.fwi_reserved2;
	info->fwi_reserved3 = xiocb.plist.xiocb_fwinfo.fwi_reserved3;
#endif

	return 0;
}
#endif				/* CFE_API_getfwinfo || CFE_API_ALL */

#if defined(CFE_API_getstdhandle) || defined(CFE_API_ALL)
int cfe_getstdhandle(int flg)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_DEV_GETHANDLE;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = flg;
	xiocb.xiocb_psize = 0;

	cfe_iocb_dispatch(&xiocb);

	if (xiocb.xiocb_status < 0)
		return xiocb.xiocb_status;
	return xiocb.xiocb_handle;
}
#endif				/* CFE_API_getstdhandle || CFE_API_ALL */

#if defined(CFE_API_getticks) || defined(CFE_API_ALL)
int64_t
#ifdef CFE_API_IMPL_NAMESPACE
__cfe_getticks(void)
#else
cfe_getticks(void)
#endif
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_FW_GETTIME;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_time_t);
	xiocb.plist.xiocb_time.ticks = 0;

	cfe_iocb_dispatch(&xiocb);

	return xiocb.plist.xiocb_time.ticks;

}
#endif				/* CFE_API_getticks || CFE_API_ALL */

#if defined(CFE_API_inpstat) || defined(CFE_API_ALL)
int cfe_inpstat(int handle)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_DEV_INPSTAT;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = handle;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_inpstat_t);
	xiocb.plist.xiocb_inpstat.inp_status = 0;

	cfe_iocb_dispatch(&xiocb);

	if (xiocb.xiocb_status < 0)
		return xiocb.xiocb_status;
	return xiocb.plist.xiocb_inpstat.inp_status;
}
#endif				/* CFE_API_inpstat || CFE_API_ALL */

#if defined(CFE_API_ioctl) || defined(CFE_API_ALL)
int
cfe_ioctl(int handle, unsigned int ioctlnum, unsigned char *buffer,
	  int length, int *retlen, cfe_xuint_t offset)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_DEV_IOCTL;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = handle;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
	xiocb.plist.xiocb_buffer.buf_offset = offset;
	xiocb.plist.xiocb_buffer.buf_ioctlcmd = ioctlnum;
	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer);
	xiocb.plist.xiocb_buffer.buf_length = length;

	cfe_iocb_dispatch(&xiocb);

	if (retlen)
		*retlen = xiocb.plist.xiocb_buffer.buf_retlen;
	return xiocb.xiocb_status;
}
#endif				/* CFE_API_ioctl || CFE_API_ALL */

#if defined(CFE_API_open) || defined(CFE_API_ALL)
int cfe_open(char *name)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_DEV_OPEN;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
	xiocb.plist.xiocb_buffer.buf_offset = 0;
	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(name);
	xiocb.plist.xiocb_buffer.buf_length = cfe_strlen(name);

	cfe_iocb_dispatch(&xiocb);

	if (xiocb.xiocb_status < 0)
		return xiocb.xiocb_status;
	return xiocb.xiocb_handle;
}
#endif				/* CFE_API_open || CFE_API_ALL */

#if defined(CFE_API_read) || defined(CFE_API_ALL)
int cfe_read(int handle, unsigned char *buffer, int length)
{
	return cfe_readblk(handle, 0, buffer, length);
}
#endif				/* CFE_API_read || CFE_API_ALL */

#if defined(CFE_API_readblk) || defined(CFE_API_ALL)
int
cfe_readblk(int handle, cfe_xint_t offset, unsigned char *buffer,
	    int length)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_DEV_READ;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = handle;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
	xiocb.plist.xiocb_buffer.buf_offset = offset;
	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer);
	xiocb.plist.xiocb_buffer.buf_length = length;

	cfe_iocb_dispatch(&xiocb);

	if (xiocb.xiocb_status < 0)
		return xiocb.xiocb_status;
	return xiocb.plist.xiocb_buffer.buf_retlen;
}
#endif				/* CFE_API_readblk || CFE_API_ALL */

#if defined(CFE_API_setenv) || defined(CFE_API_ALL)
int cfe_setenv(char *name, char *val)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_ENV_SET;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = 0;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
	xiocb.plist.xiocb_envbuf.enum_idx = 0;
	xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
	xiocb.plist.xiocb_envbuf.name_length = cfe_strlen(name);
	xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(val);
	xiocb.plist.xiocb_envbuf.val_length = cfe_strlen(val);

	cfe_iocb_dispatch(&xiocb);

	return xiocb.xiocb_status;
}
#endif				/* CFE_API_setenv || CFE_API_ALL */

#if (defined(CFE_API_strlen) || defined(CFE_API_ALL)) \
    && !defined(CFE_API_STRLEN_CUSTOM)
int cfe_strlen(char *name)
{
	int count = 0;

	while (*name++)
		count++;

	return count;
}
#endif				/* CFE_API_strlen || CFE_API_ALL */

#if defined(CFE_API_write) || defined(CFE_API_ALL)
int cfe_write(int handle, unsigned char *buffer, int length)
{
	return cfe_writeblk(handle, 0, buffer, length);
}
#endif				/* CFE_API_write || CFE_API_ALL */

#if defined(CFE_API_writeblk) || defined(CFE_API_ALL)
int
cfe_writeblk(int handle, cfe_xint_t offset, unsigned char *buffer,
	     int length)
{
	cfe_xiocb_t xiocb;

	xiocb.xiocb_fcode = CFE_CMD_DEV_WRITE;
	xiocb.xiocb_status = 0;
	xiocb.xiocb_handle = handle;
	xiocb.xiocb_flags = 0;
	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
	xiocb.plist.xiocb_buffer.buf_offset = offset;
	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer);
	xiocb.plist.xiocb_buffer.buf_length = length;

	cfe_iocb_dispatch(&xiocb);

	if (xiocb.xiocb_status < 0)
		return xiocb.xiocb_status;
	return xiocb.plist.xiocb_buffer.buf_retlen;
}
#endif				/* CFE_API_writeblk || CFE_API_ALL */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (C) 2000, 2001, 2002 Broadcom Corporation
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version 2
	7	* of the License, or (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17	*/
	18
	19	/* *********************************************************************
	20	*
	21	* Broadcom Common Firmware Environment (CFE)
	22	*
	23	* Device Function stubs File: cfe_api.c
	24	*
	25	* This module contains device function stubs (small routines to
	26	* call the standard "iocb" interface entry point to CFE).
	27	* There should be one routine here per iocb function call.
	28	*
	29	* Authors: Mitch Lichtenberg, Chris Demetriou
	30	*
	31	********************************************************************* */
	32
df78b5c8	33	#include <asm/fw/cfe/cfe_api.h>
1da177e4 LT	34	#include "cfe_api_int.h"
	35
	36	/* Cast from a native pointer to a cfe_xptr_t and back. */
	37	#define XPTR_FROM_NATIVE(n) ((cfe_xptr_t) (intptr_t) (n))
	38	#define NATIVE_FROM_XPTR(x) ((void *) (intptr_t) (x))
	39
	40	#ifdef CFE_API_IMPL_NAMESPACE
	41	#define cfe_iocb_dispatch(a) __cfe_iocb_dispatch(a)
	42	#endif
	43	int cfe_iocb_dispatch(cfe_xiocb_t * xiocb);
	44
	45	#if defined(CFE_API_common) \|\| defined(CFE_API_ALL)
	46	/*
	47	* Declare the dispatch function with args of "intptr_t".
	48	* This makes sure whatever model we're compiling in
	49	* puts the pointers in a single register. For example,
	50	* combining -mlong64 and -mips1 or -mips2 would lead to
	51	* trouble, since the handle and IOCB pointer will be
	52	* passed in two registers each, and CFE expects one.
	53	*/
	54
	55	static int (*cfe_dispfunc) (intptr_t handle, intptr_t xiocb) = 0;
	56	static cfe_xuint_t cfe_handle = 0;
	57
	58	int cfe_init(cfe_xuint_t handle, cfe_xuint_t ept)
	59	{
	60	cfe_dispfunc = NATIVE_FROM_XPTR(ept);
	61	cfe_handle = handle;
	62	return 0;
	63	}
	64
	65	int cfe_iocb_dispatch(cfe_xiocb_t * xiocb)
	66	{
	67	if (!cfe_dispfunc)
	68	return -1;
	69	return (*cfe_dispfunc) ((intptr_t) cfe_handle, (intptr_t) xiocb);
	70	}
	71	#endif /* CFE_API_common \|\| CFE_API_ALL */
	72
	73	#if defined(CFE_API_close) \|\| defined(CFE_API_ALL)
	74	int cfe_close(int handle)
	75	{
	76	cfe_xiocb_t xiocb;
	77
	78	xiocb.xiocb_fcode = CFE_CMD_DEV_CLOSE;
	79	xiocb.xiocb_status = 0;
	80	xiocb.xiocb_handle = handle;
	81	xiocb.xiocb_flags = 0;
	82	xiocb.xiocb_psize = 0;
	83
	84	cfe_iocb_dispatch(&xiocb);
	85
	86	return xiocb.xiocb_status;
	87
	88	}
	89	#endif /* CFE_API_close \|\| CFE_API_ALL */
	90
	91	#if defined(CFE_API_cpu_start) \|\| defined(CFE_API_ALL)
	92	int cfe_cpu_start(int cpu, void (*fn) (void), long sp, long gp, long a1)
	93	{
	94	cfe_xiocb_t xiocb;
	95
	96	xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL;
	97	xiocb.xiocb_status = 0;
98	xiocb.xiocb_handle = 0;
99	xiocb.xiocb_flags = 0;
100	xiocb.xiocb_psize = sizeof(xiocb_cpuctl_t);
101	xiocb.plist.xiocb_cpuctl.cpu_number = cpu;
102	xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_START;
103	xiocb.plist.xiocb_cpuctl.gp_val = gp;
104	xiocb.plist.xiocb_cpuctl.sp_val = sp;
105	xiocb.plist.xiocb_cpuctl.a1_val = a1;
106	xiocb.plist.xiocb_cpuctl.start_addr = (long) fn;
107
108	cfe_iocb_dispatch(&xiocb);
109
110	return xiocb.xiocb_status;
111	}
112	#endif /* CFE_API_cpu_start \|\| CFE_API_ALL */
113
114	#if defined(CFE_API_cpu_stop) \|\| defined(CFE_API_ALL)
115	int cfe_cpu_stop(int cpu)
116	{
117	cfe_xiocb_t xiocb;
118
119	xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL;
120	xiocb.xiocb_status = 0;
121	xiocb.xiocb_handle = 0;
122	xiocb.xiocb_flags = 0;
123	xiocb.xiocb_psize = sizeof(xiocb_cpuctl_t);
124	xiocb.plist.xiocb_cpuctl.cpu_number = cpu;
125	xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_STOP;
126
127	cfe_iocb_dispatch(&xiocb);
128
129	return xiocb.xiocb_status;
130	}
131	#endif /* CFE_API_cpu_stop \|\| CFE_API_ALL */
132
133	#if defined(CFE_API_enumenv) \|\| defined(CFE_API_ALL)
134	int cfe_enumenv(int idx, char name, int namelen, char val, int vallen)
135	{
136	cfe_xiocb_t xiocb;
137
138	xiocb.xiocb_fcode = CFE_CMD_ENV_SET;
139	xiocb.xiocb_status = 0;
140	xiocb.xiocb_handle = 0;
141	xiocb.xiocb_flags = 0;
142	xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
143	xiocb.plist.xiocb_envbuf.enum_idx = idx;
144	xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
145	xiocb.plist.xiocb_envbuf.name_length = namelen;
146	xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(val);
147	xiocb.plist.xiocb_envbuf.val_length = vallen;
148
149	cfe_iocb_dispatch(&xiocb);
150
151	return xiocb.xiocb_status;
152	}
153	#endif /* CFE_API_enumenv \|\| CFE_API_ALL */
154
155	#if defined(CFE_API_enummem) \|\| defined(CFE_API_ALL)
156	int
157	cfe_enummem(int idx, int flags, cfe_xuint_t * start, cfe_xuint_t * length,
158	cfe_xuint_t * type)
159	{
160	cfe_xiocb_t xiocb;
161
162	xiocb.xiocb_fcode = CFE_CMD_FW_MEMENUM;
163	xiocb.xiocb_status = 0;
164	xiocb.xiocb_handle = 0;
165	xiocb.xiocb_flags = flags;
166	xiocb.xiocb_psize = sizeof(xiocb_meminfo_t);
167	xiocb.plist.xiocb_meminfo.mi_idx = idx;
168
169	cfe_iocb_dispatch(&xiocb);
170
171	if (xiocb.xiocb_status < 0)
172	return xiocb.xiocb_status;
173
174	*start = xiocb.plist.xiocb_meminfo.mi_addr;
175	*length = xiocb.plist.xiocb_meminfo.mi_size;
176	*type = xiocb.plist.xiocb_meminfo.mi_type;
177
178	return 0;
179	}
180	#endif /* CFE_API_enummem \|\| CFE_API_ALL */
181
182	#if defined(CFE_API_exit) \|\| defined(CFE_API_ALL)
183	int cfe_exit(int warm, int status)
184	{
185	cfe_xiocb_t xiocb;
186
187	xiocb.xiocb_fcode = CFE_CMD_FW_RESTART;
188	xiocb.xiocb_status = 0;
189	xiocb.xiocb_handle = 0;
190	xiocb.xiocb_flags = warm ? CFE_FLG_WARMSTART : 0;
191	xiocb.xiocb_psize = sizeof(xiocb_exitstat_t);
192	xiocb.plist.xiocb_exitstat.status = status;
193
194	cfe_iocb_dispatch(&xiocb);
195
196	return xiocb.xiocb_status;
197	}
198	#endif /* CFE_API_exit \|\| CFE_API_ALL */
199
200	#if defined(CFE_API_flushcache) \|\| defined(CFE_API_ALL)
201	int cfe_flushcache(int flg)
202	{
203	cfe_xiocb_t xiocb;
204
205	xiocb.xiocb_fcode = CFE_CMD_FW_FLUSHCACHE;
206	xiocb.xiocb_status = 0;
207	xiocb.xiocb_handle = 0;
208	xiocb.xiocb_flags = flg;
209	xiocb.xiocb_psize = 0;
210
211	cfe_iocb_dispatch(&xiocb);
212
213	return xiocb.xiocb_status;
214	}
215	#endif /* CFE_API_flushcache \|\| CFE_API_ALL */
216
217	#if defined(CFE_API_getdevinfo) \|\| defined(CFE_API_ALL)
218	int cfe_getdevinfo(char *name)
219	{
220	cfe_xiocb_t xiocb;
221
222	xiocb.xiocb_fcode = CFE_CMD_DEV_GETINFO;
223	xiocb.xiocb_status = 0;
224	xiocb.xiocb_handle = 0;
225	xiocb.xiocb_flags = 0;
226	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
227	xiocb.plist.xiocb_buffer.buf_offset = 0;
228	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(name);
229	xiocb.plist.xiocb_buffer.buf_length = cfe_strlen(name);
230
231	cfe_iocb_dispatch(&xiocb);
232
233	if (xiocb.xiocb_status < 0)
234	return xiocb.xiocb_status;
235	return xiocb.plist.xiocb_buffer.buf_devflags;
236	}
237	#endif /* CFE_API_getdevinfo \|\| CFE_API_ALL */
238
239	#if defined(CFE_API_getenv) \|\| defined(CFE_API_ALL)
240	int cfe_getenv(char name, char dest, int destlen)
241	{
242	cfe_xiocb_t xiocb;
243
244	*dest = 0;
245
246	xiocb.xiocb_fcode = CFE_CMD_ENV_GET;
247	xiocb.xiocb_status = 0;
248	xiocb.xiocb_handle = 0;
249	xiocb.xiocb_flags = 0;
250	xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
251	xiocb.plist.xiocb_envbuf.enum_idx = 0;
252	xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
253	xiocb.plist.xiocb_envbuf.name_length = cfe_strlen(name);
254	xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(dest);
255	xiocb.plist.xiocb_envbuf.val_length = destlen;
256
257	cfe_iocb_dispatch(&xiocb);
258
259	return xiocb.xiocb_status;
260	}
261	#endif /* CFE_API_getenv \|\| CFE_API_ALL */
262
263	#if defined(CFE_API_getfwinfo) \|\| defined(CFE_API_ALL)
264	int cfe_getfwinfo(cfe_fwinfo_t * info)
265	{
266	cfe_xiocb_t xiocb;
267
268	xiocb.xiocb_fcode = CFE_CMD_FW_GETINFO;
269	xiocb.xiocb_status = 0;
270	xiocb.xiocb_handle = 0;
271	xiocb.xiocb_flags = 0;
272	xiocb.xiocb_psize = sizeof(xiocb_fwinfo_t);
273
274	cfe_iocb_dispatch(&xiocb);
275
276	if (xiocb.xiocb_status < 0)
277	return xiocb.xiocb_status;
278
279	info->fwi_version = xiocb.plist.xiocb_fwinfo.fwi_version;
280	info->fwi_totalmem = xiocb.plist.xiocb_fwinfo.fwi_totalmem;
281	info->fwi_flags = xiocb.plist.xiocb_fwinfo.fwi_flags;
282	info->fwi_boardid = xiocb.plist.xiocb_fwinfo.fwi_boardid;
283	info->fwi_bootarea_va = xiocb.plist.xiocb_fwinfo.fwi_bootarea_va;
284	info->fwi_bootarea_pa = xiocb.plist.xiocb_fwinfo.fwi_bootarea_pa;
285	info->fwi_bootarea_size =
286	xiocb.plist.xiocb_fwinfo.fwi_bootarea_size;
287	#if 0
288	info->fwi_reserved1 = xiocb.plist.xiocb_fwinfo.fwi_reserved1;
289	info->fwi_reserved2 = xiocb.plist.xiocb_fwinfo.fwi_reserved2;
290	info->fwi_reserved3 = xiocb.plist.xiocb_fwinfo.fwi_reserved3;
291	#endif
292
293	return 0;
294	}
295	#endif /* CFE_API_getfwinfo \|\| CFE_API_ALL */
296
297	#if defined(CFE_API_getstdhandle) \|\| defined(CFE_API_ALL)
298	int cfe_getstdhandle(int flg)
299	{
300	cfe_xiocb_t xiocb;
301
302	xiocb.xiocb_fcode = CFE_CMD_DEV_GETHANDLE;
303	xiocb.xiocb_status = 0;
304	xiocb.xiocb_handle = 0;
305	xiocb.xiocb_flags = flg;
306	xiocb.xiocb_psize = 0;
307
308	cfe_iocb_dispatch(&xiocb);
309
310	if (xiocb.xiocb_status < 0)
311	return xiocb.xiocb_status;
312	return xiocb.xiocb_handle;
313	}
314	#endif /* CFE_API_getstdhandle \|\| CFE_API_ALL */
315
316	#if defined(CFE_API_getticks) \|\| defined(CFE_API_ALL)
317	int64_t
318	#ifdef CFE_API_IMPL_NAMESPACE
319	__cfe_getticks(void)
320	#else
321	cfe_getticks(void)
322	#endif
323	{
324	cfe_xiocb_t xiocb;
325
326	xiocb.xiocb_fcode = CFE_CMD_FW_GETTIME;
327	xiocb.xiocb_status = 0;
328	xiocb.xiocb_handle = 0;
329	xiocb.xiocb_flags = 0;
330	xiocb.xiocb_psize = sizeof(xiocb_time_t);
331	xiocb.plist.xiocb_time.ticks = 0;
332
333	cfe_iocb_dispatch(&xiocb);
334
335	return xiocb.plist.xiocb_time.ticks;
336
337	}
338	#endif /* CFE_API_getticks \|\| CFE_API_ALL */
339
340	#if defined(CFE_API_inpstat) \|\| defined(CFE_API_ALL)
341	int cfe_inpstat(int handle)
342	{
343	cfe_xiocb_t xiocb;
344
345	xiocb.xiocb_fcode = CFE_CMD_DEV_INPSTAT;
346	xiocb.xiocb_status = 0;
347	xiocb.xiocb_handle = handle;
348	xiocb.xiocb_flags = 0;
349	xiocb.xiocb_psize = sizeof(xiocb_inpstat_t);
350	xiocb.plist.xiocb_inpstat.inp_status = 0;
351
352	cfe_iocb_dispatch(&xiocb);
353
354	if (xiocb.xiocb_status < 0)
355	return xiocb.xiocb_status;
356	return xiocb.plist.xiocb_inpstat.inp_status;
357	}
358	#endif /* CFE_API_inpstat \|\| CFE_API_ALL */
359
360	#if defined(CFE_API_ioctl) \|\| defined(CFE_API_ALL)
361	int
362	cfe_ioctl(int handle, unsigned int ioctlnum, unsigned char *buffer,
363	int length, int *retlen, cfe_xuint_t offset)
364	{
365	cfe_xiocb_t xiocb;
366
367	xiocb.xiocb_fcode = CFE_CMD_DEV_IOCTL;
368	xiocb.xiocb_status = 0;
369	xiocb.xiocb_handle = handle;
370	xiocb.xiocb_flags = 0;
371	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
372	xiocb.plist.xiocb_buffer.buf_offset = offset;
373	xiocb.plist.xiocb_buffer.buf_ioctlcmd = ioctlnum;
374	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer);
375	xiocb.plist.xiocb_buffer.buf_length = length;
376
377	cfe_iocb_dispatch(&xiocb);
378
379	if (retlen)
380	*retlen = xiocb.plist.xiocb_buffer.buf_retlen;
381	return xiocb.xiocb_status;
382	}
383	#endif /* CFE_API_ioctl \|\| CFE_API_ALL */
384
385	#if defined(CFE_API_open) \|\| defined(CFE_API_ALL)
386	int cfe_open(char *name)
387	{
388	cfe_xiocb_t xiocb;
389
390	xiocb.xiocb_fcode = CFE_CMD_DEV_OPEN;
391	xiocb.xiocb_status = 0;
392	xiocb.xiocb_handle = 0;
393	xiocb.xiocb_flags = 0;
394	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
395	xiocb.plist.xiocb_buffer.buf_offset = 0;
396	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(name);
397	xiocb.plist.xiocb_buffer.buf_length = cfe_strlen(name);
398
399	cfe_iocb_dispatch(&xiocb);
400
401	if (xiocb.xiocb_status < 0)
402	return xiocb.xiocb_status;
403	return xiocb.xiocb_handle;
404	}
405	#endif /* CFE_API_open \|\| CFE_API_ALL */
406
407	#if defined(CFE_API_read) \|\| defined(CFE_API_ALL)
408	int cfe_read(int handle, unsigned char *buffer, int length)
409	{
410	return cfe_readblk(handle, 0, buffer, length);
411	}
412	#endif /* CFE_API_read \|\| CFE_API_ALL */
413
414	#if defined(CFE_API_readblk) \|\| defined(CFE_API_ALL)
415	int
416	cfe_readblk(int handle, cfe_xint_t offset, unsigned char *buffer,
417	int length)
418	{
419	cfe_xiocb_t xiocb;
420
421	xiocb.xiocb_fcode = CFE_CMD_DEV_READ;
422	xiocb.xiocb_status = 0;
423	xiocb.xiocb_handle = handle;
424	xiocb.xiocb_flags = 0;
425	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
426	xiocb.plist.xiocb_buffer.buf_offset = offset;
427	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer);
428	xiocb.plist.xiocb_buffer.buf_length = length;
429
430	cfe_iocb_dispatch(&xiocb);
431
432	if (xiocb.xiocb_status < 0)
433	return xiocb.xiocb_status;
434	return xiocb.plist.xiocb_buffer.buf_retlen;
435	}
436	#endif /* CFE_API_readblk \|\| CFE_API_ALL */
437
438	#if defined(CFE_API_setenv) \|\| defined(CFE_API_ALL)
439	int cfe_setenv(char name, char val)
440	{
441	cfe_xiocb_t xiocb;
442
443	xiocb.xiocb_fcode = CFE_CMD_ENV_SET;
444	xiocb.xiocb_status = 0;
445	xiocb.xiocb_handle = 0;
446	xiocb.xiocb_flags = 0;
447	xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
448	xiocb.plist.xiocb_envbuf.enum_idx = 0;
449	xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
450	xiocb.plist.xiocb_envbuf.name_length = cfe_strlen(name);
451	xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(val);
452	xiocb.plist.xiocb_envbuf.val_length = cfe_strlen(val);
453
454	cfe_iocb_dispatch(&xiocb);
455
456	return xiocb.xiocb_status;
457	}
458	#endif /* CFE_API_setenv \|\| CFE_API_ALL */
459
460	#if (defined(CFE_API_strlen) \|\| defined(CFE_API_ALL)) \
461	&& !defined(CFE_API_STRLEN_CUSTOM)
462	int cfe_strlen(char *name)
463	{
464	int count = 0;
465
466	while (*name++)
467	count++;
468
469	return count;
470	}
471	#endif /* CFE_API_strlen \|\| CFE_API_ALL */
472
473	#if defined(CFE_API_write) \|\| defined(CFE_API_ALL)
474	int cfe_write(int handle, unsigned char *buffer, int length)
475	{
476	return cfe_writeblk(handle, 0, buffer, length);
477	}
478	#endif /* CFE_API_write \|\| CFE_API_ALL */
479
480	#if defined(CFE_API_writeblk) \|\| defined(CFE_API_ALL)
481	int
482	cfe_writeblk(int handle, cfe_xint_t offset, unsigned char *buffer,
483	int length)
484	{
485	cfe_xiocb_t xiocb;
486
487	xiocb.xiocb_fcode = CFE_CMD_DEV_WRITE;
488	xiocb.xiocb_status = 0;
489	xiocb.xiocb_handle = handle;
490	xiocb.xiocb_flags = 0;
491	xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
492	xiocb.plist.xiocb_buffer.buf_offset = offset;
493	xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer);
494	xiocb.plist.xiocb_buffer.buf_length = length;
495
496	cfe_iocb_dispatch(&xiocb);
497
498	if (xiocb.xiocb_status < 0)
499	return xiocb.xiocb_status;
500	return xiocb.plist.xiocb_buffer.buf_retlen;
501	}
502	#endif /* CFE_API_writeblk \|\| CFE_API_ALL */