flsysfun.h

M-System DOC(Disk on a Chip) Flash芯片的诊断工具, 可以从Flash芯片中获取特定的数据信息, 用于判断芯片当前的状态.

/*      None                                                            */
/*                                                                      */
/* Returns:                                                             */
/*        Current date                                                  */
/*----------------------------------------------------------------------*/

extern unsigned flCurrentDate(void);


/*----------------------------------------------------------------------*/
/*                      f l C u r r e n t T i m e                       */
/*                                                                      */
/* Returns the current DOS-format time                                  */
/*                                                                      */
/* The DOS time format is documented in dosformt.h.                     */
/*                                                                      */
/* If a TOD clock is not available, return the value of 0:00 AM.        */
/*                                                                      */
/* Parameters:                                                          */
/*      None                                                            */
/*                                                                      */
/* Returns:                                                             */
/*        Current time                                                  */
/*----------------------------------------------------------------------*/

extern unsigned flCurrentTime(void);


/*----------------------------------------------------------------------*/
/*                      f l C r e a t e M u t e x                       */
/*                                                                      */
/* Creates and initializes a mutex object                               */
/*                                                                      */
/* The mutex is initializes as not owned by anyone.                     */
/*                                                                      */
/* Parameters:                                                          */
/*      mutex                : Pointer to mutex object                  */
/*                                                                      */
/* Returns:                                                             */
/*         FLStatus        : 0 on success, otherwise failure            */
/*----------------------------------------------------------------------*/

extern FLStatus flCreateMutex(FLMutex *mutex);


/*----------------------------------------------------------------------*/
/*                      f l D e l e t e M u t e x                       */
/*                                                                      */
/* Destroys a mutex object                                              */
/*                                                                      */
/* This function frees any resources taken by flCreateMutex.            */
/*                                                                      */
/* Parameters:                                                          */
/*      mutex                : Pointer to mutex object                  */
/*                                                                      */
/* Returns:                                                             */
/*         None                                                         */
/*----------------------------------------------------------------------*/

extern void flDeleteMutex(FLMutex *mutex);


/*----------------------------------------------------------------------*/
/*                        f l T a k e M u t e x                         */
/*                                                                      */
/* Attempts to take ownership of a mutex. If the mutex is currently not */
/* owned, TRUE is returned and the mutex becomes owned. If the mutex is */
/* currently owned, FALSE is returned and ownership is not taken.       */
/*                                                                      */
/* Parameters:                                                          */
/*      mutex                : Pointer to mutex object                  */
/*                                                                      */
/* Returns:                                                             */
/*         FLBoolean        : TRUE if ownership taken, FALSE otherwise  */
/*----------------------------------------------------------------------*/

extern FLBoolean flTakeMutex(FLMutex *mutex);


/*----------------------------------------------------------------------*/
/*                        f l F r e e M u t e x                         */
/*                                                                      */
/* Frees ownership of a mutex                                           */
/*                                                                      */
/* Parameters:                                                          */
/*      mutex                : Pointer to mutex object                  */
/*                                                                      */
/* Returns:                                                             */
/*         None                                                         */
/*----------------------------------------------------------------------*/

extern void flFreeMutex(FLMutex *mutex);


/*----------------------------------------------------------------------*/
/*                        f l I n p o r t b                             */
/*                                                                      */
/* Reads a byte from an I/O port.                                       */
/*                                                                      */
/* Parameters:                                                          */
/*      portId                : Id or address of port                   */
/*                                                                      */
/* Returns:                                                             */
/*         unsigned char        : Value of I/O port                     */
/*----------------------------------------------------------------------*/

extern FLByte flInportb(unsigned portId);


/*----------------------------------------------------------------------*/
/*                        f l O u t p o r t b                           */
/*                                                                      */
/* Writes a byte to an I/O port.                                        */
/*                                                                      */
/* Parameters:                                                          */
/*      portId                : Id or address of port                   */
/*      value                : Value to write                           */
/*                                                                      */
/* Returns:                                                             */
/*         None                                                         */
/*----------------------------------------------------------------------*/

extern void flOutportb(unsigned portId, FLByte value);


/*----------------------------------------------------------------------*/
/*                            f l S w a p B y t e s                     */
/*                                                                      */
/* Swap bytes in a given buffer.                                        */
/*                                                                      */
/* Parameters:                                                          */
/*      buf      : buffer that holds bytes to swap                      */
/*      len      : number of bytes to swap                              */
/*                                                                      */
/* Returns:                                                             */
/*     None                                                             */
/*----------------------------------------------------------------------*/

extern void flSwapBytes(FLSByte FAR1 *buf, int len);

#endif /* FLSYSFUN_H */