menelaus.cpp

Windows CE 6.0 BSP for the Beagle Board.

    UCHAR pData = 0x00;
    ReadData(MENELAUS_MCTCTRL1_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL1 0x%02X \r\n", pData));
    ReadData(MENELAUS_MCTCTRL2_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL2 0x%02X \r\n", pData));
    ReadData(MENELAUS_MCTCTRL3_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL3 0x%02X \r\n", pData));
    ReadData(MENELAUS_MCTPINST_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTPINST 0x%02X \r\n", pData));
#endif

    DEBUGMSG(SDCARD_ZONE_FUNC, (L"-CMenelaus::SlotsEnabled\r\n"));
    return TRUE;
}

//------------------------------------------------------------------------------
//
//  Function:  HandleSlot1Insert
//
//  Note: Slot1 will automatically shutdown VMCC when card is removed
//
BOOL 
CMenelaus::HandleSlot1Insert()
{
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"+CMenelaus::HandleSlot1Insert\r\n"));

    // set VMCC to ON
    // enable slot 1 and auto shutoff
    if (!WriteData(MENELAUS_MCTCTRL3_OFFSET, (SLOT1_EN)) ||
        !MaskMenelausIrq(IRQ_MENELAUS_DL2) ||
        !MaskMenelausIrq(IRQ_MENELAUS_CD2))
    {
        MenelausDeinit();
        return FALSE;
    }

#if DEBUG_MENELUS == 1
    UCHAR pData = 0x00;
    ReadData(MENELAUS_MCTCTRL1_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL1 0x%02X \r\n"), pData));
    ReadData(MENELAUS_MCTCTRL2_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL2 0x%02X \r\n"), pData));
    ReadData(MENELAUS_MCTCTRL3_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL3 0x%02X \r\n"), pData));
    ReadData(MENELAUS_MCTPINST_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTPINST 0x%02X \r\n"), pData));
#endif


    DEBUGMSG(SDCARD_ZONE_FUNC, (L"-CMenelaus::HandleSlot1Insert\r\n"));
    return TRUE;
}


//------------------------------------------------------------------------------
//
//  Function:  HandleSlot2Insert
//
//  Note: Slot2 will automatically shutdown VMCC when card is removed
BOOL 
CMenelaus::HandleSlot2Insert()
{
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"+CMenelaus::HandleSlot2Insert\r\n"));
    
    // enable slot2
    if (!WriteData(MENELAUS_MCTCTRL3_OFFSET, (SLOT2_EN)) ||
        !MaskMenelausIrq(IRQ_MENELAUS_DL1) ||
        !MaskMenelausIrq(IRQ_MENELAUS_CD1))
    {
        MenelausDeinit();
        return FALSE;
    }

#if DEBUG_MENELUS == 1
    UCHAR pData = 0x00;
    ReadData(MENELAUS_MCTCTRL1_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL1 0x%02X \r\n"), pData));
    ReadData(MENELAUS_MCTCTRL2_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL2 0x%02X \r\n"), pData));
    ReadData(MENELAUS_MCTCTRL3_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL3 0x%02X \r\n"), pData));
    ReadData(MENELAUS_MCTPINST_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTPINST 0x%02X \r\n"), pData));
#endif 

    DEBUGMSG(SDCARD_ZONE_FUNC, (L"-CMenelaus::HandleSlot2Insert\r\n"));
    return TRUE;
}

//------------------------------------------------------------------------------
//
//  Function:  UpdateSlotsState
//
BOOL
CMenelaus::UpdateSlotsState()
{
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"+CMenelaus::UpdateSlotsState\r\n"));

    if (m_hI2C == NULL)
        return FALSE;

    UCHAR pinState = 0x00;
    UCHAR mask = 0x00;
    
    if (!ReadData(MENELAUS_MCTPINST_OFFSET, &pinState) ||
        !ReadData(MENELAUS_INTMASK1_OFFSET, &mask))
    {
        DEBUGMSG(SDCARD_ZONE_ERROR, (L"CMenelaus::UpdateSlotsState: "
            L"Failed UpdateSlotsState\r\n"
        ));
        return FALSE;
    }
    
    m_bSlot1 = (~pinState & S1_CD_ST) ? TRUE : FALSE;
    
    m_bSlot2 = ((~pinState & S2_DAT1_ST) ||
                (~pinState & S2_CD_ST)) ? TRUE : FALSE;

#if DEBUG_MENELUS == 1
    UCHAR pData = 0x00;
    ReadData(MENELAUS_MCTCTRL1_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL1 0x%02X \r\n"), pData));
    ReadData(MENELAUS_MCTCTRL2_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL2 0x%02X \r\n"), pData));
    ReadData(MENELAUS_MCTCTRL3_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTCTRL3 0x%02X \r\n"), pData));
    ReadData(MENELAUS_MCTPINST_OFFSET, &pData); DEBUGMSG(SDCARD_ZONE_INFO, (L"MCTPINST 0x%02X \r\n"), pData));
#endif

    DEBUGMSG(SDCARD_ZONE_FUNC, (L"-CMenelaus::UpdateSlotsState\r\n"));
    return TRUE;
}

//------------------------------------------------------------------------------
// Function : AckInterrupts
//
// Acknowledge Menelaus Interrupt
BOOL
CMenelaus::AckInterrupts()
{
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"+CMenelaus::AckInterrupts\r\n"));
   
    UCHAR status = 0x00;
    UCHAR mask = 0x00;
    
    if (!ReadData(MENELAUS_INTSTATUS1_OFFSET, &status) ||
        !ReadData(MENELAUS_INTMASK1_OFFSET, &mask))
    {
        DEBUGMSG(SDCARD_ZONE_ERROR, (L"CMenelaus::AckInterrupts: "
            L"Failed UpdateSlotsState\r\n"
        ));
        return FALSE;
    }

    DEBUGMSG(SDCARD_ZONE_INFO, (L"CMenelaus::AckInterrupts: "
        L"Menelaus Int Status 0x%02X Int Mask 0x%02X \r\n", status, mask
    ));

    if (status & S1_CD_ST)
        return ClearMenelausIrq(IRQ_MENELAUS_CD1) && UnMaskMenelausIrq(IRQ_MENELAUS_CD1);
    
    if (status & S1_DAT1_ST)
        return ClearMenelausIrq(IRQ_MENELAUS_DL1) && UnMaskMenelausIrq(IRQ_MENELAUS_DL1);

    if (status & S2_CD_ST)
        return ClearMenelausIrq(IRQ_MENELAUS_CD2) && UnMaskMenelausIrq(IRQ_MENELAUS_CD2);

    if (status & S2_DAT1_ST)
        return ClearMenelausIrq(IRQ_MENELAUS_DL2) && UnMaskMenelausIrq(IRQ_MENELAUS_DL2);
        
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"-CMenelaus::AckInterrupts\r\n"));
    return TRUE;
}

/* ******************************************************* */
/*                           Private Method                                             */
/* ******************************************************* */

//------------------------------------------------------------------------------
//  Function:  ReadData from I2C Bus
//
BOOL 
CMenelaus::ReadData(UCHAR reg, UCHAR *pData)
{
    I2CTRANS trans;
    ZeroMemory(&trans,sizeof(trans));
    trans.mClk_HL_Divisor = I2C_CLOCK_DEFAULT;
    trans.mOpCode[0] = I2C_OPCODE_WRITE;
    trans.mBufferOffset[0] = 0;
    trans.mBuffer[0] = reg;
    trans.mTransLen[0] = 1;
    trans.mOpCode[1] = I2C_OPCODE_READ;
    trans.mBufferOffset[1] = 1;
    trans.mTransLen[1] = 1;
    
    I2CTransact(m_hI2C, &trans);

    if (trans.mErrorCode)
    {
        DEBUGMSG(SDCARD_ZONE_ERROR, (L"CMenelaus::ReadData: "
            L"Failed with error code 0x%08X\r\n",trans.mErrorCode
        ));
        return FALSE;
    }

    *pData = trans.mBuffer[1];
    return TRUE;
}


//------------------------------------------------------------------------------
//  Function:  WriteData to I2C Bus
//
//
BOOL 
CMenelaus::WriteData(UCHAR reg, UCHAR data)
{
    I2CTRANS trans;
    ZeroMemory(&trans,sizeof(trans));
    trans.mClk_HL_Divisor = I2C_CLOCK_DEFAULT;
    trans.mOpCode[0] = I2C_OPCODE_WRITE;
    trans.mBufferOffset[0] = 0;
    trans.mBuffer[0] = reg;
    trans.mBuffer[1] = data;
    trans.mTransLen[0] = 2;
    
    I2CTransact(m_hI2C, &trans);

    if (trans.mErrorCode)
    {
        DEBUGMSG(SDCARD_ZONE_ERROR, (L"CMenelaus::WriteData: "
            L"Failed with error code 0x%08X\r\n",trans.mErrorCode
        ));
        return FALSE;
    }
    return TRUE;
}

//------------------------------------------------------------------------------
// Function : MaskMenelausIrq
//
BOOL 
CMenelaus::MaskMenelausIrq(UINT32 irq)
{
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"+CMenelaus::MaskMenelausIrq (%d)\r\n", irq));

    BOOL rc = FALSE;
    UCHAR reg;
    UCHAR mask;

    // get the current mask in the Menelaus; first determin which register.
    if ((irq - IRQ_MENELAUS_CD1) < 8)
    {
        reg = MENELAUS_INTMASK1_OFFSET;
                
        rc = ReadData(reg, &mask);

        if (rc)
            mask |= 1 << (irq - IRQ_MENELAUS_CD1); 

        rc =  WriteData(reg, mask);  // Apply Mask
    }
    else if ((irq - IRQ_MENELAUS_RTCTMR) < 5)
    {
        reg = MENELAUS_INTMASK2_OFFSET;

        rc = ReadData(reg, &mask);

        if (rc)
            mask |= 1 << (irq - IRQ_MENELAUS_RTCTMR); 

        rc =  WriteData(reg, mask);  // Apply Mask
    }

    DEBUGMSG(SDCARD_ZONE_FUNC, (L"-CMenelaus::MaskMenelausIrq\r\n"));
    return rc;
}

//------------------------------------------------------------------------------
// Function : UnMaskMenelausIrq
//
BOOL 
CMenelaus::UnMaskMenelausIrq(UINT32 irq)
{
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"+CMenelaus::UnMaskMenelausIrq (%d)\r\n", irq));

    BOOL rc = FALSE;
    UCHAR reg;
    UCHAR mask;
    
    // get the current mask in the Menelaus; first determin which register.
    if ((irq - IRQ_MENELAUS_CD1) < 5)
    {
        reg = MENELAUS_INTMASK1_OFFSET;
                
        rc = ReadData(reg, &mask);

        if (rc)
            mask &= ~(1 << (irq - IRQ_MENELAUS_CD1)); 

        rc =  WriteData(reg, mask);  // Apply Mask
    }
    else if ((irq - IRQ_MENELAUS_RTCTMR) < 5)
    {
        reg = MENELAUS_INTMASK2_OFFSET;

        rc = ReadData(reg, &mask);

        if (rc)
            mask &= ~(1 << (irq - IRQ_MENELAUS_RTCTMR)); 

        rc =  WriteData(reg, mask);  // Apply Mask
    }
    
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"+CMenelaus::UnMaskMenelausIrq\r\n"));
    return rc;
}

//------------------------------------------------------------------------------
// Function : ClearMenelausIrq
//
BOOL 
CMenelaus::ClearMenelausIrq(UINT32 irq)
{
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"+CMenelaus::ClearMenelausIrq (%d)\r\n", irq));
    BOOL rc = FALSE;

    if ((irq - IRQ_MENELAUS_CD1) < 8)
    {
        rc = WriteData(MENELAUS_INTACK1_OFFSET, (1 << (irq - IRQ_MENELAUS_CD1)));
    }
    else if ((irq - IRQ_MENELAUS_RTCTMR) < 5)
    {
        rc = WriteData(MENELAUS_INTACK2_OFFSET, (1 << (irq - IRQ_MENELAUS_RTCTMR)));
    }
        
    DEBUGMSG(SDCARD_ZONE_FUNC, (L"-CMenelaus::ClearMenelausIrq\r\n"));
    return rc;
}


//#pragma optimize("", on)          // debug