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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
flsysfun.h
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：13k
源码类别：

VxWorks

开发平台：

C/C++

flsysfun.h：源码内容
  2. /*
  3.  * $Log:   P:/user/amir/lite/vcs/flsysfun.h_v  $
  4.    
  5.       Rev 1.9   03 Nov 1997 16:19:00   danig
  6.    flAddLongToFarPointer
  7.    
  8.       Rev 1.8   19 Oct 1997 16:08:28   danig
  9.    Documentation
  10.    
  11.       Rev 1.7   05 Oct 1997 15:31:30   ANDRY
  12.    flSwapBytes() added
  14.       Rev 1.6   10 Sep 1997 15:46:46   danig
  15.    FLBoolean
  17.       Rev 1.5   19 Aug 1997 20:06:06   danig
  18.    Andray's changes
  20.       Rev 1.4   24 Jul 1997 17:49:16   amirban
  21.    Changed name to flsysfun.h
  23.       Rev 1.3   07 Jul 1997 15:23:50   amirban
  24.    Ver 2.0
  26.       Rev 1.2   09 Jun 1996 18:17:04   amirban
  27.    Added removeTimer
  29.       Rev 1.1   12 May 1996 20:05:48   amirban
  30.    include "custom.h"
  32.       Rev 1.0   20 Mar 1996 13:33:20   amirban
  33.    Initial revision.
  34.  */
  36. /************************************************************************/
  37. /*                                                                      */
  38. /* FAT-FTL Lite Software Development Kit */
  39. /* Copyright (C) M-Systems Ltd. 1995-1996 */
  40. /* */
  41. /************************************************************************/
  44. #ifndef FLSYSFUN_H
  45. #define FLSYSFUN_H
  47. #ifdef __cplusplus
  48. extern "C" {
  49. #endif
  51. #include "flbase.h"
  53. /*----------------------------------------------------------------------*/
  54. /*                f l S y s f u n I n i t */
  55. /* */
  56. /* Do any necessary initialization for routines in this module. */
  57. /* */
  58. /* Called from fatlite.c (flInit) */
  59. /* */
  60. /* Parameters:                                                          */
  61. /*      None */
  62. /*                                                                      */
  63. /*----------------------------------------------------------------------*/
  65. extern void flSysfunInit(void);
  68. /*----------------------------------------------------------------------*/
  69. /*                        f l D e l a y L o o p                         */
  70. /*                                                                      */
  71. /* Short delay. It is BSp specific routine                              */
  72. /*                                                                      */
  73. /* Parameters:                                                          */
  74. /*      cycles          : wait loop cycles to perform                   */
  75. /*----------------------------------------------------------------------*/
  77. extern void flDelayLoop (int  cycles);
  80. /*----------------------------------------------------------------------*/
  81. /*                  f l R a n d B y t e */
  82. /* */
  83. /* Returns a random number between 0 and 255 */
  84. /* */
  85. /* Called from FTLLITE.C */
  86. /* */
  87. /* Parameters:                                                          */
  88. /*      None */
  89. /*                                                                      */
  90. /* Returns:                                                             */
  91. /* A random number between 0 and 255 */
  92. /*----------------------------------------------------------------------*/
  94. extern unsigned flRandByte(void);
  97. /*----------------------------------------------------------------------*/
  98. /*                 f l D e l a y M s e c s */
  99. /* */
  100. /* Delays execution for a number of milliseconds. */
  101. /* If there is no msec-accuracy to the clock, this routine should wait */
  102. /* at least the time specified. */
  103. /* */
  104. /* This routine may be called from the socket interface or MTD's, and */
  105. /* is not necessary for all implementations. */
  106. /* */
  107. /* Parameters:                                                          */
  108. /*      milliseconds : Milliseconds to wait */
  109. /*                                                                      */
  110. /*----------------------------------------------------------------------*/
  112. extern void flDelayMsecs(unsigned milliseconds);
  115. /*----------------------------------------------------------------------*/
  116. /*               f l I n s t a l l T i m e r */
  117. /* */
  118. /* Installs an interval timer. */
  119. /* The implementation of this routine usually means hooking a clock */
  120. /* interrupt. The polling interval is specified as a parameter. If the  */
  121. /* clock frequency is faster, the interval timer should count several */
  122. /* clock ticks before calling the interval routine. */
  123. /* */
  124. /* This routine is necessary if POLLING_INTERVAL (custom.h) is greater */
  125. /* than 0. In this case this routine will be called from socket.c  */
  126. /* (init). It will be called to install 'socketIntervalRoutine' with a */
  127. /* period specified by POLLING_INTERVAL. */
  128. /* */
  129. /* Parameters:                                                          */
  130. /*      routine : Routine to call at each interval */
  131. /* interval : Milliseconds per polling interval */
  132. /* */
  133. /* Returns: */
  134. /*  FLStatus : 0 on success, otherwise failure */
  135. /*----------------------------------------------------------------------*/
  137. extern FLStatus flInstallTimer(void (*routine)(void), unsigned interval);
  140. #ifdef EXIT
  142. /*----------------------------------------------------------------------*/
  143. /*               f l R e m o v e T i m e r  */
  144. /* */
  145. /* Removes the active interval timer. */
  146. /* This routine removes the active interval timer set by 'removeTimer'. */
  147. /* */
  148. /* Parameters:                                                          */
  149. /*      None */
  150. /*                                                                      */
  151. /*----------------------------------------------------------------------*/
  153. extern void flRemoveTimer(void);
  155. #endif
  158. /*----------------------------------------------------------------------*/
  159. /*                f l C u r r e n t D a t e */
  160. /* */
  161. /* Returns the current DOS-format date */
  162. /* */
  163. /* The DOS date format is documented in dosformt.h. */
  164. /*                                                                      */
  165. /* If a TOD clock is not available, return the value of 1/1/80. */
  166. /* */
  167. /* Parameters:                                                          */
  168. /*      None */
  169. /*                                                                      */
  170. /* Returns:                                                             */
  171. /* Current date */
  172. /*----------------------------------------------------------------------*/
  174. extern unsigned flCurrentDate(void);
  177. /*----------------------------------------------------------------------*/
  178. /*               f l C u r r e n t T i m e */
  179. /* */
  180. /* Returns the current DOS-format time */
  181. /* */
  182. /* The DOS time format is documented in dosformt.h. */
  183. /*                                                                      */
  184. /* If a TOD clock is not available, return the value of 0:00 AM. */
  185. /* */
  186. /* Parameters:                                                          */
  187. /*      None */
  188. /*                                                                      */
  189. /* Returns:                                                             */
  190. /* Current time */
  191. /*----------------------------------------------------------------------*/
  193. extern unsigned flCurrentTime(void);
  196. /*----------------------------------------------------------------------*/
  197. /*               f l C r e a t e M u t e x */
  198. /* */
  199. /* Creates and initializes a mutex object */
  200. /* */
  201. /* The mutex is initializes as not owned by anyone. */
  202. /* */
  203. /* Parameters:                                                          */
  204. /*      mutex : Pointer to mutex object */
  205. /*                                                                      */
  206. /* Returns:                                                             */
  207. /*  FLStatus : 0 on success, otherwise failure */
  208. /*----------------------------------------------------------------------*/
  210. extern FLStatus flCreateMutex(FLMutex *mutex);
  213. /*----------------------------------------------------------------------*/
  214. /*               f l D e l e t e M u t e x */
  215. /* */
  216. /* Destroys a mutex object */
  217. /* */
  218. /* This function frees any resources taken by flCreateMutex. */
  219. /* */
  220. /* Parameters:                                                          */
  221. /*      mutex : Pointer to mutex object */
  222. /*                                                                      */
  223. /* Returns:                                                             */
  224. /*  None */
  225. /*----------------------------------------------------------------------*/
  227. extern void flDeleteMutex(FLMutex *mutex);
  230. /*----------------------------------------------------------------------*/
  231. /*                 f l T a k e M u t e x */
  232. /* */
  233. /* Attempts to take ownership of a mutex. If the mutex is currently not */
  234. /* owned, TRUE is returned and the mutex becomes owned. If the mutex is */
  235. /* currently owned, FALSE is returned and ownership is not taken. */
  236. /* */
  237. /* Parameters:                                                          */
  238. /*      mutex : Pointer to mutex object */
  239. /*                                                                      */
  240. /* Returns:                                                             */
  241. /*  FLBoolean : TRUE if ownership taken, FALSE otherwise */
  242. /*----------------------------------------------------------------------*/
  244. extern FLBoolean flTakeMutex(FLMutex *mutex, int mode);
  247. /*----------------------------------------------------------------------*/
  248. /*                 f l F r e e M u t e x */
  249. /* */
  250. /* Frees ownership of a mutex */
  251. /* */
  252. /* Parameters:                                                          */
  253. /*      mutex : Pointer to mutex object */
  254. /*                                                                      */
  255. /* Returns:                                                             */
  256. /*  None */
  257. /*----------------------------------------------------------------------*/
  259. extern void flFreeMutex(FLMutex *mutex);
  262. #if FALSE
  263. /*----------------------------------------------------------------------*/
  264. /*                 f l I n p o r t b */
  265. /* */
  266. /* Reads a byte from an I/O port. */
  267. /* */
  268. /* Parameters:                                                          */
  269. /*      portId : Id or address of port */
  270. /*                                                                      */
  271. /* Returns:                                                             */
  272. /*  unsigned char : Value of I/O port */
  273. /*----------------------------------------------------------------------*/
  275. extern unsigned char flInportb(unsigned portId);
  278. /*----------------------------------------------------------------------*/
  279. /*                 f l O u t p o r t b */
  280. /* */
  281. /* Writes a byte to an I/O port. */
  282. /* */
  283. /* Parameters:                                                          */
  284. /*      portId : Id or address of port */
  285. /*      value : Value to write */
  286. /*                                                                      */
  287. /* Returns:                                                             */
  288. /*  None */
  289. /*----------------------------------------------------------------------*/
  291. extern void flOutportb(unsigned portId, unsigned char value);
  292. #endif /* FALSE */
  295. /*----------------------------------------------------------------------*/
  296. /*                 f l S w a p B y t e s */
  297. /* */
  298. /* Swap bytes in a given buffer. */
  299. /* */
  300. /* Parameters:                                                          */
  301. /*      buf : buffer that holds bytes to swap */
  302. /*      len : number of bytes to swap */
  303. /*                                                                      */
  304. /* Returns:                                                             */
  305. /*  None */
  306. /*----------------------------------------------------------------------*/
  308. extern void flSwapBytes(char FAR1 *buf, int len);
  311. /*----------------------------------------------------------------------*/
  312. /*                 f l A d d L o n g T o F a r P o i n t e r            */
  313. /* */
  314. /* Add unsigned long offset to the far pointer                          */
  315. /* */
  316. /* Parameters:                                                          */
  317. /*      ptr             : far pointer                                   */
  318. /*      offset          : offset in bytes                               */
  319. /*                                                                      */
  320. /*----------------------------------------------------------------------*/
  322. extern void FAR0* flAddLongToFarPointer(void FAR0 *ptr, unsigned long offset);
  324. /*----------------------------------------------------------------------*/
  325. /*                 f l F i t I n S o c k e t W i n d o w                */
  326. /* */
  327. /* Check if flash array fits in socket window */
  328. /* */
  329. /* Parameters: */
  330. /* chipSize : long int */
  331. /* interleaving : int */
  332. /* windowSize : long int */
  333. /* */
  334. /*----------------------------------------------------------------------*/
  336. extern long int flFitInSocketWindow (long int chipSize, int interleaving, 
  337.       long int windowSize);
  339. #ifdef __cplusplus
  340. }
  341. #endif
  343. #endif