drvddc2bi.c

mstar 776 开发的车载dvd

U8 DDCBuffer[MaxBufLen];
U8 txStatus;
U8 *txBufferPtr;
U8 txLength;
U8 rxStatus;
U8 rxLength;
U8 rxChkSum;
U8 rxIndex;

U16 DDClength;
U8 DDC_StatusFlag;

U8 g_ucCI_Port;
U8 g_ucReceiveCounter;

#define RxBusyFlagBit               _BIT0
#define NMVAddrFlagBit              _BIT1

#define Set_RxBusyFlag()            (DDC_StatusFlag |= RxBusyFlagBit)
#define Clr_RxBusyFlag()            (DDC_StatusFlag &= ~RxBusyFlagBit)
#define Get_RxBusyFlag()            (DDC_StatusFlag & RxBusyFlagBit)

#define Set_DDC_NMVAddrFlag()       (DDC_StatusFlag |= NMVAddrFlagBit)
#define Clr_DDC_NMVAddrFlag()       (DDC_StatusFlag &= ~NMVAddrFlagBit)
#define Get_DDC_NMVAddrFlag()       (DDC_StatusFlag & NMVAddrFlagBit)

//=======================================================================

//=======================================================================

static CALLBACK_AlignControl AlignControlCallback;

void MDrv_DDC2BI_Set_Callback(CALLBACK_AlignControl align_control)
{
    AlignControlCallback = align_control;
}

void MDrv_DDC2BI_InitRx(void)
{
    rxStatus = DDC2B_CLEAR; // clear the rxState
    rxIndex = 0;            // the current buffer for a new message
    g_ucReceiveCounter = 0;
}

void MDrv_DDC2BI_Init(void)
{
    rxLength = 0;
    rxChkSum = 0;
    rxIndex = 0;
    txLength = 0;

    DDC_StatusFlag = 0;         // initialize various flags and data items
    MDrv_DDC2BI_InitRx();
    txStatus = DDC2B_CLEAR;     // initialize transmit status

    XBYTE[DDC2BI_ADC_ID] = 0xB7;
    MDrv_DDC2BI_Set_INT_FLAG(0x7F);                 //Clear all interrupt flag

    XBYTE[DDC2BI_CTRL] = 0x00;

    //Stop/R/W/RW/Word  : enable
    //Start/ID          : disable
    MDrv_DDC2BI_Set_INT_Mask(0x67);  // enable read and write status interrupt

    //enable interrupt mask
    XBYTE[0x2b1b] &=(~BIT2);
}

U8 MDrv_DDC2BI_Get_INT_FLAG(void)
{
    return XBYTE[DDC2BI_ADC_INT_FLAG];
}

void MDrv_DDC2BI_Set_INT_FLAG(U8 u8Flag)
{
    XBYTE[DDC2BI_ADC_INT_CLR] = u8Flag;
    XBYTE[DDC2BI_ADC_INT_CLR] = 0x00;
}

void MDrv_DDC2BI_Set_INT_Mask(U8 u8Mask)
{
    XBYTE[DDC2BI_ADC_INT_MASK] = u8Mask;
    XBYTE[DDC2BI_DVI_INT_MASK] = u8Mask;
}

void MDrv_DDC2BI_Write_Buf(U8 u8Data)
{
    XBYTE[DDC2BI_ADC_RB_WP] = u8Data;
}

U8 MDrv_DDC2BI_Read_Buf(void)
{
    return XBYTE[DDC2BI_ADC_WB_RP];
}

void MDrv_DDC2BI_Receive_ISR(void)
{
    if(g_ucReceiveCounter)
    {
        if((--g_ucReceiveCounter)==0)
        {
            MDrv_DDC2BI_InitRx();
        }
    }
}

U8 MDrv_DDC2BI_ComputeChecksum(U8 count)
{
    U8 checksum;
    U8 i = 0;

    if (Get_DDC_NMVAddrFlag())
        checksum = INITNMVTxCK;
    else
        checksum = INITTxCK;

    for (; count > 0; count--)
        checksum ^= DDCBuffer[i++];

    return checksum;
}

void MDrv_DDC2BI_GetTxBuffer(void)
{
    U8  i;
    for(i = MAX_TXWAIT_DELAY; i > 0; i--)
    {
        if (txStatus == DDC2B_MSGON)
            MDrv_Timer_Delayms(1);
    }
    txStatus = DDC2B_CLEAR;
}

void MDrv_DDC2BI_MessageReady(void)
{
    DDClength = (DDCBuffer[0] & ~DDC2Bi_CONTROL_STATUS_FLAG) + 1;
    DDCBuffer[DDClength] = MDrv_DDC2BI_ComputeChecksum(DDClength); //put checksum
    MDrv_DDC2BI_GetTxBuffer();

    EX0 = 0;
    txBufferPtr = &DDCBuffer[0];
    txLength = DDClength + 1;
    EX0 = 1;
}

void MDrv_DDC2BI_ParseCommand(void)
{
    U8 length;

    length = DDCBuffer[LENGTH] & 0x7F;

    if (rxIndex <= 0)
        return;

    if(length <= 0)
    {
        DDC_MSG(printf("length return \r\n"));
        EX0 = 0;
        txBufferPtr = &nullMsg1[1];
        txLength = sizeof (nullMsg1);
        EX0 = 1;

        MDrv_DDC2BI_Write_Buf(DDC2B_DEST_ADDRESS);
        return;
    }

    length = (*AlignControlCallback)(DDCBuffer);

    if (length <= 0)
    {
        DDCBuffer[0] = 0x80;
    }
    else if (length == 0xFE || length == 0xFD)
    {
        DDCBuffer[0] = 0x80;
        // return;
    }

    MDrv_DDC2BI_MessageReady();

    if(Get_DDC_NMVAddrFlag())
    {
        MDrv_DDC2BI_Write_Buf(DDC2B_SRC_ADDRESS);
        Clr_DDC_NMVAddrFlag();
    }
    else
    {
        MDrv_DDC2BI_Write_Buf(DDC2B_DEST_ADDRESS);
    }
}


void MDrv_DDC2BI_CommandHandler(void)
{
    if (rxStatus == DDC2B_COMPLETED)
    {
        DDC_MSG(printf("DDC2B_COMPLETED \r\n"));
        MDrv_DDC2BI_Set_INT_Mask(0x7F); // disable all interrypt

        MDrv_DDC2BI_ParseCommand();
        Clr_RxBusyFlag();
        MDrv_DDC2BI_InitRx();

        MDrv_DDC2BI_Set_INT_Mask(0x67); // enable the write and read interrupt
    }
}

void MDrv_DDC2BI_IIC(void)
{
    U8 rxByte, intFlag;

    intFlag = MDrv_DDC2BI_Get_INT_FLAG();

    if(intFlag == 0) return;

    switch (intFlag & (TXBI | RCBI ))
    {
        case TXBI:
            MDrv_DDC2BI_InitRx();
            txStatus = DDC2B_MSGON;

            if (!(txLength))
            {
                // clear the transmit status
                txStatus = DDC2B_CLEAR;
                MDrv_DDC2BI_Write_Buf(0x00);

                //return ;  //Kent, to be study...
            }
            else
            {
                // send out the current byte
                MDrv_DDC2BI_Write_Buf(*txBufferPtr++);
                txLength--;
            }
            break;

        case RCBI:
            txLength=0;
            txStatus = DDC2B_CLEAR;

            // read the received byte
            rxByte = MDrv_DDC2BI_Read_Buf();

            // depending of the message status
            switch (rxStatus)
            {
                // in case there is nothing received yet
                case DDC2B_CLEAR:
                {
                    if (rxByte == DDC2B_SRC_ADDRESS)
                    {
                        rxStatus++;
                        rxChkSum = INITRxCK;
                        g_ucReceiveCounter = 200; //ms

                        MDrv_DDC2BI_Set_Callback(CB_DDC2B_SRC_STANDARD);
                    }
                    else if (rxByte == DDC2B_SRC_ADDRESS_CUSTOMER)
                    {
                        rxStatus++;
                        rxChkSum = (DDC2B_SRC_ADDRESS_CUSTOMER ^ DDC2B_DEST_ADDRESS);
                        g_ucReceiveCounter = 200; //ms
                        MDrv_DDC2BI_Set_Callback(CB_DDC2B_SRC_CUSTOMER);
                    }
                    else
                    {
                        MDrv_DDC2BI_InitRx();
                    }
                    break;
                }

                case DDC2B_SRCADDRESS:
                {
                    // get the length
                    rxLength = rxByte & ~DDC2Bi_CONTROL_STATUS_FLAG;    //clear first bit 0x84 -> 0x04

                    // put the received byte in DDCBuffer
                    DDCBuffer[rxIndex++] = rxByte; //DDCBuffer[0] = length
                    rxChkSum ^= rxByte;

                    // set the receive body state
                    rxStatus++; //= DDC2B_COMMAND;

                    //if it is a NULL message
                    if (rxLength == 0 || rxLength >= MaxBufLen)
                    {
                        // wait for CK
                        rxStatus = DDC2B_COMPLETED;
                        Set_RxBusyFlag();
                    }
                    break;
                }

                // get the command
                case DDC2B_COMMAND:
                {
                    // save the commandbyte
                    rxStatus++; //= DDC2B_RECBODY;
                }

                // get the message body
                case DDC2B_RECBODY:
                {
                    DDCBuffer[rxIndex++] = rxByte;  //DDCBuffer[1] = Command

                    rxChkSum ^= rxByte ;
                    rxLength--;

                    // the last byte in the message body
                    if (rxLength == 0 || rxLength >= MaxBufLen)
                    {
                    rxStatus++; //= DDC2B_WAITFORCK;
                    }
                    break;
                }

                // ...here we are waiting for checksum...
                case DDC2B_WAITFORCK:
                {
                    if (rxChkSum == rxByte) // if checksum match
                    {
                        rxStatus = DDC2B_COMPLETED;
                        Set_RxBusyFlag();
                    }
                    else // else checksum error
                    {
                        // if checksum error re-initialize the receive buffer
                        MDrv_DDC2BI_InitRx();
                    }
                    break;
                }

                // error condition
                default:
                {
                    // clear the rxState and the current buffer for a new message
                    if (!Get_RxBusyFlag())
                        MDrv_DDC2BI_InitRx();
                    break;
                }
            } // switch (rxStatus)
            break;
    }
    intFlag &= 0xBE;
    MDrv_DDC2BI_Set_INT_FLAG(intFlag);
}
#endif




#endif // ENABLE_DDCCI