/* Cypress West Bridge HAL for beagleboard SPI Symbian header file (cyashalbeagleboard_spi.h)

 ## ===========================

 ##

 ##  Copyright Cypress Semiconductor Corporation, 2006-2009,

 ##  All Rights Reserved

 ##  UNPUBLISHED, LICENSED SOFTWARE.

 ##

 ##  CONFIDENTIAL AND PROPRIETARY INFORMATION

 ##  WHICH IS THE PROPERTY OF CYPRESS.

 ##

 ##  Use of this file is governed

 ##  by the license agreement included in the file

 ##

 ##     <install>/license/license.txt

 ##

 ##  where <install> is the Cypress software

 ##  installation root directory path.

 ##

 ## ===========================

*/

/*

 * This file contains the defintion of the hardware abstraction layer on beagleboard

 * talking to the West Bridge device through SPI interface

 */

#ifndef _INCLUDED_CYASHALBEAGLEBOARD_H_

#define _INCLUDED_CYASHALBEAGLEBOARD_H_

typedef struct CyAsHalSleepChannel_t {

    /* TODO:

    wait_queue_head_t wq ;*/

    int wq ;

} CyAsHalSleepChannel ;

typedef CyAsHalSleepChannel CyAnHalSleepChannel;

#include "cyastypes.h"

#include "cyas_cplus_start.h"

typedef enum CyAsHalInterfaceMode

{

    CyAsHalCRAMMode         = 0,

    CyAsHalSRAMMode         = 1,

    CyAsHalADMMode          = 2,

    CyAsHalPNANDLBD8Mode    = 3,

    CyAsHalPNANDLBD16Mode   = 4,

    CyAsHalPNANDSBD8Mode    = 5,

    CyAsHalPNANDSBD16Mode   = 6,

    CyAsHalSPIMode          = 7,

    CyAsHalLNAMode          = 8,

    CyAsHalUnknownMode      = 9

} CyAsHalInterfaceMode;

/*************************************************************************************************

 *

 * Below are the data structures that must be defined by the HAL layer

 *

 *************************************************************************************************/

/*

 * The HAL layer must define a TAG for identifying a specific West Bridge device in the system.

 * In this case the tag is a void * which is really an OMAP device pointer

 */

typedef void * CyAsHalDeviceTag ;

typedef CyAsHalDeviceTag CyAnHalDeviceTag;

/* This must be included after the CyAsHalDeviceTag type is defined */

#include "cyashalcb.h"

/*************************************************************************************************

 *

 * Below are the functions that communicate with the West Bridge device.  These are system dependent

 * and must be defined by the HAL layer for a given system.

 *

 *************************************************************************************************/

/*

 * This function must be defined to write a register within the West Bridge

 * device.  The addr value is the address of the register to write with

 * respect to the base address of the West Bridge device.

 */

extern void

CyAsHalWriteRegister(CyAsHalDeviceTag tag, uint16_t addr, uint16_t data) ;

#define CyAnHalWriteRegister(tag, addr, data) CyAsHalWriteRegister((CyAsHalDeviceTag)(tag), (addr), (data))

/*

 * This function must be defined to read a register from the West Bridge

 * device.  The addr value is the address of the register to read with

 * respect to the base address of the West Bridge device.

 */

uint16_t

CyAsHalReadRegister(CyAsHalDeviceTag tag, uint16_t addr) ;

#define CyAnHalReadRegister(tag, addr) CyAsHalReadRegister((CyAsHalDeviceTag)(tag), (addr))

/*

 * This function must be defined to transfer a block of data to the West Bridge device.  This

 * function can use the burst write (DMA) capabilities of West Bridge to do this, or it can

 * just copy the data using writes.

 */

extern void

CyAsHalDmaSetupWrite(CyAsHalDeviceTag tag, uint8_t ep, void *buf, uint32_t size, uint16_t maxsize) ;

#define CyAnHalDmaSetupWrite(tag, ep, buf, sz, max)     \

    CyAsHalDmaSetupWrite((CyAsHalDeviceTag)(tag), (ep), (buf), (sz), (max))

/*

 * This function must be defined to transfer a block of data from the West Bridge device.  This

 * function can use the burst read (DMA) capabilities of West Bridge to do this, or it can just

 * copy the data using reads.

 */

extern void

CyAsHalDmaSetupRead(CyAsHalDeviceTag tag, uint8_t ep, void *buf, uint32_t size, uint16_t maxsize) ;

#define CyAnHalDmaSetupRead(tag, ep, buf, sz, max)      \

    CyAsHalDmaSetupRead((CyAsHalDeviceTag)(tag), (ep), (buf), (sz), (max))

/*

 * This function must be defined to cancel any pending DMA request.

 */

extern void

CyAsHalDmaCancelRequest(CyAsHalDeviceTag tag, uint8_t ep) ;

#define CyAnHalDmaCancelRequest(tag, ep) CyAsHalDmaCancelRequest((CyAsHalDeviceTag)(tag), (ep))

/*

 * This function must be defined to allow the West Bridge API to register a callback function that is

 * called when a DMA transfer is complete.

 */

extern void

CyAsHalDmaRegisterCallback(CyAsHalDeviceTag tag, CyAsHalDmaCompleteCallback cb) ;

#define CyAnHalDmaRegisterCallback(tag, cb)     \

    CyAsHalDmaRegisterCallback((CyAsHalDeviceTag)(tag), (CyAsHalDmaRegisterCallback)(cb))

/*

 * This function must be defined to return the maximum size of DMA request that can be handled

 * on the given endpoint.  The return value should be the maximum size in bytes that the DMA

 * module can handle.

 */

extern uint32_t

CyAsHalDmaMaxRequestSize(CyAsHalDeviceTag tag, CyAsEndPointNumber_t ep) ;

#define CyAnHalDmaMaxRequestSize(tag, ep)       \

    CyAsHalDmaMaxRequestSize((CyAsHalDeviceTag)(tag), (CyAsEndPointNumber_t)(ep))

/*

 * This function must be defined to set the state of the WAKEUP pin on the West Bridge device.  Generally

 * this is done via a GPIO of some type.

 */

extern CyBool

CyAsHalSetWakeupPin(CyAsHalDeviceTag tag, CyBool state) ;

#define CyAnHalSetWakeupPin(tag, state) CyAsHalSetWakeupPin((CyAsHalDeviceTag)(tag), (state))

/*

 * This function is called when the West Bridge PLL loses lock, because

 * of a problem in the supply voltage or the input clock.

 */

extern void

CyAsHalPllLockLossHandler(CyAsHalDeviceTag tag) ;

#define CyAnHalPllLockLossHandler(tag) CyAsHalPllLockLossHandler((CyAsHalDeviceTag)(tag))

/*

 * Function to re-synchronise connection between Processor and West Bridge.

 * This is a no-operation for this HAL.

 */

extern CyBool

CyAsHalSyncDeviceClocks(CyAsHalDeviceTag tag) ;

#define CyAsHalSyncDeviceClocks(tag)    (CyTrue)

/*

 * Function to re-initialize West Bridge register when waking up from standby.

 * This is a no-operation for this HAL.

 */

extern void

CyAsHalInitDevRegisters(CyAsHalDeviceTag tag, CyBool is_standby_wakeup ) ;

/*

 * Function to read and save register values before Astoria is put into standby mode.

 */

extern void

CyAsHalReadRegsBeforeStandby (

        CyAsHalDeviceTag tag) ;

/*

 * Function to restore original values to registers after Astoria wakes up from standby mode.

 */

extern void

CyAsHalRestoreRegsAfterStandby (

        CyAsHalDeviceTag tag) ;

/*************************************************************************************************

 *

 * Below are the functions that must be defined to provide the basic operating system services

 * required by the API.

 *

 *************************************************************************************************/

/*

 * This function is required by the API to allocate memory.  This function is expected to work

 * exactly like malloc().

 */

void *

CyAsHalAlloc(uint32_t cnt) ;

#define CyAnHalAlloc(cnt) CyAsHalAlloc(cnt)

/*

 * This function is required by the API to free memory allocated with CyAsHalAlloc().  This function is

 * expected to work exacly like free().

 */

void

CyAsHalFree(void *mem_p) ;

#define CyAnHalFree(ptr) CyAsHalFree(ptr)

/*

 * This function is required by the API to allocate memory during a callback.  This function must be able to

 * provide storage at inturupt time.

 */

void *

CyAsHalCBAlloc(uint32_t cnt) ;

#define CyAnHalCBAlloc(cnt) CyAsHalCBAlloc(cnt)

/*

 * This function is required by the API to free memory allocated with CyAsHalCBAlloc.

 */

void

CyAsHalCBFree(void *mem_p) ;

#define CyAsHalCBFree(ptr) CyAsHalFree(ptr)

#define CyAnHalCBFree(ptr) CyAsHalFree(ptr)

/*

 * This function is required to set a block of memory to a specific value.  This function is

 * expected to work exactly like memset()

 */

void

CyAsHalMemSet(void *ptr, uint8_t value, uint32_t cnt) ;

#define CyAnHalMemSet(ptr, value, cnt) CyAsHalMemSet((ptr), (value), (cnt))

/*

 * This function is expected to create a sleep channel.  The data structure that represents the

 * sleep channel is given by the pointer in the argument.

 */

CyBool

CyAsHalCreateSleepChannel(CyAsHalSleepChannel *channel) ;

#define CyAnHalCreateSleepChannel(ch) CyAsHalCreateSleepChannel((CyAsHalSleepChannel *)(ch))

/*

 * This function is expected to destroy a sleep channel.  The data structure that represents the

 * sleep channel is given by the pointer in the argument.

 */

CyBool

CyAsHalDestroySleepChannel(CyAsHalSleepChannel *channel) ;

#define CyAnHalDestroySleepChannel(ch) CyAsHalDestroySleepChannel((CyAsHalSleepChannel *)(ch))

CyBool

CyAsHalSleepOn(CyAsHalSleepChannel *channel, uint32_t ms) ;

#define CyAnHalSleepOn(ch, ms) CyAsHalSleepOn((CyAsHalSleepChannel *)(ch), (ms))

CyBool

CyAsHalWake(CyAsHalSleepChannel *channel) ;

#define CyAnHalWake(ch) CyAsHalWake((CyAsHalSleepChannel *)(ch))

uint32_t

CyAsHalDisableInterrupts(void) ;

#define CyAnHalDisableInterrupts() CyAsHalDisableInterrupts()

void

CyAsHalEnableInterrupts(uint32_t);

#define CyAnHalEnableInterrupts(msk) CyAsHalEnableInterrupts(msk)

void

CyAsHalSleep150(void) ;

#define CyAnHalSleep150() CyAsHalSleep150()

void

CyAsHalSleep(uint32_t ms) ;

#define CyAnHalSleep(ms) CyAsHalSleep(ms)

#define CyAsHalIsPolling()	        (CyFalse)

#define CyAsHalDisablePolling()

#define CyAsHalEnablePolling()

#define CyAnHalIsPolling()	        (CyFalse)

#define CyAnHalDisablePolling()

#define CyAnHalEnablePolling()

#define CyAsHalPrintMessage

//#define CyAsHalPrintMessage Kern::Printf

#define CyAnHalPrintMessage CyAsHalPrintMessage

void

CyAsHalPrintMessage2(const char* msg);

/*#define CyAsHalAssert(cond)	if (!(cond)) { CyAsHalPrintMessage ("Assertion failed at %s:%d\n", __FILE__, __LINE__); }*/

#define CyAsHalAssert(cond)

#define CyAnHalAssert(cond) CyAsHalAssert(cond)

/*

   As this is a completely interrupt driven HAL, there is no

   need to implement the following functions.

 */

/*

 * These are the functions that are not part of the HAL layer, but are required to be called

 * for this HAL.

 */

int StartBeagleboardHal(const char *pgm, CyAsHalDeviceTag *tag, CyBool debug) ;

int StopBeagleboardHal(const char *pgm, CyAsHalDeviceTag tag) ;

/*

 * Constants

 */

#define CY_AS_OMAP_KERNEL_HAL_SIG	    (0x1441)

#define CYAS_DEV_MAX_ADDR   (0xFF)

#define CYAS_DEV_ADDR_RANGE (CYAS_DEV_MAX_ADDR << 16)

/* The base address is added in the kernel module code. */

#define CYAS_DEV_CALC_ADDR(addr) (addr << 16)

/*

 * Data structures

 */

typedef struct CyAsOmapDevKernel

{

    /* This is the signature for this data structure */

    unsigned int m_sig ;

    /* Address base of West Bridge Device */

    void *m_addr_base ;

    /* This is a pointer to the next West Bridge device in the system */

    struct CyAsOmapDevKernel *m_next_p ;

    /* This is for thread sync */

    /* TODO: struct completion thread_complete ;*/

    /* This is for thread to wait for interrupts */

    CyAsHalSleepChannel thread_sc ;

    /* This is for thread to exit upon StopOmapKernel */

    int thread_flag ; /* set 1 to exit */

} CyAsOmapDevKernel ;

extern int

CyAsHalAstoriaInit(void);

#include "cyas_cplus_end.h"

#endif