fw.c

FS7805 使用APLIF的demoFS7805 使用APLIF的demo

{
    if (!(EP1FIFOCS & bmFIFO0_FULL))
    {
        FifoIn(pReadBuffer, DataLen);
    }

    if (!(EP1FIFOCS & bmFIFO0_FULL))
    {
        SendDataCmd();
    }
}


/*
*********************************************************************************************************
*                                             FIFOOUT
*
* Description: Device receive data from host using FIFO function
*
* Arguments  : pReadBuffer   buffer address
*
* Returns    : none
*********************************************************************************************************
*/
void  FifoOut (INT8U *pReadBuffer)
{
    Length.Byte[1]      = EP2CNT0L;                    // Get low byte data
    Length.Byte[0]      = EP2CNTH & 0x07;              // Get high byte data
    UsbDmaBuffer        = DMA_FIFO2_0;                 // Get FIFO address

    memcpy(pReadBuffer, (INT8U xdata *)UsbDmaBuffer, Length.Val);

                                                       // Clear FULL bit
    EP2FIFOCS           = (EP2FIFOCS | bmFIFO0_FULL_WE) & (~bmFIFO0_FULL);

    EP2CS               = EP2CS | bmEP_RXTXEN;         // Enable RXTX
}


/*
*********************************************************************************************************
*                                             FIFOIN
*
* Description: Device send data to host using FIFO function
*
* Arguments  : pReadBuffer   buffer address
*
*              DataLen       Data Length
*
* Returns    : none
*********************************************************************************************************
*/
void  FifoIn (INT8U *pReadBuffer, INT16U DataLen)
{
    union
    {
        INT8U   Val;
        struct
        {
            INT8U   Count0 : 3;
            INT8U          : 1;
            INT8U   Count1 : 3;
            INT8U          : 1;
        } Bit;
    } HighReg;

    Length.Val              = DataLen;
    HighReg.Val             = EP1CNTH;

    EP1CNT0L                = Length.Byte[1];          // Write count low byte
    HighReg.Bit.Count0      = Length.Byte[0] & 0x07;
    HighReg.Val             = HighReg.Val | bmCNT0HWEN;
    EP1CNTH                 = HighReg.Val;             // Write count high byte
    UsbDmaBuffer            = DMA_FIFO1_0;             // Get FIFO address

    memcpy((INT8U xdata *)UsbDmaBuffer, pReadBuffer, DataLen);
                                                       // Copy data
}

void WriteData_APLIF(INT8U *pReadBuffer, INT16U DataLen)
{
    if (!(EP1FIFOCS & bmFIFO0_FULL))
    {
        FifoIn(pReadBuffer, DataLen);
        EP1FIFOCS   = (EP1FIFOCS | bmFIFO0_FULL_WE) | bmFIFO0_FULL; // Set FULL bit
        SFI_SKIP        = 0x04;
        while (!AplifIdle());                          //wait for aplif idle
        APLIFTCL        = (DataLen >> 1) & 0xFF;       //set transaction count value
        APLIFTCH        = (DataLen >> 1) >> 8;
        EP1APLIFTRIG    = 0xAA;                        //start write ,use wave 2
        while (!AplifIdle());                          //wait for write done
        EP1CS      = EP1CS | bmEP_RXTXEN;              //enable usb receive next frame data
    }
}

/*
*********************************************************************************************************
*                                             SENDDATACMD
*
* Description: Complete IN operation function
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/
void  SendDataCmd (void)
{
                                                       // Set FULL bit
    EP1FIFOCS   = (EP1FIFOCS | bmFIFO0_FULL_WE) | bmFIFO0_FULL;

    EP1CS       = EP1CS | bmEP_RXTXEN;                 // Enable RXTX
}


#endif

/*
*********************************************************************************************************
*                                             USBDATAWRITE
*
* Description: device write data to host
*
* Arguments  : pReadBuffer   buffer address
*
*              DataLen       data length
*
* Returns    : none
*********************************************************************************************************
*/
void  UsbDataWrite (INT8U *pReadBuffer, INT16U DataLen)
{
    UsbBulkIn(pReadBuffer, DataLen);                   // Write data
}


/*
*********************************************************************************************************
*                                             USBDATAREAD
*
* Description: device read data from host
*
* Arguments  : pReadBuffer   buffer address
*
* Returns    : Data length
*********************************************************************************************************
*/
INT16U  UsbDataRead (INT8U *pReadBuffer)
{
    UsbBulkOut(pReadBuffer);                           // Read data
    return (Length.Val);
}

void McuInit(void)
{
    WDTRST  = 0x2D;                                    // Disable WDT
    SYS_CFG = SYS_CFG | bmPM_AVBLE;                    // Firmware process USB protocol, 30MHz
    SYS_CFG = SYS_CFG & (~bmBIT0) | bmBIT1;            // SYS_CFG use default value, 30MHz
    MEMCON  = 0x08;                                    // XDATA memory configuration
}
/*
*********************************************************************************************************
*                                             TDINIT
*
* Description: Task Dispatcher hooks function
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/
void  TdInit (void)
{
    INT16U  i;

    UsbInit();

    EA          = TRUE;                                // Enable All interrupt

    USBGCTRL    = USBGCTRL & (~bmPLUG);
    for (i = 0; i < 0xFFFF; i++);
    USBGCTRL    = USBGCTRL | bmPLUG;
    for (i = 0; i < 0xFFFF; i++);

    while (!Configuration);                            // detect USB speed
    KsocInit();
}



/*
*********************************************************************************************************
*                                             USBINIT
*
* Description: USB Initialization
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/
void  UsbInit (void)
{
    union
    {
        INT8U   Val;
        struct
        {
            INT8U   EpType : 2;
            INT8U   EpDir  : 1;
            INT8U   EpEn   : 1;
            INT8U   EpMap  : 4;
        } Bit;
    } Ep1Reg, Ep2Reg;

    Selfpwr     = TRUE;                                // Enable self powered
    Rwuen       = FALSE;                               // Disable remote wake up
    Configuration   = FALSE;
    OutData     = FALSE;
    InData      = FALSE;
    OutCnt      = 0x00;
    InCnt       = 0x00;

// initialize endpoint
#ifndef FIFO_SIZE_1024
    #ifdef  PINGPONG_FIFO
    EPFIFOCFG   = 0x55;                                // 512 Ping-Pong
    #else
    EPFIFOCFG   = 0x00;                                // 512 Single
    #endif
#else
    #ifdef  PINGPONG_FIFO
    EPFIFOCFG   = 0xFF;                                // 1024 Ping-Pong
    #else
    EPFIFOCFG   = 0xAA;                                // 1024 Single
    #endif
#endif
#ifdef ISOCHRONOUS
    Ep1Reg.Bit.EpType   = bmEP_TYPE_ISO;               // EP1 Isochronous In Enable
    Ep1Reg.Bit.EpDir    = TRUE;
    Ep1Reg.Bit.EpEn     = TRUE;
    Ep1Reg.Bit.EpMap    = bmEP1MAP;
    Ep2Reg.Bit.EpType   = bmEP_TYPE_ISO;               // EP2 Isochronous Out Enable
    Ep2Reg.Bit.EpDir    = FALSE;
    Ep2Reg.Bit.EpEn     = TRUE;
    Ep2Reg.Bit.EpMap    = bmEP2MAP;
#endif
#ifdef BULK
    Ep1Reg.Bit.EpType   = bmEP_TYPE_BULK;              // EP1 Bulk In Enable
    Ep1Reg.Bit.EpDir    = TRUE;
    Ep1Reg.Bit.EpEn     = TRUE;
    Ep1Reg.Bit.EpMap    = bmEP1MAP;
    Ep2Reg.Bit.EpType   = bmEP_TYPE_BULK;              // EP2 Bulk Out Enable
    Ep2Reg.Bit.EpDir    = FALSE;
    Ep2Reg.Bit.EpEn     = TRUE;
    Ep2Reg.Bit.EpMap    = bmEP2MAP;
#endif
#ifdef INTERRUPT
    Ep1Reg.Bit.EpType   = bmEP_TYPE_INT;               // EP1 Interrupt In Enable
    Ep1Reg.Bit.EpDir    = TRUE;
    Ep1Reg.Bit.EpEn     = TRUE;
    Ep1Reg.Bit.EpMap    = bmEP1MAP;
    Ep2Reg.Bit.EpType   = bmEP_TYPE_INT;               // EP2 Interrupt Out Enable
    Ep2Reg.Bit.EpDir    = FALSE;
    Ep2Reg.Bit.EpEn     = TRUE;
    Ep2Reg.Bit.EpMap    = bmEP2MAP;
#endif
    EP1CTRL     = Ep1Reg.Val;
    EP2CTRL     = Ep2Reg.Val;
    EP1CS       = EP1CS & (~bmEP_SESTALL);             // Disable EP1 STALL
    EP2CS       = EP2CS & (~bmEP_SESTALL);             // Disable EP2 STALL
    EP2CS       = EP2CS | bmEP_RXTXEN;                 // Enable EP2 RXTX

#ifdef  FIFO_SIZE_1024
    #ifdef  PINGPONG_FIFO
    EPBCS       = EPBCS & (~bmEP_EN);
    EPDCS       = EPDCS & (~bmEP_EN);
    #endif
#endif
// End initialize endpoint

    EP0RXCS     = EP0RXCS | bmRX0_EN;                  // Enable EP0 RX

    EPIE        = EPIE | bmRX0IE;                      // Enable EP0 RX Event interrupt
    EPIE        = EPIE | bmEP1INT | bmEP2INT;          // Enable EP1 EP2 interrupt
    STIE       |= bmIDLE3MIE | bmRESUMEIE | bmUSBRSTIE;// Enable USB reset, suspend, resume interrupt

    IE5         = TRUE;                                // Enable USB interrupt
}


/*
*********************************************************************************************************
*                                             SFIINIT
*
* Description: SlaveFIFO initialization function
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/
void  KsocInit (void)
{
    // initialize sfi register
    SYSIO_CFG       = 0x92;                            // pins for PLIF mode

    SFI_EPCFG       = 0x01;                            // Manual, 16-bit, Parallel mode, not swap
    SFI_EPINTE      = 0x05;                            // enable sfi interrupt
    // End initialize sfi register

    // initialize plif register
    APLIFDM_CTL     = 0x08;                            // Half-Duplex mode, State Output
    APLIFIOCFG      = 0x00;                            // TRICTL = 0, CTL[5:0] is CMOS, Tri-state Data Bus when IDLE
    APLIFIDLECTL    = 0xff;                            // APLIF_CTL Output State in the Idle State
    APLIFREADYCFG   = 0x50;                            // use tc as the end
    APLIFWAVESEL    = 0x1B;                            // APLIF Waveform Selector
    memcpy(WAVEDATA0, WaveData, 128);                  // Copy wave data

    P3CFG           = 0xFE;                            // Enable APLIFADR[7:0]/[15:8]
    P3OE            = 0xFE;                            // Address Output
    P0CFG           = 0xFF;                            // Enable APLIFADR[15:8]/[7:0]
    P0OE            = 0xFF;                            // Address Output
    // End initialize plif register

}