convity_test.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
//------------------------------------------------------------------------------
//
// Copyright (C) 2006, 2007, Freescale Semiconductor, Inc. All Rights Reserved.
// THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
// AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT
//
//------------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//
//  File:  convity_test.cpp
//
//  This file contains test code for the PMIC connectivity APIs.
//
//------------------------------------------------------------------------------

#pragma warning(push)
#pragma warning(disable: 4115)
#pragma warning(disable: 4201)
#pragma warning(disable: 4204)
#pragma warning(disable: 4214)
#include <windows.h>
#pragma warning(pop)
#include <Devload.h>
#include<Winbase.h>

#include <ceddk.h>
#include "main.h"
#include "globals.h"
#include "pmic_lla.h"

#include "csp.h"
#include "regs.h"
#include "pmic_connectivity.h"
#include "regs_connectivity.h"

#define MY_ASSERT(c)   if (!(c)) g_pKato->Log(LOG_COMMENT, TEXT("Assert failed: line %d\r\n"), __LINE__);
static void dump_regs(WCHAR* context)
{
    UINT32 reg0, reg1;

    g_pKato->Log(LOG_COMMENT, context);

    PmicRegisterRead(MC13783_USB0_ADDR, &reg0);
    PmicRegisterRead(MC13783_CHG_USB1_ADDR, &reg1);
    g_pKato->Log(LOG_COMMENT, TEXT("0x%.8x 0x%.8x\r\n"), reg0, reg1);
}

void usbCB(const PMIC_CONVITY_EVENTS events)
{
    dump_regs(TEXT("USB: following events have occured\r\n"));
    if (events & USB_DETECT_4V4_RISE)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_4V4_RISE\r\n"));
    if (events & USB_DETECT_4V4_FALL)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_4V4_FALL\r\n"));
    if (events & USB_DETECT_2V0_RISE)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_2V0_RISE\r\n"));
    if (events & USB_DETECT_2V0_FALL)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_2V0_FALL\r\n"));
    if (events & USB_DETECT_0V8_RISE)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_0V8_RISE\r\n"));
    if (events & USB_DETECT_0V8_FALL)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_0V8_FALL\r\n"));
    if (events & USB_DETECT_MINI_A)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_MINI_A\r\n"));
    if (events & USB_DETECT_MINI_B)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_MINI_B\r\n"));
    if (events & USB_DETECT_NON_USB_ACCESORY)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_NON_USB_ACCESORY\r\n"));
    if (events & USB_DETECT_FACTORY_MODE)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_FACTORY_MODE\r\n"));
    if (events & USB_DETECT_SE1_RISE)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_SE1_RISE\r\n"));
    if (events & USB_DETECT_SE1_FALL)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_SE1_FALL\r\n"));
    if (events & USB_DETECT_CKDETECT)
        g_pKato->Log(LOG_COMMENT, TEXT("USB_DETECT_CKDETECT\r\n"));

    return;
}

void IfModeTest(PMIC_CONVITY_HANDLE handle)
{
    PMIC_CONVITY_MODE ifMode;

    PmicConvitySetMode(handle, RS232);
    PmicConvityGetMode(handle, &ifMode); MY_ASSERT(ifMode == RS232);
    dump_regs(TEXT("ifMode == RS232"));
    PmicConvitySetMode(handle, CEA936_MONO);
    PmicConvityGetMode(handle, &ifMode); MY_ASSERT(ifMode == CEA936_MONO);
    dump_regs(TEXT("ifMode == CEA936_MONO"));
    PmicConvitySetMode(handle, CEA936_STEREO);
    PmicConvityGetMode(handle, &ifMode); MY_ASSERT(ifMode == CEA936_STEREO);
    dump_regs(TEXT("ifMode == CEA936_STEREO"));
    PmicConvitySetMode(handle, CEA936_TEST_RIGHT);
    PmicConvityGetMode(handle, &ifMode); MY_ASSERT(ifMode == CEA936_TEST_RIGHT);
    dump_regs(TEXT("ifMode == CEA936_TEST_RIGHT"));
    PmicConvitySetMode(handle, CEA936_TEST_LEFT);
    PmicConvityGetMode(handle, &ifMode); MY_ASSERT(ifMode == CEA936_TEST_LEFT);
    dump_regs(TEXT("ifMode == CEA936_TEST_LEFT"));
    PmicConvitySetMode(handle, USB);
    PmicConvityGetMode(handle, &ifMode); MY_ASSERT(ifMode == USB);
    dump_regs(TEXT("ifMode == USB"));
    g_pKato->Log(LOG_COMMENT, TEXT("IfModeTest complete\r\n"));
    g_pKato->Log(LOG_COMMENT, TEXT("===========================\r\n"));
}

void UsbSpeedTest(PMIC_CONVITY_HANDLE handle)
{
    PMIC_CONVITY_USB_SPEED speed;
    PMIC_CONVITY_USB_MODE mode;

    PmicConvitySetMode(handle, USB);
    PmicConvityUsbSetSpeed(handle, USB_LOW_SPEED, USB_HOST);
    PmicConvityUsbGetSpeed(handle, &speed, &mode); 
    MY_ASSERT((speed == USB_LOW_SPEED) && (mode == USB_HOST));
    dump_regs(TEXT("LOW_SPEED HOST"));

    PmicConvityUsbSetSpeed(handle, USB_LOW_SPEED, USB_PERIPHERAL);
    PmicConvityUsbGetSpeed(handle, &speed, &mode); 
    MY_ASSERT((speed == USB_LOW_SPEED) && (mode == USB_PERIPHERAL));
    dump_regs(TEXT("LOW_SPEED USB_PERIPHERAL"));

    PmicConvityUsbSetSpeed(handle, USB_FULL_SPEED, USB_HOST);
    PmicConvityUsbGetSpeed(handle, &speed, &mode); 
    MY_ASSERT((speed == USB_FULL_SPEED) && (mode == USB_HOST));
    dump_regs(TEXT("USB_FULL_SPEED HOST"));

    PmicConvityUsbSetSpeed(handle, USB_FULL_SPEED, USB_PERIPHERAL);
    PmicConvityUsbGetSpeed(handle, &speed, &mode); 
    MY_ASSERT((speed == USB_FULL_SPEED) && (mode == USB_PERIPHERAL));
    dump_regs(TEXT("USB_FULL_SPEED USB_PERIPHERAL"));

    g_pKato->Log(LOG_COMMENT, TEXT("UsbSpeedTest complete\r\n"));
    g_pKato->Log(LOG_COMMENT, TEXT("===========================\r\n"));
}


void UsbSetPowerTest(PMIC_CONVITY_HANDLE handle)
{
    PMIC_CONVITY_USB_POWER_IN  in;
    PMIC_CONVITY_USB_POWER_OUT out;

    PmicConvitySetMode(handle, USB);
    PmicConvityUsbSetPowerSource(handle, USB_POWER_VBUS, USB_POWER_2V775);
    PmicConvityUsbGetPowerSource(handle, &in, &out); 
    MY_ASSERT((in == USB_POWER_VBUS) && (out == USB_POWER_2V775));
    dump_regs(TEXT("USB_POWER_VBUS 2.775"));

    PmicConvityUsbSetPowerSource(handle, USB_POWER_INTERNAL, USB_POWER_2V775);
    PmicConvityUsbGetPowerSource(handle, &in, &out); 
    MY_ASSERT((in == USB_POWER_INTERNAL) && (out == USB_POWER_2V775));
    dump_regs(TEXT("USB_POWER_INTERNAL 2.775"));

    PmicConvityUsbSetPowerSource(handle, USB_POWER_INTERNAL_BOOST, USB_POWER_2V775);
    PmicConvityUsbGetPowerSource(handle, &in, &out); 
    MY_ASSERT((in == USB_POWER_INTERNAL_BOOST) && (out == USB_POWER_2V775));
    dump_regs(TEXT("USB_POWER_INTERNAL_BOOST 2.775"));

    PmicConvityUsbSetPowerSource(handle, USB_POWER_VBUS, USB_POWER_3V3);
    PmicConvityUsbGetPowerSource(handle, &in, &out); 
    MY_ASSERT((in == USB_POWER_VBUS) && (out == USB_POWER_3V3));
    dump_regs(TEXT("USB_POWER_VBUS 3.3"));

    PmicConvityUsbSetPowerSource(handle, USB_POWER_INTERNAL, USB_POWER_3V3);
    PmicConvityUsbGetPowerSource(handle, &in, &out); 
    MY_ASSERT((in == USB_POWER_INTERNAL) && (out == USB_POWER_3V3));
    dump_regs(TEXT("USB_POWER_INTERNAL 3.3"));

    PmicConvityUsbSetPowerSource(handle, USB_POWER_INTERNAL_BOOST, USB_POWER_3V3);
    PmicConvityUsbGetPowerSource(handle, &in, &out); 
    MY_ASSERT((in == USB_POWER_INTERNAL_BOOST) && (out == USB_POWER_3V3));
    dump_regs(TEXT("USB_POWER_INTERNAL_BOOST 3.3"));

    g_pKato->Log(LOG_COMMENT, TEXT("UsbSetPowerTest complete\r\n"));
    g_pKato->Log(LOG_COMMENT, TEXT("===========================\r\n"));
}


void UsbSetXcvrTest(PMIC_CONVITY_HANDLE handle)
{
    PMIC_CONVITY_USB_TRANSCEIVER_MODE mode;

    PmicConvitySetMode(handle, USB);
    PmicConvityUsbSetXcvr(handle, USB_SINGLE_ENDED_UNIDIR_TX);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_SINGLE_ENDED_UNIDIR_TX);
    dump_regs(TEXT("USB_SINGLE_ENDED_UNIDIR_TX"));

    PmicConvityUsbSetXcvr(handle, USB_SINGLE_ENDED_UNIDIR_RX);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_SINGLE_ENDED_UNIDIR_RX);
    dump_regs(TEXT("USB_SINGLE_ENDED_UNIDIR_RX"));

    PmicConvityUsbSetXcvr(handle, USB_SINGLE_ENDED_BIDIR_TX);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_SINGLE_ENDED_BIDIR_TX);
    dump_regs(TEXT("USB_SINGLE_ENDED_BIDIR_TX"));

    PmicConvityUsbSetXcvr(handle, USB_SINGLE_ENDED_BIDIR_RX);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_SINGLE_ENDED_BIDIR_RX);
    dump_regs(TEXT("USB_SINGLE_ENDED_BIDIR_RX"));
    
    PmicConvityUsbSetXcvr(handle, USB_DIFFERENTIAL_UNIDIR_TX);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_DIFFERENTIAL_UNIDIR_TX);
    dump_regs(TEXT("USB_DIFFERENTIAL_UNIDIR_TX"));

    PmicConvityUsbSetXcvr(handle, USB_DIFFERENTIAL_UNIDIR_RX);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_DIFFERENTIAL_UNIDIR_RX);
    dump_regs(TEXT("USB_DIFFERENTIAL_UNIDIR_RX"));

    PmicConvityUsbSetXcvr(handle, USB_DIFFERENTIAL_BIDIR_TX);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_DIFFERENTIAL_BIDIR_TX);
    dump_regs(TEXT("USB_DIFFERENTIAL_BIDIR_TX"));

    PmicConvityUsbSetXcvr(handle, USB_DIFFERENTIAL_BIDIR_RX);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_DIFFERENTIAL_BIDIR_RX);
    dump_regs(TEXT("USB_DIFFERENTIAL_BIDIR_RX"));
    
    PmicConvityUsbSetXcvr(handle, USB_SUSPEND_ON);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_SUSPEND_ON);
    dump_regs(TEXT("USB_SUSPEND_ON"));
        
    PmicConvityUsbSetXcvr(handle, USB_SUSPEND_OFF);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_SUSPEND_OFF);
    dump_regs(TEXT("USB_SUSPEND_OFF"));
    
    PmicConvityUsbSetXcvr(handle, USB_OTG_SRP_DLP_START);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_OTG_SRP_DLP_START);
    dump_regs(TEXT("USB_OTG_SRP_DLP_START"));

    PmicConvityUsbSetXcvr(handle, USB_OTG_SRP_DLP_STOP);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_OTG_SRP_DLP_STOP);
    dump_regs(TEXT("USB_OTG_SRP_DLP_STOP"));
    
    PmicConvityUsbSetXcvr(handle, USB_SINGLE_ENDED_LOW);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_SINGLE_ENDED_LOW);
    dump_regs(TEXT("USB_SINGLE_ENDED_LOW"));
    
    PmicConvityUsbSetXcvr(handle, USB_TRANSCEIVER_OFF);
    PmicConvityUsbGetXcvr(handle, &mode); 
    MY_ASSERT(mode == USB_TRANSCEIVER_OFF);
    dump_regs(TEXT("USB_TRANSCEIVER_OFF"));

    g_pKato->Log(LOG_COMMENT, TEXT("UsbSetXcvrTest complete\r\n"));
    g_pKato->Log(LOG_COMMENT, TEXT("===========================\r\n"));
}


void UsbHnpTesting(PMIC_CONVITY_HANDLE handle)
{
    PmicConvitySetMode(handle, USB);
    PmicConvityUsbSetPowerSource(handle, USB_POWER_INTERNAL, USB_POWER_3V3);

    PmicConvityUsbOtgBeginHnp(handle, USB_A_DEVICE);
    dump_regs(TEXT("BgnHnp USB_A_DEVICE"));
    PmicConvityUsbOtgBeginHnp(handle, USB_A_DEVICE);
    dump_regs(TEXT("EndHnp USB_A_DEVICE"));

    PmicConvityUsbOtgBeginHnp(handle, USB_B_DEVICE);
    dump_regs(TEXT("BgnHnp USB_B_DEVICE"));
    PmicConvityUsbOtgBeginHnp(handle, USB_B_DEVICE);
    dump_regs(TEXT("EndHnp USB_B_DEVICE"));

    g_pKato->Log(LOG_COMMENT, TEXT("UsbHnpTesting complete\r\n"));
    g_pKato->Log(LOG_COMMENT, TEXT("===========================\r\n"));
}


void UsbOtgCfgTest(PMIC_CONVITY_HANDLE handle)
{