kitl.c

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) 2004-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:  kitl.c
//
//  Support routines for KITL.
//
//  Note: These routines are stubbed out in the kern image.
//
//-----------------------------------------------------------------------------
#include <bsp.h>
#include <kitl_cfg.h>

//-----------------------------------------------------------------------------
#define USE_DHCP_RENEW          1

static PCSP_GPT_REGS g_pGPT;

PCSP_GPIO_REGS g_pGPIO;
PCSP_PBC_REGS g_pPBC;
PBSP_ARGS g_pBSPARGS;

extern VOID* OALArgsQuery(UINT32 type);
    
//-----------------------------------------------------------------------------
#ifdef FORCE_KITL_SERIAL
#define BSP_UART_KITL_SERIAL_BAUD    115200
void OALEnableKitlSerial(void)
{
    PCSP_PLLCRC_REGS pPllcrc = (PCSP_PLLCRC_REGS)OALPAtoUA(CSP_BASE_REG_PA_CRM);

    // Configure Pins(PE12 ~ PE15) for UART1 as primary function
    OAL_IOMUX_PRI_PINS(g_pGPIO, GPIO_PORT_E, 0x0000F000);
    
    // Enable HWClock to UART1
    SETREG32(&pPllcrc->PCCR1, CSP_BITFMASK(PLLCRC_PCCR1_UART1_EN));
}
#endif

//------------------------------------------------------------------------------
// Platform entry point for KITL.
//
// Called when KITLIoctl (IOCTL_KITL_STARTUP, ...) is called.
//
BOOL OEMKitlStartup(void)
{
    BOOL rc;
    OAL_KITL_ARGS *pArgs, args;
    CHAR *szDeviceId;
    OAL_KITL_DEVICE *pKitlDevice = NULL;
#ifndef FORCE_KITL_SERIAL
    CHAR buffer[OAL_KITL_ID_SIZE];
#endif

#ifdef DEBUG
    // KITL gets its own debug zone and does not share
    // the OAL one any longer.
    // Turn on all debug zones for KITL debug only
    // dpCurSettings.ulZoneMask = 0xFFFF;
    dpCurSettings.ulZoneMask = 0x0003;  // Only ERROR and WARN
#endif

    OALMSG(OAL_KITL&&OAL_FUNC, (L"+OEMKitlStartup\r\n"));

    g_pBSPARGS = (PBSP_ARGS)IMAGE_SHARE_ARGS_RAM_UA_START;
    if (g_pBSPARGS == NULL)
    {
        OALMSG(OAL_ERROR, (L"+OEMKitlStartup: BSPARGS null pointer!\r\n"));
        rc = FALSE;
        goto cleanUp;
    }

    g_pPBC = (PCSP_PBC_REGS) OALPAtoUA(BSP_BASE_REG_PA_PBC_BASE);
    if (g_pPBC == NULL)
    {
        OALMSG(OAL_ERROR, (L"+OEMKitlStartup: PBC null pointer!\r\n"));
        rc = FALSE;
        goto cleanUp;
    }

    g_pGPIO = (PCSP_GPIO_REGS) OALPAtoUA(CSP_BASE_REG_PA_GPIO);
    if (g_pGPIO == NULL)
    {
        OALMSG(OAL_ERROR, (L"+OEMKitlStartup: GPIO null pointer!\r\n"));
        rc = FALSE;
        goto cleanUp;
    }

    // Get uncached virtual addresses for timer used in OALGetTickCount
    g_pGPT = (PCSP_GPT_REGS) OALPAtoUA(CSP_BASE_REG_PA_GPT1);
    if (g_pGPT == NULL)
    {
        OALMSG(OAL_ERROR, (L"+OEMKitlStartup: GPT null pointer!\r\n"));
        rc = FALSE;
        goto cleanUp;
    }

#ifdef FORCE_KITL_SERIAL
    // Set pointer to KITL transport device to Serial
    //
    pKitlDevice = &g_kitlDevices[OAL_KITL_SERIAL_INDEX];
    args.flags = OAL_KITL_FLAGS_ENABLED|OAL_KITL_FLAGS_POLL;
    args.baudRate = BSP_UART_KITL_SERIAL_BAUD;
    args.dataBits = UART_UCR2_WS_8BIT;
    args.stopBits = UART_UCR2_STPB_1STOP;
    args.parity = UART_UCR2_PREN_DISBLE;
    args.devLoc.LogicalLoc = BSP_BASE_REG_PA_SERIALKITL;
    args.devLoc.IfcType = Internal;
    szDeviceId = "MX27UART1";
    OALEnableKitlSerial();
    pArgs = &args;
	
#else
    // Look for bootargs left by the bootloader or left over from an earlier boot.
    //
    pArgs      = (OAL_KITL_ARGS*)OALArgsQuery(OAL_ARGS_QUERY_KITL);
    szDeviceId = (CHAR*)OALArgsQuery(OAL_ARGS_QUERY_DEVID);

    // If we don't get kitl arguments, the defaults would be used, and the CS8900A
    // becomes the KITL transport device as defalt.
    if (pArgs == NULL)
    {
        OALMSG(OAL_WARN, (L"WARN: Boot arguments not found, use defaults\r\n"));
		memset(&args, 0, sizeof(args));
        args.flags = OAL_KITL_FLAGS_ENABLED | OAL_KITL_FLAGS_VMINI | OAL_KITL_FLAGS_DHCP;
        args.mac[0] = BSP_ARGS_DEFAULT_MAC_BYTE0;
        args.mac[1] = BSP_ARGS_DEFAULT_MAC_BYTE1;
        args.mac[2] = BSP_ARGS_DEFAULT_MAC_BYTE2;
        args.mac[3] = BSP_ARGS_DEFAULT_MAC_BYTE3;
        args.mac[4] = BSP_ARGS_DEFAULT_MAC_BYTE4;
        args.mac[5] = BSP_ARGS_DEFAULT_MAC_BYTE5;
        args.devLoc.LogicalLoc = BSP_BASE_REG_PA_CS8900A_IOBASE;
        args.devLoc.IfcType = Internal;
		args.devLoc.BusNumber = 0;
        pArgs = &args;
        pKitlDevice = &g_kitlDevices[OAL_KITL_ETH_CS8900A_INDEX];        
    }
	
#ifndef USE_DHCP_RENEW
    else if (pArgs->flags & OAL_KITL_FLAGS_DHCP)
    {
        // Reset IP address to force DHCP request instead of renew which
        // is acknowleged much sooner from the DHCP server
        pArgs->ipAddress = 0;
    }
#endif

    // If there isn't device id from bootloader create some.
    //
    if (szDeviceId == NULL)
    {
        OALKitlCreateName(BSP_DEVICE_PREFIX, args.mac, buffer);
        szDeviceId = buffer;
    }

    // If we have not configured pointer to KITL transport device,
    // set it to CS8900A or FEC as per the args setting.
    if (pKitlDevice == NULL)
    {
        switch (pArgs->devLoc.LogicalLoc)
        {
        case BSP_BASE_REG_PA_CS8900A_IOBASE:
            pKitlDevice = &g_kitlDevices[OAL_KITL_ETH_CS8900A_INDEX];
            break;
            
        case CSP_BASE_REG_PA_FEC:
            pKitlDevice = &g_kitlDevices[OAL_KITL_ETH_FEC_INDEX];
            break;

        default:
            OALMSG(OAL_ERROR, (L"ERROR: Invalid KITL transport device\r\n"));
        }
    }
#endif // FORCE_KITL_SERIA

    //Force KITL run inpolled mode
    //pArgs->flags |= OAL_KITL_FLAGS_POLL;

    // Finally call KITL library.
    //
    rc = OALKitlInit(szDeviceId, pArgs, pKitlDevice);

cleanUp:
    OALMSG(OAL_KITL&&OAL_FUNC, (L"-OEMKitlStartup(rc = %d)\r\n", rc));
    return(rc);
}


//------------------------------------------------------------------------------
//
//  Function:  OALGetTickCount
//
//  This function is called by some KITL libraries to obtain relative time
//  since device boot. It is mostly used to implement timeout in network
//  protocol.
//
//------------------------------------------------------------------------------
UINT32 OALGetTickCount()
{
    UINT32 ticks;

    // Calculate GPT ticks since we started the system
    ticks = INREG32(&g_pGPT->TCN);

    // Return the number of 1ms ticks that have elapsed
    // return ticks / g_oalTimer.countsPerMSec;
    //
    // Note: If we link the oal_timer_mx27.lib to get g_oalTimer,
    // the g_oalTimer here will never get initialization.  That's because
    // OAL and KITL have respective copy of g_oalTimer.
    return ticks / OEM_TICKS_1MS;
}


//-----------------------------------------------------------------------------
//
// Function: OEMEthGetSecs
//
// Function returns a free-running seconds count.
//
// Parameters:
//
// Returns:
//      DWORD dwSeconds - the count of seconds
//
//-----------------------------------------------------------------------------
DWORD OEMEthGetSecs(void)
{
    SYSTEMTIME st;

    OEMGetRealTime( &st );
    return ((60UL * (60UL * (24UL * (31UL * st.wMonth + st.wDay) + st.wHour) + 
            st.wMinute)) + st.wSecond);
}


//-----------------------------------------------------------------------------
//
// Function: OALGetSerialRefClock
//
// Function returns reference clock for UART1
//
// Parameters:
//
// Returns:
//      DWORD PERCLK1 for UART1
//
//-----------------------------------------------------------------------------
UINT OALGetSerialRefClock(void)
{
	return g_pBSPARGS->clockFreq[DDK_CLOCK_SIGNAL_PERDIV1];
}


//-----------------------------------------------------------------------------
#include "..\\common\\bspcmn\\args.c"