cust_hw_spi.h

一个基于windows mobile 的GPS 接受IC 驱动程序。

//------------------------------------------------------------------------
//
//  SPI Hardware Customization
//
//  To customize this SPI device driver, the driver programmer must provide
//  these macros to touch the hardware:
//
//      HW_SPI_PTR      Means to get a pointer to the SPI hardware.
//      HW_SPI_TYPE     The type of the SPI structure.
//      HW_SPI_BUSY     Returns 1 if the SPI is busy.
//      HW_SPI_TX_RDY   Returns 1 if the SPI transmitter has space for
//                      one byte of outgoing data.
//      HW_SPI_RX_RDY   Returns 1 if the SPI receive queue is not empty, and
//                      has at least one byte of incoming data.
//      HW_SPI_READ     Read one byte from the SPI hardware
//      HW_SPI_WRITE    Write one byte to the SPI hardware
//
//  HW_CHIP_SELECT_ON   Define this if you need means to turn on the
//                      SPI chip or get it on the bus.
//
//  HW_CHIP_SELECT_OFF  Define this if you need means to turn off the
//                      SPI chip or get it off the bus.
//
//------------------------------------------------------------------------

#ifndef CUST_HW_SPI_H__         // {
#define CUST_HW_SPI_H__

//#include "spiHardware.h"
#include "xllp_ssp.h"
#include "trace.h"

//------------------------------------------------------------------------
//
//              Adaptation Area
//
//  Map the custom hardware definitions (spiHardware.h) into specific
//  macros and datatypes needed by the generic GpsDeviceDriver.c when it
//  reads and writes SPI bytes.
//
//------------------------------------------------------------------------

//using namespace SSP;

extern volatile XLLP_SSP_REGS *v_pSPIRegs;   

 
typedef volatile XLLP_SSP_REGS* HW_SPI_TYPE;
#define HW_SPI_PTR 		v_pSPIRegs


inline void HW_SPI_WRITE(HW_SPI_TYPE p, unsigned char data)
{
    p->ssdr     = data;
    // p->cr.sen = 1;
    // p->cr.spe = 1;
}

inline unsigned char HW_SPI_READ(HW_SPI_TYPE p)
{
    return (unsigned char)(p->ssdr & 0xFF);
}

inline DWORD HW_SPI_BUSY(DWORD val)
{
    if (val & XXLP_SSSP_BSY)       return 1; 	// SPI is busy.
    if (val & XXLP_SSSP_TFL_MASK)  return 1; 	// SPI TX queue is not empty

    //  Now, the SPI TX queue is empty or completely full
    if (val & XXLP_SSSP_TNF)       return 0; 	// SPI TX is not full (empty)
    return 1;                            		// SPI TX queue is full.
}

inline DWORD HW_SPI_BUSY(HW_SPI_TYPE p)
{
    return HW_SPI_BUSY(p->ssr);
}

inline DWORD HW_SPI_RX_RDY(HW_SPI_TYPE p)
{
    return p->ssr & XXLP_SSSP_RNE;
}

inline DWORD HW_SPI_RX_RDY(DWORD val)
{
    return val & XXLP_SSSP_RNE;
}

inline DWORD HW_SPI_TX_RDY(HW_SPI_TYPE p)
{
    return p->ssr & XXLP_SSSP_TNF;
}

inline DWORD HW_SPI_CR0()
{
    return HW_SPI_PTR->sscr0;
}

inline DWORD HW_SPI_CR1()
{
    return HW_SPI_PTR->sscr1;
}

inline DWORD HW_SPI_STAT(HW_SPI_TYPE p)
{
    return p->ssr;
}

inline void HW_CHIP_SELECT_ON()
{
    DWORD tmp = v_pSPIRegs->sscr0 | XLLP_SSCR0_SSE;
    v_pSPIRegs->sscr0 = tmp;
    TRACE(TR_SPI_CMD, tmp);
}

inline void HW_CHIP_SELECT_OFF()
{
    DWORD tmp = v_pSPIRegs->sscr0 & ~XLLP_SSCR0_SSE;
    v_pSPIRegs->sscr0 = tmp;
    TRACE(TR_SPI_CMD, tmp);
}

#endif // CUST_HW_SPI_H__         // }