cspiutil.c

i.mx27 soc for wince 6.0

//-----------------------------------------------------------------------------
//
//  Copyright (C) 2004, Motorola Inc. All Rights Reserved
//
//------------------------------------------------------------------------------
// Copyright (C) 2006, 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:  cspiutil.c
//
//  This file contains the utility function for accessing perpherials via CSPI.
//  The code is currently used for accessing PMIC.  We assume 32 bit access.
//
//-----------------------------------------------------------------------------

#include <windows.h>
#include <Devload.h>
#include <ceddk.h>

#include "cspiutil.h"
#include "socarm_macros.h"
#include "ioctl_pmic.h"

//-----------------------------------------------------------------------------
// External Functions
extern BOOL   BSPPmicCSPIGetSysIntr(int index, DWORD *cspiSysIntr);
extern BOOL   BSPPmicCSPIMapIoSpace(int index);
extern void   BSPPmicCSPIWriteTXFIFO(unsigned int data);
extern UINT32 BSPPmicCSPIReadRXFIFO(void);
extern void   BSPPmicCSPIExchange(void);
extern void   BSPPmicCPSIWaitTransactionComplete(void);
extern void   BSPPmicCSPIWaitReadReady(void);
extern void   BSPPmicCSPIEnable(void);
extern void   BSPPmicCSPIDisable(void);
extern void   BSPPmicCSPIRXIRQEnable(void);
extern void   BSPPmicCSPIIRQDisable(void);
extern UINT32 BSPPmicGetSpiFreqIn(void);
extern BOOL   BSPPmicSetSpiClockGating(BOOL bEnable);

//-----------------------------------------------------------------------------
// External Variables
extern BOOL g_bPmicUseCspiPolling;

//-----------------------------------------------------------------------------
// Defines
#define CSPI_READ               0
#define CSPI_WRITE              1

#define CSPI_TIMEOUT            1000

//-----------------------------------------------------------------------------
// Types

#ifdef DEBUG

// Debug zone bit positions
#define ZONEID_ERROR           0
#define ZONEID_WARN            1
#define ZONEID_INIT            2
#define ZONEID_FUNC            3
#define ZONEID_INFO            4

// Debug zone masks
#define ZONEMASK_ERROR         (1 << ZONEID_ERROR)
#define ZONEMASK_WARN          (1 << ZONEID_WARN)
#define ZONEMASK_INIT          (1 << ZONEID_INIT)
#define ZONEMASK_FUNC          (1 << ZONEID_FUNC)
#define ZONEMASK_INFO          (1 << ZONEID_INFO)

// Debug zone args to DEBUGMSG
#define ZONE_ERROR             DEBUGZONE(ZONEID_ERROR)
#define ZONE_WARN              DEBUGZONE(ZONEID_WARN)
#define ZONE_INIT              DEBUGZONE(ZONEID_INIT)
#define ZONE_FUNC              DEBUGZONE(ZONEID_FUNC)
#define ZONE_INFO              DEBUGZONE(ZONEID_INFO)

#endif

//-----------------------------------------------------------------------------
// Global Variables

//-----------------------------------------------------------------------------
// Local Variables
static HANDLE g_hCspiIntrEvent;
static HANDLE g_hCspiWaitEvent;
static HANDLE g_hCspiIntrServThread;
static DWORD g_cspiSysIntr;
static BOOL g_bUsePolling;
static volatile BOOL g_bSync;


//-----------------------------------------------------------------------------
// Local Functions
static DWORD WaitForInterruptEvent(HANDLE hIntrEvent, DWORD dwMilliseconds);
static DWORD WINAPI CspiIntrServThread (LPVOID lpParam);

//-----------------------------------------------------------------------------
//
// Function: cspiInitialize
//
// Initializes the CSPI interface and data structures.
//
// Parameters:
//      index
//          [in] CSPI instance (1 = CSPI1, 2 = CSPI2) to initialize.
//
//      dwFrequency
//          [in] Frequency requested.
//
// Returns:
//      TRUE is CSPI is initialized successfully.
//
//-----------------------------------------------------------------------------
BOOL cspiInitialize(int index, UINT32 dwFrequency)
{
    if (!BSPPmicCSPIGetSysIntr(index, &g_cspiSysIntr))
    {
        ERRORMSG(TRUE, (TEXT("%s(): Failed to obtain SYSINTR value.\r\n"),
                 __WFUNCTION__));
        goto Error;
    }

    if (!BSPPmicCSPIMapIoSpace(index))
    {
        ERRORMSG(TRUE, (TEXT("%s(): MmMapIoSpace() failed for ")
                        TEXT("CSP_CSPI_REG.\r\n"), __WFUNCTION__));
        goto Error;
    }

    // Create event for CSPI interrupt signaling
    g_hCspiIntrEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    if (g_hCspiIntrEvent == NULL)
    {
        ERRORMSG(TRUE, (TEXT("%s(): CreateEvent failed for ")
                        TEXT("g_hCspiIntrEvent.\r\n"), __WFUNCTION__));
        goto Error;
    }

    // Register CSPI interrupt
    if (!InterruptInitialize(g_cspiSysIntr, g_hCspiIntrEvent, NULL, 0))
    {
        ERRORMSG(TRUE, (TEXT("%s(): InterruptInitialize() failed.\r\n"),
                 __WFUNCTION__));
        goto Error;
    }

    // Create event for CSPI thread wait signaling
    g_hCspiWaitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    if (g_hCspiWaitEvent == NULL)
    {
        ERRORMSG(TRUE, (TEXT("%s(): CreateEvent() failed for ")
                        TEXT("g_hCspiWaitEvent.\r\n"), __WFUNCTION__));
        goto Error;
    }

    // Create IST for CSPI interrupts
    g_hCspiIntrServThread = CreateThread(NULL, 0, CspiIntrServThread, NULL,
                                         0, NULL);
    if (!g_hCspiIntrServThread) 
    {
        ERRORMSG(TRUE, (TEXT("%s(): CreateThread() failed for CSPI IST\r\n"),
                 __WFUNCTION__));
        goto Error;
    }

    // Initialize global for sync with threads blocked on CSPI transfer
    g_bSync = FALSE;

    // Configure for interrupt-driven communication
    cspiConfigPolling(g_bPmicUseCspiPolling);

    return TRUE;

Error:
    return FALSE;
}


//-----------------------------------------------------------------------------
//
// Function: cspiRelease
//
// Frees allocated memory, closes reference to handles, and resets the state
// of global member variables.
//
// Parameters:
//      index
//          [in] CSPI instance (1 = CSPI1, 2 = CSPI2) to initialize
//
// Returns:
//      None.
//
//-----------------------------------------------------------------------------
VOID cspiRelease(int index)
{
    return;
}

//-----------------------------------------------------------------------------
//
// Function: cspiConfigPolling
//
// Configures polled or interrupt-driven communication for the CSPI interface.
//
// Parameters:
//      bPoll
//          [in] Set to TRUE to forced polled communication.  Set to FALSE for
//          interrupt-driven communication.
//
// Returns:
//      None.
//
//-----------------------------------------------------------------------------
VOID cspiConfigPolling(BOOL bPoll)
{
    g_bUsePolling = bPoll;
}


//-----------------------------------------------------------------------------
//
// Function: cspiAddWritePacket
//
// Add a CSPI write packet.
//
// Parameters:
//      addr
//          [in] address
//      data
//          [in] data to write
//
// Returns:
//      TRUE if CSPI writing is successful.
//
//-----------------------------------------------------------------------------
BOOL cspiAddWritePacket(UINT32 addr, UINT32 data)
{
    CSPI_PACKET32 packet;

    // Format the packet
    packet.reg.data = data;
    packet.reg.null = 0;
    packet.reg.address = addr;
    packet.reg.rw = CSPI_WRITE;

    // Write the packet to the TXFIFO
    BSPPmicCSPIWriteTXFIFO(packet.data);
    DEBUGMSG(ZONE_INFO, (_T("write 0x%x = 0x%x\r\n"), addr, data));

    return TRUE;
}


//-----------------------------------------------------------------------------
//
// Function: cspiAddReadPacket
//
// Add a CSPI read packet.
//
// Parameters:
//      addr
//          [in] address
//
// Returns:
//      TRUE if CSPI reading is successful.
//
//-----------------------------------------------------------------------------
BOOL cspiAddReadPacket(UINT32 addr)
{
    CSPI_PACKET32 packet;

    // Format the packet
    packet.reg.data = 0;
    packet.reg.null = 0;
    packet.reg.address = addr;
    packet.reg.rw = CSPI_READ;