sys/arch/sbmips/stand/common/cfe_api.c

   1 /* $NetBSD$ */
   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
  60 int 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
  72 static int (*cfe_dispfunc)(intptr_t handle, intptr_t xiocb) = 0;
  73 static cfe_xuint_t cfe_handle = 0;
  74
  75 int
  76 cfe_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
  83 int
  84 cfe_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)
  92 int
  93 cfe_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)
 111 int
 112 cfe_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)
 135 int
 136 cfe_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)
 155 int
 156 cfe_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)
 178 int
 179 cfe_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)
 205 int
 206 cfe_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)
 224 int
 225 cfe_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)
 242 int
 243 cfe_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)
 265 int
 266 cfe_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)
 290 int
 291 cfe_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)
 324 int
 325 cfe_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)
 345 int64_t
 346 #ifdef CFE_API_IMPL_NAMESPACE
 347 __cfe_getticks(void)
 348 #else
 349 cfe_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)
 369 int
 370 cfe_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)
 391 int
 392 cfe_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)
 416 int
 417 cfe_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)
 439 int
 440 cfe_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)
 447 int
 448 cfe_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)
 470 int
 471 cfe_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)
 494 int
 495 cfe_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)
 507 int
 508 cfe_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)
 515 int
 516 cfe_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 */