Thomas Gleixner | 1a59d1b8 | 2019-05-27 08:55:05 +0200 | [diff] [blame^] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2000, 2001, 2002 Broadcom Corporation |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | */ |
| 5 | |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 6 | /* |
| 7 | * |
| 8 | * Broadcom Common Firmware Environment (CFE) |
| 9 | * |
| 10 | * This module contains device function stubs (small routines to |
| 11 | * call the standard "iocb" interface entry point to CFE). |
| 12 | * There should be one routine here per iocb function call. |
| 13 | * |
| 14 | * Authors: Mitch Lichtenberg, Chris Demetriou |
| 15 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | |
Aurelien Jarno | df78b5c | 2007-09-05 08:58:26 +0200 | [diff] [blame] | 17 | #include <asm/fw/cfe/cfe_api.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | #include "cfe_api_int.h" |
| 19 | |
| 20 | /* Cast from a native pointer to a cfe_xptr_t and back. */ |
| 21 | #define XPTR_FROM_NATIVE(n) ((cfe_xptr_t) (intptr_t) (n)) |
| 22 | #define NATIVE_FROM_XPTR(x) ((void *) (intptr_t) (x)) |
| 23 | |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 24 | int cfe_iocb_dispatch(struct cfe_xiocb *xiocb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | /* |
| 27 | * Declare the dispatch function with args of "intptr_t". |
| 28 | * This makes sure whatever model we're compiling in |
| 29 | * puts the pointers in a single register. For example, |
| 30 | * combining -mlong64 and -mips1 or -mips2 would lead to |
| 31 | * trouble, since the handle and IOCB pointer will be |
| 32 | * passed in two registers each, and CFE expects one. |
| 33 | */ |
| 34 | |
Ralf Baechle | 982f6ff | 2009-09-17 02:25:07 +0200 | [diff] [blame] | 35 | static int (*cfe_dispfunc) (intptr_t handle, intptr_t xiocb); |
| 36 | static u64 cfe_handle; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 38 | int cfe_init(u64 handle, u64 ept) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | { |
| 40 | cfe_dispfunc = NATIVE_FROM_XPTR(ept); |
| 41 | cfe_handle = handle; |
| 42 | return 0; |
| 43 | } |
| 44 | |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 45 | int cfe_iocb_dispatch(struct cfe_xiocb * xiocb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | { |
| 47 | if (!cfe_dispfunc) |
| 48 | return -1; |
| 49 | return (*cfe_dispfunc) ((intptr_t) cfe_handle, (intptr_t) xiocb); |
| 50 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | int cfe_close(int handle) |
| 53 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 54 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | |
| 56 | xiocb.xiocb_fcode = CFE_CMD_DEV_CLOSE; |
| 57 | xiocb.xiocb_status = 0; |
| 58 | xiocb.xiocb_handle = handle; |
| 59 | xiocb.xiocb_flags = 0; |
| 60 | xiocb.xiocb_psize = 0; |
| 61 | |
| 62 | cfe_iocb_dispatch(&xiocb); |
| 63 | |
| 64 | return xiocb.xiocb_status; |
| 65 | |
| 66 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | int cfe_cpu_start(int cpu, void (*fn) (void), long sp, long gp, long a1) |
| 69 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 70 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | |
| 72 | xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL; |
| 73 | xiocb.xiocb_status = 0; |
| 74 | xiocb.xiocb_handle = 0; |
| 75 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 76 | xiocb.xiocb_psize = sizeof(struct xiocb_cpuctl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | xiocb.plist.xiocb_cpuctl.cpu_number = cpu; |
| 78 | xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_START; |
| 79 | xiocb.plist.xiocb_cpuctl.gp_val = gp; |
| 80 | xiocb.plist.xiocb_cpuctl.sp_val = sp; |
| 81 | xiocb.plist.xiocb_cpuctl.a1_val = a1; |
| 82 | xiocb.plist.xiocb_cpuctl.start_addr = (long) fn; |
| 83 | |
| 84 | cfe_iocb_dispatch(&xiocb); |
| 85 | |
| 86 | return xiocb.xiocb_status; |
| 87 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | int cfe_cpu_stop(int cpu) |
| 90 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 91 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | |
| 93 | xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL; |
| 94 | xiocb.xiocb_status = 0; |
| 95 | xiocb.xiocb_handle = 0; |
| 96 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 97 | xiocb.xiocb_psize = sizeof(struct xiocb_cpuctl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | xiocb.plist.xiocb_cpuctl.cpu_number = cpu; |
| 99 | xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_STOP; |
| 100 | |
| 101 | cfe_iocb_dispatch(&xiocb); |
| 102 | |
| 103 | return xiocb.xiocb_status; |
| 104 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | int cfe_enumenv(int idx, char *name, int namelen, char *val, int vallen) |
| 107 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 108 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | |
| 110 | xiocb.xiocb_fcode = CFE_CMD_ENV_SET; |
| 111 | xiocb.xiocb_status = 0; |
| 112 | xiocb.xiocb_handle = 0; |
| 113 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 114 | xiocb.xiocb_psize = sizeof(struct xiocb_envbuf); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | xiocb.plist.xiocb_envbuf.enum_idx = idx; |
| 116 | xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name); |
| 117 | xiocb.plist.xiocb_envbuf.name_length = namelen; |
| 118 | xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(val); |
| 119 | xiocb.plist.xiocb_envbuf.val_length = vallen; |
| 120 | |
| 121 | cfe_iocb_dispatch(&xiocb); |
| 122 | |
| 123 | return xiocb.xiocb_status; |
| 124 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | int |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 127 | cfe_enummem(int idx, int flags, u64 *start, u64 *length, u64 *type) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 129 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | |
| 131 | xiocb.xiocb_fcode = CFE_CMD_FW_MEMENUM; |
| 132 | xiocb.xiocb_status = 0; |
| 133 | xiocb.xiocb_handle = 0; |
| 134 | xiocb.xiocb_flags = flags; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 135 | xiocb.xiocb_psize = sizeof(struct xiocb_meminfo); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | xiocb.plist.xiocb_meminfo.mi_idx = idx; |
| 137 | |
| 138 | cfe_iocb_dispatch(&xiocb); |
| 139 | |
| 140 | if (xiocb.xiocb_status < 0) |
| 141 | return xiocb.xiocb_status; |
| 142 | |
| 143 | *start = xiocb.plist.xiocb_meminfo.mi_addr; |
| 144 | *length = xiocb.plist.xiocb_meminfo.mi_size; |
| 145 | *type = xiocb.plist.xiocb_meminfo.mi_type; |
| 146 | |
| 147 | return 0; |
| 148 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | int cfe_exit(int warm, int status) |
| 151 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 152 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | |
| 154 | xiocb.xiocb_fcode = CFE_CMD_FW_RESTART; |
| 155 | xiocb.xiocb_status = 0; |
| 156 | xiocb.xiocb_handle = 0; |
| 157 | xiocb.xiocb_flags = warm ? CFE_FLG_WARMSTART : 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 158 | xiocb.xiocb_psize = sizeof(struct xiocb_exitstat); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | xiocb.plist.xiocb_exitstat.status = status; |
| 160 | |
| 161 | cfe_iocb_dispatch(&xiocb); |
| 162 | |
| 163 | return xiocb.xiocb_status; |
| 164 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | int cfe_flushcache(int flg) |
| 167 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 168 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | |
| 170 | xiocb.xiocb_fcode = CFE_CMD_FW_FLUSHCACHE; |
| 171 | xiocb.xiocb_status = 0; |
| 172 | xiocb.xiocb_handle = 0; |
| 173 | xiocb.xiocb_flags = flg; |
| 174 | xiocb.xiocb_psize = 0; |
| 175 | |
| 176 | cfe_iocb_dispatch(&xiocb); |
| 177 | |
| 178 | return xiocb.xiocb_status; |
| 179 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | int cfe_getdevinfo(char *name) |
| 182 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 183 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | |
| 185 | xiocb.xiocb_fcode = CFE_CMD_DEV_GETINFO; |
| 186 | xiocb.xiocb_status = 0; |
| 187 | xiocb.xiocb_handle = 0; |
| 188 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 189 | xiocb.xiocb_psize = sizeof(struct xiocb_buffer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | xiocb.plist.xiocb_buffer.buf_offset = 0; |
| 191 | xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(name); |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 192 | xiocb.plist.xiocb_buffer.buf_length = strlen(name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | |
| 194 | cfe_iocb_dispatch(&xiocb); |
| 195 | |
| 196 | if (xiocb.xiocb_status < 0) |
| 197 | return xiocb.xiocb_status; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 198 | return xiocb.plist.xiocb_buffer.buf_ioctlcmd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | int cfe_getenv(char *name, char *dest, int destlen) |
| 202 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 203 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | |
| 205 | *dest = 0; |
| 206 | |
| 207 | xiocb.xiocb_fcode = CFE_CMD_ENV_GET; |
| 208 | xiocb.xiocb_status = 0; |
| 209 | xiocb.xiocb_handle = 0; |
| 210 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 211 | xiocb.xiocb_psize = sizeof(struct xiocb_envbuf); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | xiocb.plist.xiocb_envbuf.enum_idx = 0; |
| 213 | xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name); |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 214 | xiocb.plist.xiocb_envbuf.name_length = strlen(name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(dest); |
| 216 | xiocb.plist.xiocb_envbuf.val_length = destlen; |
| 217 | |
| 218 | cfe_iocb_dispatch(&xiocb); |
| 219 | |
| 220 | return xiocb.xiocb_status; |
| 221 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 222 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | int cfe_getfwinfo(cfe_fwinfo_t * info) |
| 224 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 225 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | |
| 227 | xiocb.xiocb_fcode = CFE_CMD_FW_GETINFO; |
| 228 | xiocb.xiocb_status = 0; |
| 229 | xiocb.xiocb_handle = 0; |
| 230 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 231 | xiocb.xiocb_psize = sizeof(struct xiocb_fwinfo); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | |
| 233 | cfe_iocb_dispatch(&xiocb); |
| 234 | |
| 235 | if (xiocb.xiocb_status < 0) |
| 236 | return xiocb.xiocb_status; |
| 237 | |
| 238 | info->fwi_version = xiocb.plist.xiocb_fwinfo.fwi_version; |
| 239 | info->fwi_totalmem = xiocb.plist.xiocb_fwinfo.fwi_totalmem; |
| 240 | info->fwi_flags = xiocb.plist.xiocb_fwinfo.fwi_flags; |
| 241 | info->fwi_boardid = xiocb.plist.xiocb_fwinfo.fwi_boardid; |
| 242 | info->fwi_bootarea_va = xiocb.plist.xiocb_fwinfo.fwi_bootarea_va; |
| 243 | info->fwi_bootarea_pa = xiocb.plist.xiocb_fwinfo.fwi_bootarea_pa; |
| 244 | info->fwi_bootarea_size = |
| 245 | xiocb.plist.xiocb_fwinfo.fwi_bootarea_size; |
| 246 | #if 0 |
| 247 | info->fwi_reserved1 = xiocb.plist.xiocb_fwinfo.fwi_reserved1; |
| 248 | info->fwi_reserved2 = xiocb.plist.xiocb_fwinfo.fwi_reserved2; |
| 249 | info->fwi_reserved3 = xiocb.plist.xiocb_fwinfo.fwi_reserved3; |
| 250 | #endif |
| 251 | |
| 252 | return 0; |
| 253 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | int cfe_getstdhandle(int flg) |
| 256 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 257 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | |
| 259 | xiocb.xiocb_fcode = CFE_CMD_DEV_GETHANDLE; |
| 260 | xiocb.xiocb_status = 0; |
| 261 | xiocb.xiocb_handle = 0; |
| 262 | xiocb.xiocb_flags = flg; |
| 263 | xiocb.xiocb_psize = 0; |
| 264 | |
| 265 | cfe_iocb_dispatch(&xiocb); |
| 266 | |
| 267 | if (xiocb.xiocb_status < 0) |
| 268 | return xiocb.xiocb_status; |
| 269 | return xiocb.xiocb_handle; |
| 270 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | int64_t |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | cfe_getticks(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 275 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | |
| 277 | xiocb.xiocb_fcode = CFE_CMD_FW_GETTIME; |
| 278 | xiocb.xiocb_status = 0; |
| 279 | xiocb.xiocb_handle = 0; |
| 280 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 281 | xiocb.xiocb_psize = sizeof(struct xiocb_time); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | xiocb.plist.xiocb_time.ticks = 0; |
| 283 | |
| 284 | cfe_iocb_dispatch(&xiocb); |
| 285 | |
| 286 | return xiocb.plist.xiocb_time.ticks; |
| 287 | |
| 288 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | int cfe_inpstat(int handle) |
| 291 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 292 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 293 | |
| 294 | xiocb.xiocb_fcode = CFE_CMD_DEV_INPSTAT; |
| 295 | xiocb.xiocb_status = 0; |
| 296 | xiocb.xiocb_handle = handle; |
| 297 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 298 | xiocb.xiocb_psize = sizeof(struct xiocb_inpstat); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | xiocb.plist.xiocb_inpstat.inp_status = 0; |
| 300 | |
| 301 | cfe_iocb_dispatch(&xiocb); |
| 302 | |
| 303 | if (xiocb.xiocb_status < 0) |
| 304 | return xiocb.xiocb_status; |
| 305 | return xiocb.plist.xiocb_inpstat.inp_status; |
| 306 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 307 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | int |
| 309 | cfe_ioctl(int handle, unsigned int ioctlnum, unsigned char *buffer, |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 310 | int length, int *retlen, u64 offset) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 312 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 313 | |
| 314 | xiocb.xiocb_fcode = CFE_CMD_DEV_IOCTL; |
| 315 | xiocb.xiocb_status = 0; |
| 316 | xiocb.xiocb_handle = handle; |
| 317 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 318 | xiocb.xiocb_psize = sizeof(struct xiocb_buffer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | xiocb.plist.xiocb_buffer.buf_offset = offset; |
| 320 | xiocb.plist.xiocb_buffer.buf_ioctlcmd = ioctlnum; |
| 321 | xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer); |
| 322 | xiocb.plist.xiocb_buffer.buf_length = length; |
| 323 | |
| 324 | cfe_iocb_dispatch(&xiocb); |
| 325 | |
| 326 | if (retlen) |
| 327 | *retlen = xiocb.plist.xiocb_buffer.buf_retlen; |
| 328 | return xiocb.xiocb_status; |
| 329 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 330 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | int cfe_open(char *name) |
| 332 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 333 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 334 | |
| 335 | xiocb.xiocb_fcode = CFE_CMD_DEV_OPEN; |
| 336 | xiocb.xiocb_status = 0; |
| 337 | xiocb.xiocb_handle = 0; |
| 338 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 339 | xiocb.xiocb_psize = sizeof(struct xiocb_buffer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | xiocb.plist.xiocb_buffer.buf_offset = 0; |
| 341 | xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(name); |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 342 | xiocb.plist.xiocb_buffer.buf_length = strlen(name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | |
| 344 | cfe_iocb_dispatch(&xiocb); |
| 345 | |
| 346 | if (xiocb.xiocb_status < 0) |
| 347 | return xiocb.xiocb_status; |
| 348 | return xiocb.xiocb_handle; |
| 349 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 350 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | int cfe_read(int handle, unsigned char *buffer, int length) |
| 352 | { |
| 353 | return cfe_readblk(handle, 0, buffer, length); |
| 354 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 356 | int cfe_readblk(int handle, s64 offset, unsigned char *buffer, int length) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 357 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 358 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | |
| 360 | xiocb.xiocb_fcode = CFE_CMD_DEV_READ; |
| 361 | xiocb.xiocb_status = 0; |
| 362 | xiocb.xiocb_handle = handle; |
| 363 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 364 | xiocb.xiocb_psize = sizeof(struct xiocb_buffer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 365 | xiocb.plist.xiocb_buffer.buf_offset = offset; |
| 366 | xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer); |
| 367 | xiocb.plist.xiocb_buffer.buf_length = length; |
| 368 | |
| 369 | cfe_iocb_dispatch(&xiocb); |
| 370 | |
| 371 | if (xiocb.xiocb_status < 0) |
| 372 | return xiocb.xiocb_status; |
| 373 | return xiocb.plist.xiocb_buffer.buf_retlen; |
| 374 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | int cfe_setenv(char *name, char *val) |
| 377 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 378 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | |
| 380 | xiocb.xiocb_fcode = CFE_CMD_ENV_SET; |
| 381 | xiocb.xiocb_status = 0; |
| 382 | xiocb.xiocb_handle = 0; |
| 383 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 384 | xiocb.xiocb_psize = sizeof(struct xiocb_envbuf); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | xiocb.plist.xiocb_envbuf.enum_idx = 0; |
| 386 | xiocb.plist.xiocb_envbuf.name_ptr = XPTR_FROM_NATIVE(name); |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 387 | xiocb.plist.xiocb_envbuf.name_length = strlen(name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 388 | xiocb.plist.xiocb_envbuf.val_ptr = XPTR_FROM_NATIVE(val); |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 389 | xiocb.plist.xiocb_envbuf.val_length = strlen(val); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | |
| 391 | cfe_iocb_dispatch(&xiocb); |
| 392 | |
| 393 | return xiocb.xiocb_status; |
| 394 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | |
Markos Chandras | 39b6f3a | 2013-06-17 13:00:36 +0000 | [diff] [blame] | 396 | int cfe_write(int handle, const char *buffer, int length) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | { |
| 398 | return cfe_writeblk(handle, 0, buffer, length); |
| 399 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | |
Markos Chandras | 39b6f3a | 2013-06-17 13:00:36 +0000 | [diff] [blame] | 401 | int cfe_writeblk(int handle, s64 offset, const char *buffer, int length) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 402 | { |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 403 | struct cfe_xiocb xiocb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 404 | |
| 405 | xiocb.xiocb_fcode = CFE_CMD_DEV_WRITE; |
| 406 | xiocb.xiocb_status = 0; |
| 407 | xiocb.xiocb_handle = handle; |
| 408 | xiocb.xiocb_flags = 0; |
Christoph Hellwig | 417345d | 2007-10-29 14:23:43 +0000 | [diff] [blame] | 409 | xiocb.xiocb_psize = sizeof(struct xiocb_buffer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 410 | xiocb.plist.xiocb_buffer.buf_offset = offset; |
| 411 | xiocb.plist.xiocb_buffer.buf_ptr = XPTR_FROM_NATIVE(buffer); |
| 412 | xiocb.plist.xiocb_buffer.buf_length = length; |
| 413 | |
| 414 | cfe_iocb_dispatch(&xiocb); |
| 415 | |
| 416 | if (xiocb.xiocb_status < 0) |
| 417 | return xiocb.xiocb_status; |
| 418 | return xiocb.plist.xiocb_buffer.buf_retlen; |
| 419 | } |