开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
cfe_api.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：10k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

cfe_api.c：源码内容
  1. /*
  2.  * Copyright (C) 2000, 2001 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.  */
  19. /*  *********************************************************************
  20.     *  Broadcom Common Firmware Environment (CFE)
  21.     *
  22.     *  Device Function stubs File: cfe_api.c
  23.     *
  24.     *  This module contains device function stubs (small routines to
  25.     *  call the standard "iocb" interface entry point to CFE).
  26.     *  There should be one routine here per iocb function call.
  27.     *
  28.     *  Author:  Mitch Lichtenberg (mpl@broadcom.com)
  29.     *
  30.     ********************************************************************* */
  33. #include "cfe_xiocb.h"
  34. #include "cfe_api.h"
  36. static long cfe_console_handle = -1;
  37. static int (*cfe_dispfunc)(long handle,cfe_xiocb_t *xiocb) = 0;
  38. static cfe_xuint_t cfe_handle = 0;
  40. /*
  41.  * This macro makes a "signed 64-bit pointer" - basically extending a regular
  42.  * pointer to its 64-bit compatibility space equivalent.
  43.  */
  44. #define BIGPTR(x) (long long) (long) (x)
  46. typedef unsigned long intptr_t;
  48. int cfe_init(cfe_xuint_t handle)
  49. {
  50. if ((*((unsigned int *) (int) CFE_APISEAL) == CFE_EPTSEAL) ||
  51.     (*((unsigned int *) (int) CFE_APISEAL_RE) == CFE_EPTSEAL) ||
  52.     (*((unsigned int *) (int) CFE_APISEAL_OLD) == CFE_EPTSEAL)) {
  53. cfe_dispfunc = (cfe_xptr_t) (int) CFE_APIENTRY;
  54. if (handle) cfe_handle = handle;
  55. return 0;
  56. } else {
  57. return -1;
  58. }
  59. }
  61. int cfe_iocb_dispatch(cfe_xiocb_t *xiocb);
  62. int cfe_iocb_dispatch(cfe_xiocb_t *xiocb)
  63. {
  64. if (!cfe_dispfunc) return -1;
  65. return (*cfe_dispfunc)(cfe_handle,xiocb);
  66. }
  68. static int cfe_strlen(char *name)
  69. {
  70. int count = 0;
  72. while (*name) {
  73. count++;
  74. name++;
  75. }
  77. return count;
  78. }
  80. int cfe_open(char *name)
  81. {
  82. cfe_xiocb_t xiocb;
  84. xiocb.xiocb_fcode = CFE_CMD_DEV_OPEN;
  85. xiocb.xiocb_status = 0;
  86. xiocb.xiocb_handle = 0;
  87. xiocb.xiocb_flags = 0;
  88. xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
  89. xiocb.plist.xiocb_buffer.buf_offset = 0;
  90. xiocb.plist.xiocb_buffer.buf_ptr = BIGPTR(name);
  91. xiocb.plist.xiocb_buffer.buf_length = cfe_strlen(name);
  93. cfe_iocb_dispatch(&xiocb);
  95. return (xiocb.xiocb_status < 0) ? xiocb.xiocb_status : xiocb.xiocb_handle;
  96. }
  98. int cfe_close(int handle)
  99. {
  100. cfe_xiocb_t xiocb;
  102. xiocb.xiocb_fcode = CFE_CMD_DEV_CLOSE;
  103. xiocb.xiocb_status = 0;
  104. xiocb.xiocb_handle = handle;
  105. xiocb.xiocb_flags = 0;
  106. xiocb.xiocb_psize = 0;
  108. cfe_iocb_dispatch(&xiocb);
  110. return (xiocb.xiocb_status);
  112. }
  114. int cfe_readblk(int handle,cfe_xint_t offset,unsigned char *buffer,int length)
  115. {
  116. cfe_xiocb_t xiocb;
  118. xiocb.xiocb_fcode = CFE_CMD_DEV_READ;
  119. xiocb.xiocb_status = 0;
  120. xiocb.xiocb_handle = handle;
  121. xiocb.xiocb_flags = 0;
  122. xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
  123. xiocb.plist.xiocb_buffer.buf_offset = offset;
  124. xiocb.plist.xiocb_buffer.buf_ptr = BIGPTR(buffer);
  125. xiocb.plist.xiocb_buffer.buf_length = length;
  127. cfe_iocb_dispatch(&xiocb);
  129. return (xiocb.xiocb_status < 0) ? xiocb.xiocb_status : xiocb.plist.xiocb_buffer.buf_retlen;
  130. }
  132. int cfe_read(int handle,unsigned char *buffer,int length)
  133. {
  134. return cfe_readblk(handle,0,buffer,length);
  135. }
  138. int cfe_writeblk(int handle,cfe_xint_t offset,unsigned char *buffer,int length)
  139. {
  140. cfe_xiocb_t xiocb;
  142. xiocb.xiocb_fcode = CFE_CMD_DEV_WRITE;
  143. xiocb.xiocb_status = 0;
  144. xiocb.xiocb_handle = handle;
  145. xiocb.xiocb_flags = 0;
  146. xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
  147. xiocb.plist.xiocb_buffer.buf_offset = offset;
  148. xiocb.plist.xiocb_buffer.buf_ptr = BIGPTR(buffer);
  149. xiocb.plist.xiocb_buffer.buf_length = length;
  151. cfe_iocb_dispatch(&xiocb);
  153. return (xiocb.xiocb_status < 0) ? xiocb.xiocb_status : xiocb.plist.xiocb_buffer.buf_retlen;
  154. }
  156. int cfe_write(int handle,unsigned char *buffer,int length)
  157. {
  158. return cfe_writeblk(handle,0,buffer,length);
  159. }
  162. int cfe_ioctl(int handle,unsigned int ioctlnum,unsigned char *buffer,int length,int *retlen)
  163. {
  164. cfe_xiocb_t xiocb;
  166. xiocb.xiocb_fcode = CFE_CMD_DEV_IOCTL;
  167. xiocb.xiocb_status = 0;
  168. xiocb.xiocb_handle = handle;
  169. xiocb.xiocb_flags = 0;
  170. xiocb.xiocb_psize = sizeof(xiocb_buffer_t);
  171. xiocb.plist.xiocb_buffer.buf_ioctlcmd = (cfe_xint_t) ioctlnum;
  172. xiocb.plist.xiocb_buffer.buf_ptr = BIGPTR(buffer);
  173. xiocb.plist.xiocb_buffer.buf_length = length;
  175. cfe_iocb_dispatch(&xiocb);
  177. if (retlen) *retlen = xiocb.plist.xiocb_buffer.buf_retlen;
  178. return xiocb.xiocb_status;
  179. }
  181. int cfe_inpstat(int handle)
  182. {
  183. cfe_xiocb_t xiocb;
  185. xiocb.xiocb_fcode = CFE_CMD_DEV_INPSTAT;
  186. xiocb.xiocb_status = 0;
  187. xiocb.xiocb_handle = handle;
  188. xiocb.xiocb_flags = 0;
  189. xiocb.xiocb_psize = sizeof(xiocb_inpstat_t);
  190. xiocb.plist.xiocb_inpstat.inp_status = 0;
  192. cfe_iocb_dispatch(&xiocb);
  194. if (xiocb.xiocb_status < 0) return xiocb.xiocb_status;
  196. return xiocb.plist.xiocb_inpstat.inp_status;
  198. }
  200. long long cfe_getticks(void)
  201. {
  202. cfe_xiocb_t xiocb;
  204. xiocb.xiocb_fcode = CFE_CMD_FW_GETTIME;
  205. xiocb.xiocb_status = 0;
  206. xiocb.xiocb_handle = 0;
  207. xiocb.xiocb_flags = 0;
  208. xiocb.xiocb_psize = sizeof(xiocb_time_t);
  209. xiocb.plist.xiocb_time.ticks = 0;
  211. cfe_iocb_dispatch(&xiocb);
  213. return xiocb.plist.xiocb_time.ticks;
  215. }
  217. int cfe_getenv(char *name,char *dest,int destlen)
  218. {
  219. cfe_xiocb_t xiocb;
  221. *dest = 0;
  223. xiocb.xiocb_fcode = CFE_CMD_ENV_GET;
  224. xiocb.xiocb_status = 0;
  225. xiocb.xiocb_handle = 0;
  226. xiocb.xiocb_flags = 0;
  227. xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
  228. xiocb.plist.xiocb_envbuf.enum_idx = 0;
  229. xiocb.plist.xiocb_envbuf.name_ptr = BIGPTR(name);
  230. xiocb.plist.xiocb_envbuf.name_length = cfe_strlen(name);
  231. xiocb.plist.xiocb_envbuf.val_ptr = BIGPTR(dest);
  232. xiocb.plist.xiocb_envbuf.val_length = destlen;
  234. cfe_iocb_dispatch(&xiocb);
  236. return xiocb.xiocb_status;
  237. }
  239. int cfe_setenv(char *name,char *val)
  240. {
  241. cfe_xiocb_t xiocb;
  243. xiocb.xiocb_fcode = CFE_CMD_ENV_SET;
  244. xiocb.xiocb_status = 0;
  245. xiocb.xiocb_handle = 0;
  246. xiocb.xiocb_flags = 0;
  247. xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
  248. xiocb.plist.xiocb_envbuf.enum_idx = 0;
  249. xiocb.plist.xiocb_envbuf.name_ptr = BIGPTR(name);
  250. xiocb.plist.xiocb_envbuf.name_length = cfe_strlen(name);
  251. xiocb.plist.xiocb_envbuf.val_ptr = BIGPTR(val);
  252. xiocb.plist.xiocb_envbuf.val_length = cfe_strlen(val);
  254. cfe_iocb_dispatch(&xiocb);
  256. return xiocb.xiocb_status;
  257. }
  259. int cfe_enummem(long idx, unsigned long long *addr, unsigned long long *size, long *type)
  260. {
  261. cfe_xiocb_t xiocb;
  262. xiocb.xiocb_fcode = CFE_CMD_FW_MEMENUM;
  263. xiocb.xiocb_status = 0;
  264. xiocb.xiocb_handle = 0;
  265. xiocb.xiocb_flags = 0;
  266. xiocb.xiocb_psize = sizeof(xiocb_meminfo_t);
  267. xiocb.plist.xiocb_meminfo.mi_idx = idx;
  269. cfe_iocb_dispatch(&xiocb);
  271. (*addr) = xiocb.plist.xiocb_meminfo.mi_addr;
  272. (*size) = xiocb.plist.xiocb_meminfo.mi_size;
  273. (*type) = xiocb.plist.xiocb_meminfo.mi_type;
  275. return xiocb.xiocb_status;
  276. }
  279. int cfe_enumenv(int idx,char *name,int namelen,char *val,int vallen)
  280. {
  281. cfe_xiocb_t xiocb;
  283. xiocb.xiocb_fcode = CFE_CMD_ENV_SET;
  284. xiocb.xiocb_status = 0;
  285. xiocb.xiocb_handle = 0;
  286. xiocb.xiocb_flags = 0;
  287. xiocb.xiocb_psize = sizeof(xiocb_envbuf_t);
  288. xiocb.plist.xiocb_envbuf.enum_idx = idx;
  289. xiocb.plist.xiocb_envbuf.name_ptr = BIGPTR(name);
  290. xiocb.plist.xiocb_envbuf.name_length = namelen;
  291. xiocb.plist.xiocb_envbuf.val_ptr = BIGPTR(val);
  292. xiocb.plist.xiocb_envbuf.val_length = vallen;
  294. cfe_iocb_dispatch(&xiocb);
  296. return xiocb.xiocb_status;
  297. }
  299. int cfe_exit(int warm, int status)
  300. {
  301. cfe_xiocb_t xiocb;
  303. xiocb.xiocb_fcode = CFE_CMD_FW_RESTART;
  304. xiocb.xiocb_status = 0;
  305. xiocb.xiocb_handle = 0;
  306. xiocb.xiocb_flags = warm ? CFE_FLG_WARMSTART : 0;
  307. xiocb.xiocb_psize = sizeof(xiocb_exitstat_t);
  308. xiocb.plist.xiocb_exitstat.status = (cfe_xint_t) status;
  310. cfe_iocb_dispatch(&xiocb);
  312. return (xiocb.xiocb_status);
  313. }
  315. int cfe_flushcache(int flg)
  316. {
  317. cfe_xiocb_t xiocb;
  319. xiocb.xiocb_fcode = CFE_CMD_FW_FLUSHCACHE;
  320. xiocb.xiocb_status = 0;
  321. xiocb.xiocb_handle = 0;
  322. xiocb.xiocb_flags = flg;
  323. xiocb.xiocb_psize = 0;
  325. cfe_iocb_dispatch(&xiocb);
  327. return xiocb.xiocb_status;
  328. }
  330. int cfe_getstdhandle(int flg)
  331. {
  332. cfe_xiocb_t xiocb;
  334. xiocb.xiocb_fcode = CFE_CMD_DEV_GETHANDLE;
  335. xiocb.xiocb_status = 0;
  336. xiocb.xiocb_handle = 0;
  337. xiocb.xiocb_flags = flg;
  338. xiocb.xiocb_psize = 0;
  340. cfe_iocb_dispatch(&xiocb);
  342. return (xiocb.xiocb_status < 0) ? xiocb.xiocb_status : xiocb.xiocb_handle;
  344. }
  346. int cfe_start_cpu(int cpu, void (*fn)(void), long sp, long gp, long a1)
  347. {
  348. cfe_xiocb_t xiocb;
  350. xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL;
  351. xiocb.xiocb_status = 0;
  352. xiocb.xiocb_handle = 0;
  353. xiocb.xiocb_flags  = 0;
  354. xiocb.xiocb_psize = sizeof(xiocb_cpuctl_t);
  355. xiocb.plist.xiocb_cpuctl.cpu_number = cpu;
  356. xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_START;
  357. xiocb.plist.xiocb_cpuctl.gp_val = gp;
  358. xiocb.plist.xiocb_cpuctl.sp_val = sp;
  359. xiocb.plist.xiocb_cpuctl.a1_val = a1;
  360. xiocb.plist.xiocb_cpuctl.start_addr = (long)fn;
  362. cfe_iocb_dispatch(&xiocb);
  364. return xiocb.xiocb_status;
  365. }
  368. int cfe_stop_cpu(int cpu)
  369. {
  370. cfe_xiocb_t xiocb;
  372. xiocb.xiocb_fcode = CFE_CMD_FW_CPUCTL;
  373. xiocb.xiocb_status = 0;
  374. xiocb.xiocb_handle = 0;
  375. xiocb.xiocb_flags  = 0;
  376. xiocb.xiocb_psize = sizeof(xiocb_cpuctl_t);
  377. xiocb.plist.xiocb_cpuctl.cpu_number = cpu;
  378. xiocb.plist.xiocb_cpuctl.cpu_command = CFE_CPU_CMD_STOP;
  380. cfe_iocb_dispatch(&xiocb);
  382. return xiocb.xiocb_status;
  383. }
  385. void cfe_open_console()
  386. {
  387. cfe_console_handle = cfe_getstdhandle(CFE_STDHANDLE_CONSOLE);
  388. }
  390. void cfe_console_print(const char *str, int len)
  391. {
  392. int res;
  394. if (cfe_console_handle != -1) {
  395. do {
  396. res = cfe_writeblk(cfe_console_handle, 0, str, len);
  397. if (res < 0)
  398. break;
  399. str += res;
  400. len -= res;
  401. } while (len);
  402. }
  403. }