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