620 lines
16 KiB
C
Executable File
620 lines
16 KiB
C
Executable File
/*
|
|
* Copyright (c) 2006 NVIDIA Corporation. All rights reserved.
|
|
*
|
|
* NVIDIA Corporation and its licensors retain all intellectual property
|
|
* and proprietary rights in and to this software, related documentation
|
|
* and any modifications thereto. Any use, reproduction, disclosure or
|
|
* distribution of this software and related documentation without an express
|
|
* license agreement from NVIDIA Corporation is strictly prohibited.
|
|
*/
|
|
|
|
#ifndef NVBOARD_H
|
|
#define NVBOARD_H
|
|
|
|
#include "nvcommon.h"
|
|
#include "nverror.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif /* __cplusplus */
|
|
|
|
/** NvBoard - Board Support Package
|
|
|
|
NvBoard is designed to decouple customer platform specifics from generic
|
|
binary only drivers.
|
|
|
|
The interface must be thread-safe.
|
|
*/
|
|
|
|
typedef struct NvBoardAperture_t
|
|
{
|
|
/* Physical Address */
|
|
NvPhysAddr address;
|
|
|
|
/* Size of Aperture */
|
|
NvU32 size;
|
|
} NvBoardAperture;
|
|
|
|
typedef struct NvBoardApertureIO_t
|
|
{
|
|
void ( *Write8 )( void *pAddress, NvU8 data );
|
|
void ( *Write16 )( void *pAddress, NvU16 data );
|
|
void ( *Write32 )( void *pAddress, NvU32 data );
|
|
void ( *Write64 )( void *pAddress, NvU64 data );
|
|
NvU8 ( *Read8 )( void *pAddress );
|
|
NvU16 ( *Read16 )( void *pAddress );
|
|
NvU32 ( *Read32 )( void *pAddress );
|
|
NvU64 ( *Read64 )( void *pAddress );
|
|
} NvBoardApertureIO;
|
|
|
|
typedef struct NvBoardApertures_t
|
|
{
|
|
NvBoardAperture hostInterface;
|
|
|
|
/* pIO is null unless the apertures cannot be dereferenced */
|
|
NvBoardApertureIO *pIO;
|
|
} NvBoardApertures;
|
|
|
|
typedef enum
|
|
{
|
|
/* Bus type A */
|
|
NvBoardBusType_A,
|
|
|
|
/* Bus type C */
|
|
NvBoardBusType_C,
|
|
|
|
NvBoardBusType_Forceword = 0x7fffffff,
|
|
} NvBoardBusType;
|
|
|
|
typedef enum
|
|
{
|
|
/* Direct Addressing */
|
|
NvBoardBusAddressing_Direct,
|
|
|
|
/* Indirect Addressing */
|
|
NvBoardBusAddressing_Indirect,
|
|
|
|
NvBoardBusAddressing_Forceword = 0x7fffffff,
|
|
} NvBoardBusAddressing;
|
|
|
|
typedef enum
|
|
{
|
|
/* 16-bit bus */
|
|
NvBoardBusWidth_16,
|
|
|
|
/* 32-bit bus */
|
|
NvBoardBusWidth_32,
|
|
|
|
NvBoardBusWidth_Forceword = 0x7fffffff,
|
|
} NvBoardBusWidth;
|
|
|
|
typedef enum
|
|
{
|
|
/* Handshake mode. */
|
|
NvBoardBusMode_Handshake,
|
|
|
|
/* Fixed cycle mode. */
|
|
NvBoardBusMode_FixedCycle,
|
|
|
|
NvBoardBusMode_Forceword = 0x7fffffff,
|
|
} NvBoardBusMode;
|
|
|
|
typedef enum
|
|
{
|
|
/* Asynchronous. */
|
|
NvBoardBusSynchronization_Asynchronous,
|
|
|
|
/* Synchronous. */
|
|
NvBoardBusSynchronization_Synchronous,
|
|
|
|
NvBoardBusSynchronization_Forceword = 0x7fffffff,
|
|
} NvBoardBusSynchronization;
|
|
|
|
typedef enum
|
|
{
|
|
/* Active low. */
|
|
NvBoardBusReadyPolarity_ActiveLow,
|
|
|
|
/* Active high. */
|
|
NvBoardBusReadyPolarity_ActiveHigh,
|
|
|
|
NvBoardBusReadyPolarity_Forceword = 0x7fffffff,
|
|
} NvBoardBusReadyPolarity;
|
|
|
|
typedef struct NvBoardMode_t
|
|
{
|
|
NvBoardBusAddressing GPUaddressing; // Bus perspective from GPU
|
|
NvBoardBusWidth GPUwidth;
|
|
NvBoardBusAddressing CPUaddressing; // Bus perspective from CPU
|
|
NvBoardBusWidth CPUwidth;
|
|
NvBoardBusType type;
|
|
NvBoardBusMode mode;
|
|
NvBoardBusSynchronization synchronization;
|
|
NvBoardBusReadyPolarity readyPolarity;
|
|
} NvBoardMode;
|
|
|
|
/** Stateless methods. Methods can be called before NvBoardInit */
|
|
|
|
/** NvBoardListSupportedModes - Method to enumerate the modes of the board
|
|
|
|
Two calls should be made to this method.
|
|
|
|
On the first call, the method populates the number of modes, for the
|
|
display. When this call is issued pMode should be NULL.
|
|
|
|
On the second call, the length of the pMode array is indicated by
|
|
the value of *pNum. When pNum is less than the number of modes the
|
|
method populates the pMode array with only the first pNum modes.
|
|
When is more than the number of modes, the method populates the
|
|
pMode array with the number of modes and writes the number of modes
|
|
into pNum.
|
|
|
|
The first mode enumerated by this method is the recommended / default mode
|
|
for the display.
|
|
|
|
@param pNum unsigned integer value indicating the number of modes in
|
|
the array pMode.
|
|
|
|
@param pMode pointer to an array of mode structures, where the size of
|
|
the array is determined by the value in pNum.
|
|
|
|
@retval NvSuccess - on success
|
|
NvErrorBadParameter - when at least one parameter is incorrect
|
|
*/
|
|
NvError
|
|
NvBoardListSupportedModes( NvU32 *pNum, NvBoardMode *pMode );
|
|
|
|
/** Library Initialization */
|
|
|
|
/** NvBoardInit - platform initialization. Typically chip select is configured here.
|
|
|
|
NvBoardInit uses a reference counter. The first invocation performs the
|
|
initialization, all future calls increment the counter. The counter is
|
|
decremented by NvBoardDeInit.
|
|
|
|
This method is to be called before any other NvBoard methods can be used.
|
|
|
|
@param pMode pointer to structure containing a mode to set on the board.
|
|
If mode is null, the recommended mode will be chosen.
|
|
*/
|
|
NvError
|
|
NvBoardInit( const NvBoardMode *pMode );
|
|
|
|
/** NvBoardDeInit - platform deinitialization.
|
|
*/
|
|
void
|
|
NvBoardDeInit( void );
|
|
|
|
/** Wince platform resume control */
|
|
NvError
|
|
NvBoardResume( void );
|
|
|
|
/** Wince platform suspend control */
|
|
NvError
|
|
NvBoardSuspend( void );
|
|
|
|
/** SD card detect status when card detect pin is connected to CPU GPIO pin */
|
|
NvError
|
|
nvBoardSDCardDetectStatus(NvU32 *bCardInserted);
|
|
|
|
/** SD card detect sysintr number if card detect pin is connected to CPU GPIO pin*/
|
|
NvError
|
|
nvBoardSDCardDetectSysintr(NvU32 *dwSysintr);
|
|
|
|
/** SD card socket power pin configuration
|
|
In general, this pin is connected to CPU GPIO pin, and we need to configure
|
|
GPIO input/output mode and setup default value
|
|
*/
|
|
NvError
|
|
nvBoardSDSocketPowerInit(void);
|
|
|
|
/** SD card socket power control*/
|
|
NvError
|
|
nvBoardSDSocketPowerOnOff(NvU32 SDPowerOn);
|
|
|
|
/** Camera(VI) interface power plane control*/
|
|
NvError
|
|
nvBoardVIPowerOnOff(NvU32 VIPowerOn);
|
|
|
|
/** OEM specific powerOn related calls after NV backlight ON.
|
|
|
|
@retval ERROR_SUCCESS on success or appropriate wince error
|
|
codes.
|
|
*/
|
|
NvError
|
|
nvBoard_PostOEMBacklightOn(void);
|
|
|
|
/** OEM specific powerOff related calls after NV backlight Off.
|
|
|
|
@retval ERROR_SUCCESS on success or appropriate wince error
|
|
codes.
|
|
*/
|
|
NvError
|
|
nvBoard_PostOEMBacklightOff(void);
|
|
|
|
/** NvBoardGetApertures - get apertures
|
|
*/
|
|
NvError
|
|
NvBoardGetApertures( NvBoardApertures *pApertures );
|
|
|
|
/** NvBoardGetMode - get current mode
|
|
*/
|
|
NvError
|
|
NvBoardGetMode( NvBoardMode *pMode );
|
|
|
|
/** Device Events -- Abstraction for interrupts */
|
|
|
|
/* NvDeviceEvent enumerates the types of events. NvBoard implementors should not
|
|
hardcode event names. The only enumerated value that should be used in the
|
|
implementation of NvBoard is NvDeviceEvent_Num.
|
|
*/
|
|
typedef enum NvDeviceEvent_t
|
|
{
|
|
/* NOTE: Currently using unabstracted events until INTx is removed. */
|
|
NvDeviceEvent_HOST = 0,
|
|
NvDeviceEvent_GRMPD,
|
|
NvDeviceEvent_ME,
|
|
NvDeviceEvent_JPEGE,
|
|
NvDeviceEvent_VI,
|
|
NvDeviceEvent_EPP,
|
|
NvDeviceEvent_ISP,
|
|
NvDeviceEvent_DSP,
|
|
NvDeviceEvent_GR2D,
|
|
NvDeviceEvent_GR3D,
|
|
NvDeviceEvent_DISPLAY,
|
|
NvDeviceEvent_I2S,
|
|
NvDeviceEvent_IC,
|
|
NvDeviceEvent_SD,
|
|
NvDeviceEvent_MC,
|
|
NvDeviceEvent_EMC,
|
|
|
|
/* NUM should always be the 2nd last enumerated value */
|
|
NvDeviceEvent_Num,
|
|
|
|
NvDeviceEvent_Forceword = 0x7fffffff,
|
|
} NvDeviceEvent;
|
|
|
|
/** NvBoardEnableEvent - Method to enable an event
|
|
|
|
If the event is fired before a client is waiting, the event will be remembered
|
|
for the next NvBoardWaitForEvent invocation.
|
|
*/
|
|
NvError
|
|
NvBoardEnableEvent( NvDeviceEvent event );
|
|
|
|
/** NvBoardDisableEvent - Method to disable an event
|
|
*/
|
|
void
|
|
NvBoardDisableEvent( NvDeviceEvent event );
|
|
|
|
/** NvBoardWaitForEvent - This method blocks until the event is fired
|
|
|
|
Each event may only have one client waiting on it. If more than one client
|
|
needs to be notified of an event, a broadcast layer will need to be
|
|
developed on top of this API.
|
|
|
|
Once an event is fired, it is disabled. To reenable the event use
|
|
NvBoardEnableEvent.
|
|
*/
|
|
NvError
|
|
NvBoardWaitForEvent( NvDeviceEvent event );
|
|
|
|
/** NvBoardWaitForEventWithTimeOut - NvBoardWaitForEvent with a timeout
|
|
|
|
@param timeOut Unit is milliseconds
|
|
*/
|
|
NvError
|
|
NvBoardWaitForEventWithTimeOut( NvDeviceEvent event, NvU32 timeOut );
|
|
|
|
/** I2C I/O */
|
|
|
|
/** NvBoardI2CWrite - I2C write operation. Implementing this function is optional.
|
|
*/
|
|
NvError
|
|
NvBoardI2CWrite( NvU32 addr, const void *ptr, NvU32 size );
|
|
|
|
/** NvBoardI2CRead - I2C read operation. Implementing this function is optional.
|
|
*/
|
|
NvError
|
|
NvBoardI2CRead( NvU32 addr, void *ptr, NvU32 size );
|
|
|
|
/** Voltage and power control */
|
|
|
|
typedef enum NvBoardPowerPlane_t
|
|
{
|
|
NvBoardPowerPlane_AOCVDD = 0,
|
|
NvBoardPowerPlane_VECVDD,
|
|
NvBoardPowerPlane_MMCVDD,
|
|
NvBoardPowerPlane_TDCVDD,
|
|
NvBoardPowerPlane_VVDD,
|
|
NvBoardPowerPlane_EMVDD,
|
|
NvBoardPowerPlane_ACVDD,
|
|
NvBoardPowerPlane_LVDD,
|
|
NvBoardPowerPlane_HVDD,
|
|
NvBoardPowerPlane_AUXVDD,
|
|
NvBoardPowerPlane_R1CVDD,
|
|
NvBoardPowerPlane_SDVDD,
|
|
NvBoardPowerPlane_DRAM,
|
|
|
|
NvBoardPowerPlane_Forceword = 0x7fffffff,
|
|
} NvBoardPowerPlane;
|
|
|
|
typedef enum NvBoardClock_t
|
|
{
|
|
NvBoardClock_PLL1 = 0,
|
|
NvBoardClock_PLL2,
|
|
NvBoardClock_COSC,
|
|
NvBoardClock_ROSC,
|
|
NvBoardClock_REF1,
|
|
NvBoardClock_REF2,
|
|
|
|
NvBoardClock_Forceword = 0x7fffffff,
|
|
} NvBoardClock;
|
|
|
|
/** NvBoardSetVoltage - change voltage of hardware block
|
|
|
|
@param voltage Unit is millivolts
|
|
*/
|
|
NvError
|
|
NvBoardSetVoltage( NvBoardPowerPlane block, NvU32 voltage );
|
|
|
|
/** NvBoardGetVoltage - get voltage of hardware block
|
|
|
|
@param voltage Unit is millivolts
|
|
*/
|
|
NvError
|
|
NvBoardGetVoltage( NvBoardPowerPlane plane, NvU32 *voltage );
|
|
|
|
/** NvBoardPowerOn - enable power to block
|
|
*/
|
|
NvError
|
|
NvBoardPowerOn( NvBoardPowerPlane plane );
|
|
|
|
/** NvBoardPowerOff - disable power to block
|
|
*/
|
|
NvError
|
|
NvBoardPowerOff( NvBoardPowerPlane plane );
|
|
|
|
/** NvBoardClockOn - enable clock
|
|
*/
|
|
NvError
|
|
NvBoardClockOn( NvBoardClock clock );
|
|
|
|
/** NvBoardClockOff - disable clock
|
|
*/
|
|
NvError
|
|
NvBoardClockOff( NvBoardClock clock );
|
|
|
|
/** NvBoardSetFrequency - set frequency of clock
|
|
|
|
@param frequency unit is KHz
|
|
*/
|
|
NvError
|
|
NvBoardSetFrequency( NvBoardClock clock, NvU32 frequency );
|
|
|
|
|
|
/** Platfrom specific debug function. This like an ioctl to the platfrom
|
|
sepcific code.
|
|
*/
|
|
void NvBoardDebug(void *p, NvU32 op, NvU32 arg);
|
|
|
|
/** Event notification */
|
|
|
|
typedef enum
|
|
{
|
|
NvBoardDeviceType_Silicon,
|
|
NvBoardDeviceType_Emulator,
|
|
NvBoardDeviceType_Forceword = 0x7fffffff,
|
|
} NvBoardDeviceType;
|
|
|
|
typedef struct NvBoardDeviceInfo_t
|
|
{
|
|
NvU32 MinorRev;
|
|
NvU32 MajorRev;
|
|
NvU32 ChipID;
|
|
NvU32 Family;
|
|
NvBoardDeviceType Type;
|
|
} NvBoardDeviceInfo;
|
|
|
|
/** NvBoardPostChipInit - Called after the chip is intialized.
|
|
|
|
Chip specific timings can be programmed at this point.
|
|
|
|
NvIrqPostChipInit should be called here.
|
|
*/
|
|
NvError
|
|
NvBoardPostChipInit( NvBoardDeviceInfo *deviceInfo );
|
|
|
|
/** NvBoardPreChipDeInit - Called before chip is shutdown.
|
|
|
|
NvIrqPreChipDeInit should be called here.
|
|
*/
|
|
NvError
|
|
NvBoardPreChipDeInit( void );
|
|
|
|
/** NvBoardClockSwitch - Clock switch handling
|
|
|
|
@param frequency Unit is kHz
|
|
*/
|
|
NvError
|
|
NvBoardClockSwitch( NvU32 frequency );
|
|
|
|
typedef enum NvBoardStateEvent_t
|
|
{
|
|
#ifdef NV_WINDOWS_CE
|
|
NvBoardStateEvent_PreDeviceInit,
|
|
NvBoardStateEvent_PostDeviceInit,
|
|
NvBoardStateEvent_PrePanelInit,
|
|
NvBoardStateEvent_PostPanelInit,
|
|
NvBoardStateEvent_PreSetMode,
|
|
NvBoardStateEvent_PostSetMode,
|
|
NvBoardStateEvent_PreDisplayInit,
|
|
NvBoardStateEvent_PostDisplayInit,
|
|
NvBoardStateEvent_PreOEMPowerHandlerVideoPowerOff,
|
|
NvBoardStateEvent_PostOEMPowerHandlerVideoPowerOff,
|
|
NvBoardStateEvent_PreOEMPowerHandlerVideoPowerOn,
|
|
NvBoardStateEvent_PostOEMPowerHandlerVideoPowerOn,
|
|
#endif
|
|
|
|
NvBoardStateEvent_Forceword = 0x7fffffff,
|
|
} NvBoardStateEvent;
|
|
|
|
/** NvBoardGlobalStateNotification - Called during global state transitions
|
|
|
|
Only used on Windows CE at the moment.
|
|
*/
|
|
NvError
|
|
NvBoardGlobalStateNotification( NvBoardStateEvent event );
|
|
|
|
void
|
|
NvBoardOsWaitUS( NvU32 usec );
|
|
|
|
void
|
|
NvBoardOsSleepMS( NvU32 msec );
|
|
|
|
typedef struct NvBoardOsMutex_t *NvBoardOsMutex;
|
|
typedef struct NvBoardOsSemaphore_t *NvBoardOsSemaphore;
|
|
typedef struct NvBoardOsThread_t *NvBoardOsThread;
|
|
|
|
NvError
|
|
NvBoardOsMutexCreate( const char *key, NvBoardOsMutex *mutex );
|
|
|
|
void
|
|
NvBoardOsMutexLock( NvBoardOsMutex mutex );
|
|
|
|
void
|
|
NvBoardOsMutexUnlock( NvBoardOsMutex mutex );
|
|
|
|
void
|
|
NvBoardOsMutexDestroy( NvBoardOsMutex mutex );
|
|
|
|
typedef struct NvBoardOsSharedMemDescriptor_t *NvBoardOsSharedMemDescriptor;
|
|
|
|
NvError
|
|
NvBoardOsSharedMemAlloc( const char *key, size_t size,
|
|
NvBoardOsSharedMemDescriptor *descriptor );
|
|
|
|
NvError
|
|
NvBoardOsSharedMemMap( NvBoardOsSharedMemDescriptor descriptor, size_t offset,
|
|
size_t size, void **ptr );
|
|
|
|
void
|
|
NvBoardOsSharedMemUnmap( void *ptr, size_t size );
|
|
|
|
void
|
|
NvBoardOsSharedMemFree( NvBoardOsSharedMemDescriptor descriptor );
|
|
|
|
void
|
|
NvBoardOsMemset( void *s, NvU8 c, size_t size );
|
|
|
|
int
|
|
NvBoardOsMemcmp( const void *s1, const void *s2, size_t size );
|
|
|
|
#define NVBOARDOS_KEY_MAX 128
|
|
|
|
#define NVBOARDOS_MEM_NONE 0x0
|
|
#define NVBOARDOS_MEM_READ 0x1
|
|
#define NVBOARDOS_MEM_WRITE 0x2
|
|
#define NVBOARDOS_MEM_EXECUTE 0x4
|
|
#define NVBOARDOS_MEM_READ_WRITE ( NVBOARDOS_MEM_READ | NVBOARDOS_MEM_WRITE )
|
|
|
|
typedef enum
|
|
{
|
|
NvBoardOsMemAttribute_Uncached = 0,
|
|
NvBoardOsMemAttribute_WriteBack = 1,
|
|
NvBoardOsMemAttribute_WriteCombined = 2,
|
|
|
|
NvBoardOsMemAttribute_Force32 = 0x7FFFFFFF
|
|
} NvBoardOsMemAttribute;
|
|
|
|
NvError
|
|
NvBoardOsPhysicalMemMap( NvPhysAddr phys, size_t size,
|
|
NvBoardOsMemAttribute attrib, NvU32 flags, void **ptr );
|
|
|
|
|
|
void
|
|
NvBoardOsPhysicalMemUnmap( void *ptr, size_t size );
|
|
|
|
NvError
|
|
NvBoardOsMemoryAlloc(void **ptr, size_t size);
|
|
|
|
void
|
|
NvBoardOsMemoryFree(void *ptr, size_t size);
|
|
|
|
NvError
|
|
NvBoardOsGetConfigU32( const char *name, NvU32 *value );
|
|
|
|
void *
|
|
NvBoardOsAlloc( size_t size );
|
|
|
|
void
|
|
NvBoardOsFree( void *ptr );
|
|
|
|
typedef void (*NvBoardOsThreadFunction)( void *args );
|
|
|
|
NvError
|
|
NvBoardOsThreadCreate( const char *name, NvBoardOsThreadFunction function,
|
|
void *args, NvBoardOsThread *thread );
|
|
|
|
void
|
|
NvBoardOsThreadJoin( NvBoardOsThread thread );
|
|
|
|
void
|
|
NvBoardOsThreadYield( void );
|
|
|
|
NvError
|
|
NvBoardOsSemaphoreCreate( const char *key, NvBoardOsSemaphore *semaphore,
|
|
NvU32 value );
|
|
|
|
void
|
|
NvBoardOsSemaphoreWait( NvBoardOsSemaphore semaphore );
|
|
|
|
void
|
|
NvBoardOsSemaphoreSignal( NvBoardOsSemaphore semaphore );
|
|
|
|
void
|
|
NvBoardOsSemaphoreDestroy( NvBoardOsSemaphore semaphore );
|
|
|
|
NvError
|
|
nvBoard_PreDisplayInit(void);
|
|
|
|
NvError
|
|
nvBoard_PostDisplayInit(void);
|
|
|
|
NvError
|
|
nvBoard_PrePanelInit(void);
|
|
|
|
NvError
|
|
nvBoard_PostPanelInit(void);
|
|
|
|
NvError
|
|
nvBoard_PreDeviceInit(void);
|
|
|
|
NvError
|
|
nvBoard_PostDeviceInit(void);
|
|
|
|
NvError
|
|
nvBoard_PreSetMode(void);
|
|
|
|
NvError
|
|
nvBoard_PostSetMode(void);
|
|
|
|
NvError
|
|
nvBoard_PreOEMPowerHandlerVideoPowerOff(void);
|
|
|
|
NvError
|
|
nvBoard_PostOEMPowerHandlerVideoPowerOff(void);
|
|
|
|
NvError
|
|
nvBoard_PreOEMPowerHandlerVideoPowerOn(void);
|
|
|
|
NvError
|
|
nvBoard_PostOEMPowerHandlerVideoPowerOn(void);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // NVBOARD_H
|