s3c2410_can.h

ce下S3C2410的SPI口转CAN的驱动

#ifndef __S3C2410_CAN_H__   
    #define __S3C2410_CAN_H__

#ifdef __cplusplus
extern "C" {
#endif

#define try                             __try
#define except                          __except
//
// Macros to maintain a usage count for a particular spi structure,
// so that we know when it is safe to deallocate it.
//
#define COM_INC_USAGE_CNT(pOpenHead)  \
    InterlockedIncrement((long*)(&pOpenHead->StructUsers))

#define COM_DEC_USAGE_CNT(pOpenHead)  \
    InterlockedDecrement((long*)(&pOpenHead->StructUsers))

#define EXCEPTION_ACCESS_VIOLATION STATUS_ACCESS_VIOLATION 
//
// The spi event structure contains fields used to pass Spi
// event information from the PDD to the MDD.  This information
// is passed via a callback, so the scope of this structure remains
// limited to the MDD.
//
typedef struct __COMM_EVENTS
{
	HANDLE  hCommEvent;			// @field Indicates spi events from PDD to MDD
	ULONG	fEventMask;			// @field Event Mask requestd by application 
	ULONG	fEventData;			// @field Event Mask Flag. 
    ULONG   fAbort;             // @field TRUE after SetCommMask( 0 )
	CRITICAL_SECTION EventCS;	    //  CommEvent access and related sign atom
	
} COMM_EVENTS, *PCOMM_EVENTS;


/*
 @doc
 @struct RX_BUFFER_INFO | Driver Receive Buffer Information.
 */
typedef struct __RX_BUFFER_INFO 
{
	ULONG	Read;				/* @field Current Read index. */
	ULONG	Write;				/* @field Current Write index. */
	ULONG	Length;				/* @field Length of buffer */
	BOOL	DataAvail;			/* @field BOOL reflecting existence of data. */
	PUCHAR	RxCharBuffer;		/* @field Start of buffer */
	CRITICAL_SECTION	CS;		/* @field Critical section */
	
} RX_BUFFER_INFO, *PRX_BUFFER_INFO;

#define RxResetFifo(pSH)   pSH->RxBufferInfo.Write = pSH->RxBufferInfo.Read = 0
#define RxEnterCS(pSH)	   EnterCriticalSection (&(pSH->RxBufferInfo.CS))
#define RxLeaveCS(pSH)	   LeaveCriticalSection (&(pSH->RxBufferInfo.CS))
#define RxWrite(pSH)	   (pSH->RxBufferInfo.Write)
#define RxRead(pSH)		   (pSH->RxBufferInfo.Read)
#define RxLength(pSH)	   (pSH->RxBufferInfo.Length)
// Don't use the power of 2 trick for length, because the PDD has option of overriding
// buffer length, and may not specify a power of 2.  Lets be more flexible & a very
// little bit slower.
// #define RxBytesAvail(pSH)  ((RxWrite(pSH) - RxRead(pSH)) & (RxLength(pSH) - 1))
#define RxBytesAvail(pSH)   ( (RxWrite(pSH) >= RxRead(pSH)) ? (RxWrite(pSH) - RxRead(pSH)) : (RxLength(pSH) - RxRead(pSH) + RxWrite(pSH)) )

#define RxBuffWrite(pSH)   (pSH->RxBufferInfo.RxCharBuffer+pSH->RxBufferInfo.Write)
#define RxBuffRead(pSH)	   (pSH->RxBufferInfo.RxCharBuffer+pSH->RxBufferInfo.Read)

typedef struct __TX_BUFFER_INFO 
{
	DWORD	Permissions;		/* @field Current permissions */
	ULONG	Read;				/* @field Current Read index. */
	ULONG	Length;				/* @field Length of buffer */
	PUCHAR	TxCharBuffer;		/* @field Start of buffer */
	CRITICAL_SECTION	CS;		/* @field Critical section */

} TX_BUFFER_INFO, *PTX_BUFFER_INFO;

#define TxEnterCS(pSH)	   EnterCriticalSection (&(pSH->TxBufferInfo.CS))
#define TxLeaveCS(pSH)	   LeaveCriticalSection (&(pSH->TxBufferInfo.CS))
#define TxRead(pSH)		   (pSH->TxBufferInfo.Read)
#define TxLength(pSH)	   (pSH->TxBufferInfo.Length)
#define TxBytesAvail(pSH)  (TxLength(pSH)-TxRead(pSH))
#define TxBuffRead(pSH)	   (pSH->TxBufferInfo.TxCharBuffer+pSH->TxBufferInfo.Read)

typedef VOID (*COMMFUNC)(PVOID	pHead);

// Forward declare for use below
typedef struct __HW_OPEN_INFO HW_OPEN_INFO, *PHW_OPEN_INFO;

// @struct	HW_INDEP_INFO | Hardware Independent Spi Driver Head Information.
typedef struct __HW_INDEP_INFO 
{   
	DWORD          dwIntID; 
	ULONG          bEINT;
	BOOL           fSW_EnTxINT;   // S/W flag of Enable Tx interrupt.
	BOOL           RxDiscard;   // S/W flag of Enable Tx interrupt.
//	ULONG          OpenCount;	    // @field Count of simultaneous opens.           
//    ULONG		   CommErrors;		// @field Bitfield representing Win32 comm error status.      
    DWORD          dwDevIndex;     // @field Index of device
	CRITICAL_SECTION	TransmitCritSec; // @field Protects SPI Registers for non-atomic accesses
    CRITICAL_SECTION	RegCritSec; // @field Protects SPI 

	CRITICAL_SECTION	TransmitCritSec1;		// @field Protects tx action
	CRITICAL_SECTION	ReceiveCritSec1;		// @field Protects rx action
    
	HANDLE			hSpiEvent;	// @field Spi event, both rx and tx
	HANDLE			hReadEvent;		// @field Spi event, both rx and tx
	HANDLE			hKillDispatchThread;	// @field Synchonize thread end
	HANDLE			hTransmitEvent;	// @field transmit event, both rx and tx

	HANDLE			pDispatchThread;// @field ReceiveThread 
	ULONG			Priority256;    // @field CeThreadPriority of Dispatch Thread.
	ULONG			DroppedBytes;// @field Record of bytes dropped by MDD.
	
	ULONG			RxBytes;	    // @field Record of total bytes received.
	ULONG			TxBytes;	    // @field Record of total bytes transmitted.
	ULONG			TxBytesPending;	// @field Record of total bytes awaiting transmit.
	ULONG			TxBytesSent;	// @field Record of bytes sent in one transmission
	
	COMMTIMEOUTS	CommTimeouts;	// @field Time control field. 

	DWORD			OpenCnt;		// @field Protects use of this port 
	DWORD			KillRxThread:1;	// @field Flag to terminate SpiDispatch thread.
	DWORD           fAbortRead:1;   // @field Used for PURGE
    DWORD           fAbortTransmit:1;// @field Used for PURGE
	DWORD           BaudRate:29;    //@BaudRate
//	DWORD			Reserved:29;	// @field remaining bits.
	
	ULONG	        fEventMask;		// @field Sum of event mask for all opens
	
	RX_BUFFER_INFO	RxBufferInfo;	// @field rx buffer info.
	TX_BUFFER_INFO	TxBufferInfo;	// @field tx buffer info.

    LIST_ENTRY      OpenList;       // @field Head of linked list of OPEN_INFOs    
	CRITICAL_SECTION OpenCS;	    // @field Protects Open Linked List + ref counts

    PHW_OPEN_INFO   pAccessOwner;   // @field Points to whichever open has access permissions

} HW_INDEP_INFO, *PHW_INDEP_INFO;

// @struct	HW_OPEN_INFO | Info pertaining to each open instance of a device
typedef struct __HW_OPEN_INFO 
{
    PHW_INDEP_INFO  pSpiHead;    // @field Pointer back to our HW_INDEP_INFO
    DWORD	        AccessCode;     // @field What permissions was this opened with
    DWORD	        ShareMode;      // @field What Share Mode was this opened with
    DWORD           StructUsers;    // @field Count of threads currently using struct.
	COMM_EVENTS		CommEvents;		// @field Contains all info for Spi event handling
    LIST_ENTRY      llist;          // @field Linked list of OPEN_INFOs
	
} HW_OPEN_INFO, *PHW_OPEN_INFO;

#ifdef __cplusplus
}
#endif

#define RX_BUFFER_SIZE		        1024

#define READ_TIMEOUT			    25
#define READ_TIMEOUT_MULTIPLIER		1
#define READ_TIMEOUT_CONSTANT		10
#define WRITE_TIMEOUT_MULTIPLIER	1
#define WRITE_TIMEOUT_CONSTANT		10

#define DEFAULT_CE_THREAD_PRIORITY  103

PVOID   SER_RegAlloc(PVOID addr, INT sz);
VOID	SER_VirtualFree(VOID);
BOOL	SPI_VirtualAlloc(VOID);
VOID    EflgEventHandler(PHW_INDEP_INFO pSpiHead);
VOID    SpiEventHandler(PHW_INDEP_INFO pSpiHead);
VOID    EvaluateEventFlag(PVOID pHead, ULONG fdwEventMask);

HANDLE  SPI_Init(ULONG Identifier);
BOOL    SPI_Deinit(PHW_INDEP_INFO pSpiHead);
BOOL    SPI_Close(PHW_OPEN_INFO pOpenHead);
HANDLE  SPI_Open(HANDLE pHead, DWORD AccessCode, DWORD ShareMode);
ULONG   SPI_Read(HANDLE pHead, PUCHAR pTargetBuffer, ULONG BufferLength);
ULONG   SPI_Write(HANDLE pHead, PUCHAR pSourceBytes, ULONG  NumberOfBytes);
ULONG   SPI_Seek(HANDLE pHead, LONG Position, DWORD Type);
BOOL    SPI_PowerUp(HANDLE pHead);
BOOL    SPI_PowerDown(HANDLE pHead);
BOOL    SPI_IOControl(PHW_OPEN_INFO pOpenHead, DWORD dwCode, PBYTE pBufIn,
                      DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut, PDWORD pdwActualOut);

#endif __S3C2410_CAN_H__