#include <string.h>
#include "board.h"
#include "sdev.h"
#include "bsp.h"
#include "bspspi.h"
#include "uart.h"

/* SCCE Flags */
#define SPI_MASTER_ERR  (1<<(7-2))
#define SPI_TX_ERR      (1<<(7-3))
#define SPI_LACK_OF_BUF (1<<(7-5))
#define SPI_TX_BUF      (1<<(7-6))
#define SPI_RX_BUF      (1<<(7-7))

/* Rx BD Flags */
#define SPI_OVERRUN     (1<<(15-14))
#define SPI_RXMM_ERR    (1<<(15-15))

/* Tx BD Flags */
#define SPI_UNDERRUN    (1<<(15-14))
#define SPI_TXMM_ERR    (1<<(15-15)) 

void SpiStopOp(SpiCfgStruct *pCfg)
{
    S_SPIModeReg &= (~(1L<<(15-7))); /* disable SPI */
}

void SpiStartOp(SpiCfgStruct *pCfg)    
{
    ULONG SpiParamBase;
    struct spi_pram *SpiParam;
    
    if(pCfg->UseUcode==1)
    {
       SpiParamBase=pCfg->UcodeAdress+S_DPRAM_BASE;
       SpiParam=(struct spi_pram *)SpiParamBase;
       SpiParam->rstate=0;
       SpiParam->rbptr=SpiParam->rbase;
       SpiParam->tstate=0;
       SpiParam->tbptr=SpiParam->tbase;
    }
    
    if(pCfg->UseUcode==0)
    {
		CPM_CMD(INIT_RX_PARAMS|SPI_CH_NUM);
		CPM_CMD(INIT_TX_PARAMS|SPI_CH_NUM);
    }

    S_SPIModeReg |= (1L<<(15-7)); /* enable SPI */
}

void SpiClearBuf(DataBufStruct *pData)
{
    int i;
    pData->CurRecvBD=pData->CurSendBD=0;     
    for(i=0;i<pData->MaxRecvBD;i++)
    pData->pBaseRecvBD[i].status = BD_EMPTY|BD_INTR;
    if(i>0)pData->pBaseRecvBD[i-1].status |= BD_WRAP;
    for(i=0;i<pData->MaxSendBD;i++)
    pData->pBaseSendBD[i].status = BD_INTR|BD_LAST;
    if(i>0)pData->pBaseSendBD[i-1].status |= BD_WRAP;
}

static void SpiIsr(void* pDataBuf)
{
    USHORT starBD,tempstate;
    USHORT Events = S_SPIEventReg;

    S_SPIEventReg = Events;
    if((Events & SPI_LACK_OF_BUF ) || (Events & SPI_RX_BUF))
    {
        ((DataBufStruct*)pDataBuf)->DrvInfo.TotalRecvInt++;
        if((((DataBufStruct*)pDataBuf)->RecvEv!=NULL)
            &&(((DataBufStruct*)pDataBuf)->RecvTid!=NULL) )
        {    
            ev_send(((DataBufStruct*)pDataBuf)->RecvTid,
                       ((DataBufStruct*)pDataBuf)->RecvEv);
        }
        if((((DataBufStruct*)pDataBuf)->RecvQID!=NULL))
        {    
            q_send(((DataBufStruct *)pDataBuf)->RecvQID,
                   ((DataBufStruct *)pDataBuf)->RecvMessage);
        }
    }
    if (Events & SPI_TX_BUF)
    {
        ((DataBufStruct*)pDataBuf)->DrvInfo.TotalSendInt++;
        if((((DataBufStruct*)pDataBuf)->SendEv!=NULL)
            &&(((DataBufStruct*)pDataBuf)->SendTid!=NULL) )
        {
            ev_send(((DataBufStruct*)pDataBuf)->SendTid,
                       ((DataBufStruct*)pDataBuf)->SendEv);
        }
        if((((DataBufStruct*)pDataBuf)->SendQID!=NULL))
        {    
            q_send(((DataBufStruct *)pDataBuf)->SendQID,
                   ((DataBufStruct *)pDataBuf)->SendMessage);
        }
    }
}/* End of SpiIsr */

void SpiInit(void *pDataBuf, SpiCfgStruct *cfg )
{
    int i,clkdiv;
    USHORT temp_ushort;
    BuffDescType   *temp_bufdes;
    char *pRecvBuf,*pSendBuf;
    PDA *pda= (PDA *)(GetIMMR() & IO_MAP_MASK);
    DataBufStruct*  pData=(DataBufStruct *)pDataBuf;
    SpiCfgStruct*   pCfg =(SpiCfgStruct *)(pData+1);
    int BrgClk=BspCpuClkRate()*1000000;
    ULONG SpiParamBase;
    struct spi_pram *SpiParam=NULL;


/*-------------------------<< Initial data >>-------------------------------*/
    memmove(pCfg,cfg,sizeof(*cfg));
    memset(pData, 0, sizeof(DataBufStruct));
    
    if(pCfg->UseUcode==1)                
    {
 
       SpiParamBase=pCfg->UcodeAdress+S_DPRAM_BASE;
       SpiParam=(struct spi_pram *)SpiParamBase;
     }
    else
       SpiParamBase=S_SPI_BASE;
    
    
    pCfg->ch=0;
    if( pCfg->BaudRate<(BrgClk/16/64))pCfg->BaudRate=(BrgClk/16/64);
    if( pCfg->BaudRate>(BrgClk/4))pCfg->BaudRate=(BrgClk/4);
    pData->MaxRecvBD=pCfg->MaxRecvBD;
    pData->MaxSendBD=pCfg->MaxSendBD;
    pData->MaxBufLen=pCfg->MaxBufLen;
    pData->RecvErrMask=(SPI_OVERRUN|SPI_RXMM_ERR);
    pData->SendErrMask=(SPI_UNDERRUN|SPI_TXMM_ERR);
    pData->UncachedBuffer=pRecvBuf=pCfg->UncachedBuffer;
    pSendBuf=(char*)(pRecvBuf+( pData->MaxRecvBD)*(pData->MaxBufLen));

/*-------------------------<< stop SCCx operation >>----------------------*/
    SpiStopOp(pCfg);
/*----------------------<< init SCCx >>-----------------------------------*/
    RxFunctionCode(SpiParamBase) = MOT + DMA_SPACE;
    TxFunctionCode(SpiParamBase) = MOT + DMA_SPACE; 
    MaxRxBufferLgth(SpiParamBase) = pData->MaxBufLen;
    
    /* rx */
    temp_ushort=(unsigned short)dpram_alloc(0,pData->MaxRecvBD*BD_LEN);
    if(temp_ushort==NULL)bsp_fatal(BSPF_DPRAM_ALLOC_ERR);
    RxBDBaseAddr(SpiParamBase) = temp_ushort-0X2000;
    temp_bufdes=pData->pBaseRecvBD=(BuffDescType *)((char *)pda + temp_ushort);
    for(i=0;i<pData->MaxRecvBD;i++)
    {
        temp_bufdes[i].status=BD_EMPTY|BD_INTR;
        temp_bufdes[i].length=0;
        temp_bufdes[i].address=pRecvBuf+i*pData->MaxBufLen;
    }
    if(i>0)temp_bufdes[i-1].status|=BD_WRAP;

    /* tx */
    temp_ushort=(unsigned short)dpram_alloc(0,pData->MaxSendBD*BD_LEN);
    if(temp_ushort==NULL)bsp_fatal(BSPF_DPRAM_ALLOC_ERR);
    TxBDBaseAddr(SpiParamBase) = temp_ushort-0X2000;
    temp_bufdes=pData->pBaseSendBD=(BuffDescType *)((char *)pda+temp_ushort);
    for(i=0;i<pData->MaxSendBD;i++)
    {
        temp_bufdes[i].status=BD_INTR|BD_LAST;
        temp_bufdes[i].length=pData->MaxBufLen;
        temp_bufdes[i].address=pSendBuf+i*pData->MaxBufLen;
    }
    if(i>0)temp_bufdes[i-1].status|=BD_WRAP;

    S_SDMA_ConfigReg = 1;
    S_SPIEventReg = 0xFF;
    S_SPIMaskReg = SPI_SPIE_BSY | SPI_SPIE_TXB | SPI_SPIE_RXB;
    SPLX(S_CP_IntMaskReg |= EN_SPI;)
    clkdiv = BrgClk/(pCfg->BaudRate*4) - 1;
    if(clkdiv >= 16 )
    {
        clkdiv=BrgClk/(16*pCfg->BaudRate*4) -1;
        S_SPIModeReg = 0x0f70 + clkdiv;       /*  CP=0, CI=0  */
    }
    else 
    {
        S_SPIModeReg = 0x0770 + clkdiv;       /*  CP=0, CI=0  */
    }
    SPLX(CpmIsrAddHandler(V_SPI, SpiIsr, (void*)pData);)
         
    if(pCfg->UseUcode==0)
       SpiStartOp(pCfg);
    else if(pCfg->UseUcode==1)
    {
      *( (USHORT*)(S_SPI_BASE+0x2c) )=pCfg->UcodeAdress;
      SpiParam->rstate=0;
      SpiParam->rbptr=SpiParam->rbase;
      SpiParam->tstate=0;
      SpiParam->tbptr=SpiParam->tbase;
      SpiStartOp(pCfg);
    }
}

int SpiRead(void *pDataBuf,void *pBuf, int MaxLen)         
{   
    return BDRead(pDataBuf,(char *)pBuf,MaxLen);
}

int SpiWrite(void *pDataBuf,void *pBuf, int MaxLen)         
{   
    int ret=BDWrite(pDataBuf,(char *)pBuf,MaxLen);
    if(ret>=0)S_SPICommandReg = BIT7;
    return ret;
}

int SpiCntrl(void *pDataBuf, int cmd, void *pParam, int maxlen)
{
    int i;
    ULONG temp_ulong;
    /*PDA *pda= (PDA *)(GetIMMR() & IO_MAP_MASK); */
    DataBufStruct *pData=(DataBufStruct *)pDataBuf;
    SpiCfgStruct*   pCfg =(SpiCfgStruct *)(pData+1);
    int BrgClk,clkdiv;
    int ret=BDCntrl(pDataBuf, cmd, pParam, maxlen);
    if(ret!=SDE_UNKNOW_CMD)return ret;
    switch(cmd)
    {
        case SDC_REINIT:
            SpiStopOp(pCfg);
            dpram_dealloc(0,(char*)pData->pBaseRecvBD,BD_LEN*pData->MaxRecvBD);
            dpram_dealloc(0,(char*)pData->pBaseSendBD,BD_LEN*pData->MaxSendBD);
            SpiInit(pDataBuf,pCfg);
            SpiStartOp(pCfg);          
            break;

        case SDC_SET_LOOPBACK_MODE:
            SpiStopOp(pCfg);
            SPLX(S_SPIModeReg |= (1L<<(15-1));)
            SpiClearBuf(pData);
            SpiStartOp(pCfg);          
            break;

        case SDC_SET_NORMAL_MODE:
            SpiStopOp(pCfg);
            SPLX(S_SPIModeReg &= ~(1L<<(15-1));)
            SpiClearBuf(pData);
            SpiStartOp(pCfg);          
            break;

        case SDC_SET_BAUDRATE:
            pCfg->BaudRate=*(int *)pParam;
            SpiStopOp(pCfg);
            BrgClk=BspCpuClkRate()*1000000;
            if( pCfg->BaudRate<(BrgClk/16/64))pCfg->BaudRate=(BrgClk/16/64);
            if( pCfg->BaudRate>(BrgClk/4))pCfg->BaudRate=(BrgClk/4);
            clkdiv = BrgClk/(pCfg->BaudRate*4) - 1;
            if(clkdiv >= 16 )
            {
                clkdiv=BrgClk/(16*pCfg->BaudRate*4) -1;
                S_SPIModeReg = 0x0f70 + clkdiv;      /*  CP=0, CI=0  */
            }
            else 
            {
                S_SPIModeReg = 0x0770 + clkdiv;      /*  CP=0, CI=0  */
            }
            SpiClearBuf(pData);
            SpiStartOp(pCfg);          
            break;
            
        default: 
            return SDE_UNKNOW_CMD;

    }/* end of switch(cmd) */
    return SDE_OK;
}

char *SpiBspInit(int DEV, char *FreeMemPtr, SpiCfgStruct *cfg)
{
    cfg->UncachedBuffer
        =AllocUncachedBuffer((cfg->MaxRecvBD+cfg->MaxSendBD)*cfg->MaxBufLen,4);
    InstallSD(DEV,SpiRead,SpiWrite,SpiCntrl,FreeMemPtr);
    SpiInit(FreeMemPtr, cfg); 
    FreeMemPtr += sizeof(DataBufStruct)+sizeof(SpiCfgStruct);
    memcpy(FreeMemPtr,"**SpiDat",8);
    FreeMemPtr += 8;
    return FreeMemPtr;
}