1/* $Id: cfe_api.c,v 1.18 2006/08/24 02:13:56 binh Exp $ */
2
3/*
4 * Copyright 2000, 2001, 2002
5 * Broadcom Corporation. All rights reserved.
6 *
7 * This software is furnished under license and may be used and copied only
8 * in accordance with the following terms and conditions.  Subject to these
9 * conditions, you may download, copy, install, use, modify and distribute
10 * modified or unmodified copies of this software in source and/or binary
11 * form. No title or ownership is transferred hereby.
12 *
13 * 1) Any source code used, modified or distributed must reproduce and
14 *    retain this copyright notice and list of conditions as they appear in
15 *    the source file.
16 *
17 * 2) No right is granted to use any trade name, trademark, or logo of
18 *    Broadcom Corporation.  The "Broadcom Corporation" name may not be
19 *    used to endorse or promote products derived from this software
20 *    without the prior written permission of Broadcom Corporation.
21 *
22 * 3) THIS SOFTWARE IS PROVIDED "AS-IS" AND ANY EXPRESS OR IMPLIED
23 *    WARRANTIES, INCLUDING BUT NOT LIMITED TO, ANY IMPLIED WARRANTIES OF
24 *    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
25 *    NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL BROADCOM BE LIABLE
26 *    FOR ANY DAMAGES WHATSOEVER, AND IN PARTICULAR, BROADCOM SHALL NOT BE
27 *    LIABLE FOR DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 *    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 *    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 *    BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
31 *    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
32 *    OR OTHERWISE), EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35/*  *********************************************************************
36    *
37    *  Broadcom Common Firmware Environment (CFE)
38    *
39    *  Device Function stubs			File: cfe_api.c
40    *
41    *  This module contains device function stubs (small routines to
42    *  call the standard "iocb" interface entry point to CFE).
43    *  There should be one routine here per iocb function call.
44    *
45    *  Authors:  Mitch Lichtenberg, Chris Demetriou
46    *
47    ********************************************************************* */
48
49#include "cfe_api.h"
50#include "cfe_api_int.h"
51
52/* Cast from a native pointer to a cfe_xptr_t and back.  */
53#define XPTR_FROM_NATIVE(n)	((cfe_xptr_t) (intptr_t) (n))
54#define NATIVE_FROM_XPTR(x)	((void *) (intptr_t) (x))
55
56#ifdef CFE_API_IMPL_NAMESPACE
57#define cfe_iocb_dispatch(a)		__cfe_iocb_dispatch(a)
58#endif
59int cfe_iocb_dispatch(cfe_xiocb_t *xiocb);
60
61#if defined(CFE_API_common) || defined(CFE_API_ALL)
62/*
63 * Declare the dispatch function with args of "intptr_t".
64 * This makes sure whatever model we're compiling in
65 * puts the pointers in a single register.  For example,
66 * combining -mlong64 and -mips1 or -mips2 would lead to
67 * trouble, since the handle and IOCB pointer will be
68 * passed in two registers each, and CFE expects one.
69 */
70
71static int (*cfe_dispfunc)(intptr_t handle, intptr_t xiocb) = 0;
72static cfe_xuint_t cfe_handle = 0;
73
74int
75cfe_init(cfe_xuint_t handle, cfe_xuint_t ept)
76{
77    cfe_dispfunc = NATIVE_FROM_XPTR(ept);
78    cfe_handle = handle;
79    return 0;
80}
81
82int
83cfe_iocb_dispatch(cfe_xiocb_t *xiocb)
84{
85    if (!cfe_dispfunc) return -1;
86    return (*cfe_dispfunc)((intptr_t)cfe_handle, (intptr_t)xiocb);
87}
88#endif /* CFE_API_common || CFE_API_ALL */
89
90#if defined(CFE_API_close) || defined(CFE_API_ALL)
91int
92cfe_close(int handle)
93{
94    cfe_xiocb_t xiocb;
95
96    xiocb.xiocb_fcode = CFE_CMD_DEV_CLOSE;
97    xiocb.xiocb_status = 0;
98    xiocb.xiocb_handle = handle;
99    xiocb.xiocb_flags = 0;
100    xiocb.xiocb_psize = 0;
101
102    cfe_iocb_dispatch(&xiocb);
103
104    return xiocb.xiocb_status;
105
106}
107#endif /* CFE_API_close || CFE_API_ALL */
108
109#if defined(CFE_API_cpu_start) || defined(CFE_API_ALL)
110int
111cfe_cpu_start(int cpu, void (*fn)(void), long sp, long gp, long a1)
112{
113    cfe_xiocb_t xiocb;
114
115    xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL;
116    xiocb.xiocb_status = 0;
117    xiocb.xiocb_handle = 0;
118    xiocb.xiocb_flags  = 0;
119    xiocb.xiocb_psize = sizeof(xiocb_cpuctl_t);
120    xiocb.plist.xiocb_cpuctl.cpu_number = cpu;
121    xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_START;
122    xiocb.plist.xiocb_cpuctl.gp_val = gp;
123    xiocb.plist.xiocb_cpuctl.sp_val = sp;
124    xiocb.plist.xiocb_cpuctl.a1_val = a1;
125    xiocb.plist.xiocb_cpuctl.start_addr = (long)fn;
126
127    cfe_iocb_dispatch(&xiocb);
128
129    return xiocb.xiocb_status;
130}
131#endif /* CFE_API_cpu_start || CFE_API_ALL */
132
133#if defined(CFE_API_cpu_stop) || defined(CFE_API_ALL)
134int
135cfe_cpu_stop(int cpu)
136{
137    cfe_xiocb_t xiocb;
138
139    xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL;
140    xiocb.xiocb_status = 0;
141    xiocb.xiocb_handle = 0;
142    xiocb.xiocb_flags  = 0;
143    xiocb.xiocb_psize = sizeof(xiocb_cpuctl_t);
144    xiocb.plist.xiocb_cpuctl.cpu_number = cpu;
145    xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_STOP;
146
147    cfe_iocb_dispatch(&xiocb);
148
149    return xiocb.xiocb_status;
150}
151#endif /* CFE_API_cpu_stop || CFE_API_ALL */
152
153#if defined(CFE_API_enumenv) || defined(CFE_API_ALL)
154int
155cfe_enumenv(int idx, char *name, int namelen, char *val, int vallen)
156{
157    cfe_xiocb_t xiocb;
158
159    xiocb.xiocb_fcode = CFE_CMD_ENV_ENUM;
160    xiocb.xiocb_status = 0;
161    xiocb.xiocb_handle = 0;
162    xiocb.xiocb_flags = 0;
163    xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
164    xiocb.plist.xiocb_envbuf.enum_idx = idx;
165    xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
166    xiocb.plist.xiocb_envbuf.name_length = namelen;
167    xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(val);
168    xiocb.plist.xiocb_envbuf.val_length = vallen;
169
170    cfe_iocb_dispatch(&xiocb);
171
172    return xiocb.xiocb_status;
173}
174#endif /* CFE_API_enumenv || CFE_API_ALL */
175
176#if defined(CFE_API_enumdev) || defined(CFE_API_ALL)
177int
178cfe_enumdev(int idx, char *name, int namelen)
179{
180    cfe_xiocb_t xiocb;
181
182    xiocb.xiocb_fcode = CFE_CMD_DEV_ENUM;
183    xiocb.xiocb_status = 0;
184    xiocb.xiocb_handle = 0;
185    xiocb.xiocb_flags = 0;
186    xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
187    xiocb.plist.xiocb_envbuf.enum_idx = idx;
188    xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
189    xiocb.plist.xiocb_envbuf.name_length = namelen;
190
191    cfe_iocb_dispatch(&xiocb);
192
193    return xiocb.xiocb_status;
194}
195#endif /* CFE_API_enumdev || CFE_API_ALL */
196
197#if defined(CFE_API_enummem) || defined(CFE_API_ALL)
198int
199cfe_enummem(int idx, int flags, cfe_xuint_t *start, cfe_xuint_t *length,
200	    cfe_xuint_t *type)
201{
202    cfe_xiocb_t xiocb;
203
204    xiocb.xiocb_fcode = CFE_CMD_FW_MEMENUM;
205    xiocb.xiocb_status = 0;
206    xiocb.xiocb_handle = 0;
207    xiocb.xiocb_flags = flags;
208    xiocb.xiocb_psize = sizeof(xiocb_meminfo_t);
209    xiocb.plist.xiocb_meminfo.mi_idx = idx;
210
211    cfe_iocb_dispatch(&xiocb);
212
213    if (xiocb.xiocb_status < 0)
214	return xiocb.xiocb_status;
215
216    *start = xiocb.plist.xiocb_meminfo.mi_addr;
217    *length = xiocb.plist.xiocb_meminfo.mi_size;
218    *type = xiocb.plist.xiocb_meminfo.mi_type;
219
220    return 0;
221}
222#endif /* CFE_API_enummem || CFE_API_ALL */
223
224#if defined(CFE_API_exit) || defined(CFE_API_ALL)
225int
226cfe_exit(int warm, int status)
227{
228    cfe_xiocb_t xiocb;
229
230    xiocb.xiocb_fcode = CFE_CMD_FW_RESTART;
231    xiocb.xiocb_status = 0;
232    xiocb.xiocb_handle = 0;
233    xiocb.xiocb_flags = warm ? CFE_FLG_WARMSTART : 0;
234    xiocb.xiocb_psize = sizeof(xiocb_exitstat_t);
235    xiocb.plist.xiocb_exitstat.status = status;
236
237    cfe_iocb_dispatch(&xiocb);
238
239    return xiocb.xiocb_status;
240}
241#endif /* CFE_API_exit || CFE_API_ALL */
242
243#if defined(CFE_API_flushcache) || defined(CFE_API_ALL)
244int
245cfe_flushcache(int flg)
246{
247    cfe_xiocb_t xiocb;
248
249    xiocb.xiocb_fcode = CFE_CMD_FW_FLUSHCACHE;
250    xiocb.xiocb_status = 0;
251    xiocb.xiocb_handle = 0;
252    xiocb.xiocb_flags = flg;
253    xiocb.xiocb_psize = 0;
254
255    cfe_iocb_dispatch(&xiocb);
256
257    return xiocb.xiocb_status;
258}
259#endif /* CFE_API_flushcache || CFE_API_ALL */
260
261#if defined(CFE_API_getdevinfo) || defined(CFE_API_ALL)
262int
263cfe_getdevinfo(char *name)
264{
265    cfe_xiocb_t xiocb;
266
267    xiocb.xiocb_fcode = CFE_CMD_DEV_GETINFO;
268    xiocb.xiocb_status = 0;
269    xiocb.xiocb_handle = 0;
270    xiocb.xiocb_flags = 0;
271    xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
272    xiocb.plist.xiocb_buffer.buf_offset = 0;
273    xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(name);
274    xiocb.plist.xiocb_buffer.buf_length = cfe_strlen(name);
275
276    cfe_iocb_dispatch(&xiocb);
277
278    if (xiocb.xiocb_status < 0)
279	return xiocb.xiocb_status;
280    return xiocb.plist.xiocb_buffer.buf_devflags;
281}
282#endif /* CFE_API_getdevinfo || CFE_API_ALL */
283
284#if defined(CFE_API_getenv) || defined(CFE_API_ALL)
285int
286cfe_getenv(char *name, char *dest, int destlen)
287{
288    cfe_xiocb_t xiocb;
289
290    *dest = 0;
291
292    xiocb.xiocb_fcode = CFE_CMD_ENV_GET;
293    xiocb.xiocb_status = 0;
294    xiocb.xiocb_handle = 0;
295    xiocb.xiocb_flags = 0;
296    xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
297    xiocb.plist.xiocb_envbuf.enum_idx = 0;
298    xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
299    xiocb.plist.xiocb_envbuf.name_length = cfe_strlen(name);
300    xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(dest);
301    xiocb.plist.xiocb_envbuf.val_length = destlen;
302
303    cfe_iocb_dispatch(&xiocb);
304
305    return xiocb.xiocb_status;
306}
307#endif /* CFE_API_getenv || CFE_API_ALL */
308
309#if defined(CFE_API_getfwinfo) || defined(CFE_API_ALL)
310int
311cfe_getfwinfo(cfe_fwinfo_t *info)
312{
313    cfe_xiocb_t xiocb;
314
315    xiocb.xiocb_fcode = CFE_CMD_FW_GETINFO;
316    xiocb.xiocb_status = 0;
317    xiocb.xiocb_handle = 0;
318    xiocb.xiocb_flags = 0;
319    xiocb.xiocb_psize = sizeof(xiocb_fwinfo_t);
320
321    cfe_iocb_dispatch(&xiocb);
322
323    if (xiocb.xiocb_status < 0)
324	return xiocb.xiocb_status;
325
326    info->fwi_version = xiocb.plist.xiocb_fwinfo.fwi_version;
327    info->fwi_totalmem = xiocb.plist.xiocb_fwinfo.fwi_totalmem;
328    info->fwi_flags = xiocb.plist.xiocb_fwinfo.fwi_flags;
329    info->fwi_boardid = xiocb.plist.xiocb_fwinfo.fwi_boardid;
330    info->fwi_bootarea_va = xiocb.plist.xiocb_fwinfo.fwi_bootarea_va;
331    info->fwi_bootarea_pa = xiocb.plist.xiocb_fwinfo.fwi_bootarea_pa;
332    info->fwi_bootarea_size = xiocb.plist.xiocb_fwinfo.fwi_bootarea_size;
333#if 0
334    info->fwi_reserved1 = xiocb.plist.xiocb_fwinfo.fwi_reserved1;
335    info->fwi_reserved2 = xiocb.plist.xiocb_fwinfo.fwi_reserved2;
336    info->fwi_reserved3 = xiocb.plist.xiocb_fwinfo.fwi_reserved3;
337#endif
338
339    return 0;
340}
341#endif /* CFE_API_getfwinfo || CFE_API_ALL */
342
343#if defined(CFE_API_getstdhandle) || defined(CFE_API_ALL)
344int
345cfe_getstdhandle(int flg)
346{
347    cfe_xiocb_t xiocb;
348
349    xiocb.xiocb_fcode = CFE_CMD_DEV_GETHANDLE;
350    xiocb.xiocb_status = 0;
351    xiocb.xiocb_handle = 0;
352    xiocb.xiocb_flags = flg;
353    xiocb.xiocb_psize = 0;
354
355    cfe_iocb_dispatch(&xiocb);
356
357    if (xiocb.xiocb_status < 0)
358	return xiocb.xiocb_status;
359    return xiocb.xiocb_handle;
360
361}
362#endif /* CFE_API_getstdhandle || CFE_API_ALL */
363
364#if defined(CFE_API_getticks) || defined(CFE_API_ALL)
365int64_t
366#ifdef CFE_API_IMPL_NAMESPACE
367__cfe_getticks(void)
368#else
369cfe_getticks(void)
370#endif
371{
372    cfe_xiocb_t xiocb;
373
374    xiocb.xiocb_fcode = CFE_CMD_FW_GETTIME;
375    xiocb.xiocb_status = 0;
376    xiocb.xiocb_handle = 0;
377    xiocb.xiocb_flags = 0;
378    xiocb.xiocb_psize = sizeof(xiocb_time_t);
379    xiocb.plist.xiocb_time.ticks = 0;
380
381    cfe_iocb_dispatch(&xiocb);
382
383    return xiocb.plist.xiocb_time.ticks;
384
385}
386#endif /* CFE_API_getticks || CFE_API_ALL */
387
388#if defined(CFE_API_inpstat) || defined(CFE_API_ALL)
389int
390cfe_inpstat(int handle)
391{
392    cfe_xiocb_t xiocb;
393
394    xiocb.xiocb_fcode = CFE_CMD_DEV_INPSTAT;
395    xiocb.xiocb_status = 0;
396    xiocb.xiocb_handle = handle;
397    xiocb.xiocb_flags = 0;
398    xiocb.xiocb_psize = sizeof(xiocb_inpstat_t);
399    xiocb.plist.xiocb_inpstat.inp_status = 0;
400
401    cfe_iocb_dispatch(&xiocb);
402
403    if (xiocb.xiocb_status < 0)
404	return xiocb.xiocb_status;
405    return xiocb.plist.xiocb_inpstat.inp_status;
406
407}
408#endif /* CFE_API_inpstat || CFE_API_ALL */
409
410#if defined(CFE_API_ioctl) || defined(CFE_API_ALL)
411int
412cfe_ioctl(int handle, unsigned int ioctlnum, unsigned char *buffer, int length,
413	  int *retlen, cfe_xuint_t offset)
414{
415    cfe_xiocb_t xiocb;
416
417    xiocb.xiocb_fcode = CFE_CMD_DEV_IOCTL;
418    xiocb.xiocb_status = 0;
419    xiocb.xiocb_handle = handle;
420    xiocb.xiocb_flags = 0;
421    xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
422    xiocb.plist.xiocb_buffer.buf_offset = offset;
423    xiocb.plist.xiocb_buffer.buf_ioctlcmd = ioctlnum;
424    xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer);
425    xiocb.plist.xiocb_buffer.buf_length = length;
426
427    cfe_iocb_dispatch(&xiocb);
428
429    if (retlen)
430	*retlen = xiocb.plist.xiocb_buffer.buf_retlen;
431    return xiocb.xiocb_status;
432}
433#endif /* CFE_API_ioctl || CFE_API_ALL */
434
435#if defined(CFE_API_open) || defined(CFE_API_ALL)
436int
437cfe_open(char *name)
438{
439    cfe_xiocb_t xiocb;
440
441    xiocb.xiocb_fcode = CFE_CMD_DEV_OPEN;
442    xiocb.xiocb_status = 0;
443    xiocb.xiocb_handle = 0;
444    xiocb.xiocb_flags = 0;
445    xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
446    xiocb.plist.xiocb_buffer.buf_offset = 0;
447    xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(name);
448    xiocb.plist.xiocb_buffer.buf_length = cfe_strlen(name);
449
450    cfe_iocb_dispatch(&xiocb);
451
452    if (xiocb.xiocb_status < 0)
453	return xiocb.xiocb_status;
454    return xiocb.xiocb_handle;
455}
456#endif /* CFE_API_open || CFE_API_ALL */
457
458#if defined(CFE_API_read) || defined(CFE_API_ALL)
459int
460cfe_read(int handle, unsigned char *buffer, int length)
461{
462    return cfe_readblk(handle, 0, buffer, length);
463}
464#endif /* CFE_API_read || CFE_API_ALL */
465
466#if defined(CFE_API_readblk) || defined(CFE_API_ALL)
467int
468cfe_readblk(int handle, cfe_xint_t offset, unsigned char *buffer, int length)
469{
470    cfe_xiocb_t xiocb;
471
472    xiocb.xiocb_fcode = CFE_CMD_DEV_READ;
473    xiocb.xiocb_status = 0;
474    xiocb.xiocb_handle = handle;
475    xiocb.xiocb_flags = 0;
476    xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
477    xiocb.plist.xiocb_buffer.buf_offset = offset;
478    xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer);
479    xiocb.plist.xiocb_buffer.buf_length = length;
480
481    cfe_iocb_dispatch(&xiocb);
482
483    if (xiocb.xiocb_status < 0)
484	return xiocb.xiocb_status;
485    return xiocb.plist.xiocb_buffer.buf_retlen;
486}
487#endif /* CFE_API_readblk || CFE_API_ALL */
488
489#if defined(CFE_API_setenv) || defined(CFE_API_ALL)
490int
491cfe_setenv(char *name, char *val)
492{
493    cfe_xiocb_t xiocb;
494
495    xiocb.xiocb_fcode = CFE_CMD_ENV_SET;
496    xiocb.xiocb_status = 0;
497    xiocb.xiocb_handle = 0;
498    xiocb.xiocb_flags = 0;
499    xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
500    xiocb.plist.xiocb_envbuf.enum_idx = 0;
501    xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name);
502    xiocb.plist.xiocb_envbuf.name_length = cfe_strlen(name);
503    xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(val);
504    xiocb.plist.xiocb_envbuf.val_length = cfe_strlen(val);
505
506    cfe_iocb_dispatch(&xiocb);
507
508    return xiocb.xiocb_status;
509}
510#endif /* CFE_API_setenv || CFE_API_ALL */
511
512#if (defined(CFE_API_strlen) || defined(CFE_API_ALL)) \
513    && !defined(CFE_API_STRLEN_CUSTOM)
514int
515cfe_strlen(char *name)
516{
517    int count = 0;
518
519    while (*name++)
520	count++;
521
522    return count;
523}
524#endif /* CFE_API_strlen || CFE_API_ALL */
525
526#if defined(CFE_API_write) || defined(CFE_API_ALL)
527int
528cfe_write(int handle, unsigned char *buffer, int length)
529{
530    return cfe_writeblk(handle, 0, buffer, length);
531}
532#endif /* CFE_API_write || CFE_API_ALL */
533
534#if defined(CFE_API_writeblk) || defined(CFE_API_ALL)
535int
536cfe_writeblk(int handle, cfe_xint_t offset, unsigned char *buffer, int length)
537{
538    cfe_xiocb_t xiocb;
539
540    xiocb.xiocb_fcode = CFE_CMD_DEV_WRITE;
541    xiocb.xiocb_status = 0;
542    xiocb.xiocb_handle = handle;
543    xiocb.xiocb_flags = 0;
544    xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
545    xiocb.plist.xiocb_buffer.buf_offset = offset;
546    xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer);
547    xiocb.plist.xiocb_buffer.buf_length = length;
548
549    cfe_iocb_dispatch(&xiocb);
550
551    if (xiocb.xiocb_status < 0)
552	return xiocb.xiocb_status;
553    return xiocb.plist.xiocb_buffer.buf_retlen;
554}
555#endif /* CFE_API_writeblk || CFE_API_ALL */
556