📄 smi.h
字号:
BOOL IsHighPowerConsumption();
VGX_POWER_STATE GetCurrentPowerState();
HANDLE GetPMMessageQueue();
DWORD GetPowerOnLastRequested();
DWORD GetReducedLastRequested();
DWORD GetMinimalLastRequested();
BOOL ReduceClock(VGX_POWER_STATE PowerState);
void ReduceVoltage(BOOL bReduce = TRUE);
DWORD SetIdle(DWORD TicksToReduced, DWORD TicksToMinimal);
DWORD GetTicksToReduced();
DWORD GetTicksToMinimal();
BOOL IsPowerStateLocked();
void LockPowerState(BOOL bLock = TRUE);
BOOL IsMonitorEnabled();
void SetMonitorEnabled(BOOL bEnabled = TRUE);
DWORD SetModuleMonitorEnabled(VGXPM_MODULES Module, BOOL bEnabled = TRUE);
DWORD SetModulePower(VGXPM_MODULES Module, VGX_POWER_STATE State);
DWORD SetTicksToPowerDown(VGXPM_MODULES Module, DWORD dwCount);
VOID SetClockArray(CLOCK_ARRAY& Array);
DWORD GetModuleMonitorEnabled(VGXPM_MODULES Module, BOOL& bEnabled);
DWORD GetModulePower(VGXPM_MODULES Module, VGX_POWER_STATE& State);
DWORD GetLastCallTickCount(VGXPM_MODULES Module, DWORD& dwCount);
DWORD GetTicksToPowerDown(VGXPM_MODULES Module, DWORD& dwCount);
VOID GetClockArray(CLOCK_ARRAY& Array);
void ProcessGates(DWORD& Gate);
void setPower(DWORD Gate, DWORD Clock);
void setClock(DWORD Clock);
void setGate(DWORD Mask, DWORD Value);
void setDPMS(DPMS_t state);
// End of Power Management definition
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// Pulse Width Modulation: pwm.cpp
protected:
PWM_STRUCT m_PWMInfo[VGXPWMCOUNT]; // One for each PWM
BOOL m_bPWMEnabled; // PWM flag
BOOL CreatePWMEvent(PWM_STRUCT& PWMInfo);
public:
VOID InitPulseWidthModulation();
ULONG HandleSMIPWMAPI(ULONG cjIn, PVOID pvIn, ULONG cjOut, PVOID pvOut);
VOID pwmIntHandler();
ULONG pwmInit(
VGXPWM_INDEX PWMIndex, // PWM index
WORD wLowCounter, // Low counter
WORD wHighCounter, // High counter
BYTE byClockDivider, // Clock divider
BOOL bIntEnable); // Interrupt enable
ULONG pwmStart(
VGXPWM_INDEX PWMIndex); // PWM number
BOOL pwmStop(
VGXPWM_INDEX PWMIndex); // PWM number
// End of Pulse Width Modulation definition
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// I2C management: i2c.cpp
protected:
HANDLE m_I2CIntEvent; // Interrupt event
VGXI2C_RESULTS m_I2CStatus; // Status variable
BOOL m_bI2CEnabled; // I2C flag
public:
ULONG HandleSMII2CAPI(ULONG cjIn, PVOID pvIn, ULONG cjOut, PVOID pvOut);
VOID i2cIntHandler();
ULONG i2cReset();
ULONG i2cDoRead(PBYTE& pBuffer, DWORD dwCount);
ULONG i2cDoWrite(PBYTE& pBuffer, DWORD dwCount);
ULONG i2cOpen(
BOOL bFastMode, // Fast mode enable
BOOL bRepStart); // Repeated start enable
VOID i2cClose();
ULONG i2cRead(
BYTE byAddress, // Slave address
DWORD dwCount, // Number of bytes to be read
PBYTE pBuffer); // Buffer pointer
ULONG i2cWrite(
BYTE byAddress, // Slave address
DWORD dwCount, // Number of bytes to be read
PBYTE pBuffer); // Buffer pointer
// End of I2C management definition
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// SSP management: ssp.cpp
protected:
#ifndef DISABLE_INTERRUPT_MANAGEMENT
SSP_INFO m_SSPInfo[SSP_COUNT];
#endif
public:
ULONG HandleSMISSPAPI(ULONG cjIn, PVOID pvIn, ULONG cjOut, PVOID pvOut);
#ifndef DISABLE_INTERRUPT_MANAGEMENT
VOID sspIntHandler(VGXSSP_ENUM ssp);
#endif
VOID InitSSP();
ULONG sspOpen(
PVGXSSP_OPEN_STRUCT pInit);
ULONG sspClose(
VGXSSP_ENUM ssp); // SSP number
ULONG sspRead(
VGXSSP_ENUM ssp, // SSP number
PBYTE pBuffer, // Read buffer pointer
DWORD dwSize, // Number of bytes to read
DWORD& dwRead); // Number of bytes read
ULONG sspWrite(
VGXSSP_ENUM ssp, // SSP number
PBYTE pBuffer, // Write buffer
DWORD dwSize, // Number of bytes to write
DWORD& dwWritten); // Number of bytes written
ULONG sspResetBuffer(
VGXSSP_ENUM ssp); // SSP number
// End of SSP management definition
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// GPIO management: gpio.cpp (to be created)
protected:
BOOL m_bGPIOEnabled;
// End of GPIO management definition
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// Alpha Overlay : misc.cpp
protected:
BOOL m_bAlphaEnabled;
public:
ULONG HandleSMIAlphaOverlayCommand(ULONG cjIn, PVOID pvIn, ULONG cjOut, PVOID pvOut);
#ifdef ALPHA_BLEND_DEMO
ULONG AdjustAlphaBoundary(ULONG cjIn);
ULONG CreateAlphaSurface();
ULONG EnableAlphaBlend();
ULONG DisableAlphaBlend();
ULONG AdjustAlpha(ULONG cjIn);
#endif
// End of Alpha Overlay definition
///////////////////////////////////////////////////////////////////////////
#ifdef DD_ENABLE
friend void buildDDHALInfo( LPDDHALINFO lpddhi, DWORD modeidx );
#endif // DD_ENABLE
#ifdef MULTIMONEMU_ENABLE
friend class SMIVGXEmu;
#endif
};
typedef SMI PDEV;
typedef SMI HW_DEVICE_EXTENSION;
typedef SMI* PPDEV;
typedef SMI* PHW_DEVICE_EXTENSION;
#ifdef DD_ENABLE
class SMISurf : public DDGPESurf
#elif ROTATION_ENABLE
class SMISurf : public GPESurfRotate
#else // ! DD_ENABLE
class SMISurf : public GPESurf
#endif
{
private:
#ifdef DD_ENABLE
SurfaceHeap *m_pHeap;
#else
Node2D *m_pNode2D;
#endif
int m_nAlignedWidth;
SMI *m_pSMI;
public:
#ifdef DD_ENABLE
SMISurf(int width, int alignedWidth, int height, ULONG offset, PVOID pBits, int stride,
EGPEFormat format, EDDGPEPixelFormat pixelFormat,
SurfaceHeap *pHeap, SMI *pSMI);
SMISurf(int width, int alignedWidth, int height, int stride,
EGPEFormat format, EDDGPEPixelFormat pixelFormat);
#else // !DD_ENABLE
SMISurf(int width, int height, ULONG offset, PVOID pBits, int stride, EGPEFormat format,
Node2D *pNode, SMI *pSMI);
int Top(void) { return m_pNode2D->Top(); }
int Left(void) { return m_pNode2D->Left(); }
#endif
#ifndef ROTATION_ENABLE
void SetRotation(int width, int height, int iRotate) { }
#endif // ROTATION_ENABLE
virtual DWORD AlignedWidth (void) { return (DWORD) m_nAlignedWidth; }
virtual ~SMISurf(void);
};
#define MM_RW_8 *(RWReg8 *)&
#define MM_RW_16 *(RWReg16 *)&
#define MM_RW_32 *(RWReg32 *)&
//
// MEMORY ARENA DEFINITIONS
//
extern PUCHAR g_pREG;
//#define VGX_MMIO_ARENA g_pREG //Use global g_pREG instead of m_pREG so that other functions can use related macros
#define VGX_MMIO_ARENA m_pREG
//
// MMIO MACROS
//
extern int jkj;
#define POKE_8(address, value) do{*(volatile UCHAR *)(VGX_MMIO_ARENA + (address)) = (value); }while(0)
#define POKE_16(address, value) do{*(volatile USHORT *)(VGX_MMIO_ARENA + (address)) = (value); }while(0)
#define POKE_32(address, value) do{ulong aa; aa = value; if(address == 0x80200 && (aa & 0xf) != 5) {jkj++;aa = aa;};\
if(address == 0x80200) \
{\
RETAILMSG(1, (TEXT("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXaaa=0x%08X %08X\r\n"), aa, PEEK_32(0x80200)));\
aa = 0x10305;\
}\
if(address == 0x80204 || address == 0x8000c) \
{\
RETAILMSG(1, (TEXT("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXaaa=0x%08X %08X\r\n"), (address), aa ));\
if(address == 0x80204)\
aa=0x80000000;\
}\
*(volatile ULONG *)(VGX_MMIO_ARENA + (address)) = (aa);}while(0)
/*#define POKE_32(address, value) do{ \
TCHAR aaa[300]; \
*(volatile ULONG *)(VGX_MMIO_ARENA + (address)) = (value); \
wsprintf(aaa, _T("aaaaaaaaaaaaavalue=0x%08X addr=0x%08X file=%s line=%s\r\n"), value, VGX_MMIO_ARENA + (address), __FILE__, __LINE__);\
RETAILMSG(1, (TEXT("%S"),aaa));\
}while(0)*/
#define PEEK_8(address) *(volatile UCHAR *)(VGX_MMIO_ARENA + (address))
#define PEEK_16(address) *(volatile USHORT *)(VGX_MMIO_ARENA + (address))
#define PEEK_32(address) *(volatile ULONG *)(VGX_MMIO_ARENA + (address))
#define peekRegisterDWord PEEK_32
#define pokeRegisterDWord POKE_32
#define peekRegisterByte PEEK_8
#define pokeRegisterByte POKE_8
#define REVISION FIELD_GET(PEEK_32(DEVICE_ID), DEVICE_ID, REVISION_ID)
#define DEVICEID FIELD_GET(PEEK_32(DEVICE_ID), DEVICE_ID, DEVICE_ID)
// Internal macros.
#define _F_START(f) (0 ? f)
#define _F_END(f) (1 ? f)
#define _F_SIZE(f) (1 + _F_END(f) - _F_START(f))
#define _F_MASK(f) (((1 << _F_SIZE(f)) - 1) << _F_START(f))
#define _F_NORMALIZE(v, f) (((v) & _F_MASK(f)) >> _F_START(f))
#define _F_DENORMALIZE(v, f) (((v) << _F_START(f)) & _F_MASK(f))
// Global macros.
#define FIELD_GET(x, reg, field) (_F_NORMALIZE((x), reg ## _ ## field))
#define FIELD_SET(x, reg, field, value) ( (x & ~_F_MASK(reg ## _ ## field)) | _F_DENORMALIZE(reg ## _ ## field ## _ ## value, reg ## _ ## field))
#define FIELD_VALUE(x, reg, field, value) ( (x & ~_F_MASK(reg ## _ ## field)) | _F_DENORMALIZE(value, reg ## _ ## field) )
#define FIELD_CLEAR(reg, field) ( ~ _F_MASK(reg ## _ ## field) )
#define FIELD_INIT(reg, field, value) _F_DENORMALIZE(reg ## _ ## field ## _ ## value, reg ## _ ## field)
#define FIELD_INIT_VAL(reg, field, value) (_F_DENORMALIZE(value, reg ## _ ## field))
#define FIELD_GET_MASK(reg, field) _F_MASK(reg ## _ ## field)
#define RGB24(r, g, b) ( (unsigned long) (((r) << 16) | ((g) << 8) | (b)) )
#define RGB16(r, g, b) ( (unsigned short) ((((r) & 0xF8) << 8) | (((g) & 0xFC) << 3) | (((b) & 0xF8) >> 3)) )
// Some hardware bits
#define IS_BUSY (FIELD_GET(PEEK_32(CMD_INTPR_STATUS), CMD_INTPR_STATUS, 2D_ENGINE) == CMD_INTPR_STATUS_2D_ENGINE_BUSY)
#define IS_EMPTY (FIELD_GET(PEEK_32(CMD_INTPR_STATUS), CMD_INTPR_STATUS, 2D_FIFO) == CMD_INTPR_STATUS_2D_FIFO_EMPTY)
#define PANEL_SCANLINE (FIELD_GET(PEEK_32(PANEL_CURRENT_LINE), PANEL_CURRENT_LINE, LINE))
// SMI DPR Registers in MMIO space.
#define reg_SourceXY (MM_RW_32 m_pDPR[0x00])
#define reg_DestXY (MM_RW_32 m_pDPR[0x04])
#define reg_DimXY (MM_RW_32 m_pDPR[0x08])
#define reg_ROPCommand (MM_RW_32 m_pDPR[0x0C])
#define reg_RowPitch (MM_RW_32 m_pDPR[0x10])
#define reg_FgColor (MM_RW_32 m_pDPR[0x14])
#define reg_BgColor (MM_RW_32 m_pDPR[0x18])
#define reg_DataFormat (MM_RW_16 m_pDPR[0x1E])
#define reg_ColorCmp (MM_RW_32 m_pDPR[0x20])
#define reg_ColorMask (MM_RW_32 m_pDPR[0x24])
#define reg_Masks (MM_RW_32 m_pDPR[0x28])
#define reg_ScissorTL (MM_RW_32 m_pDPR[0x2C])
#define reg_ScissorBR (MM_RW_32 m_pDPR[0x30])
#define reg_PatternLow (MM_RW_32 m_pDPR[0x34])
#define reg_PatternHigh (MM_RW_32 m_pDPR[0x38])
#define reg_WindowWidth (MM_RW_32 m_pDPR[0x3C])
#define reg_SourceBase (MM_RW_32 m_pDPR[0x40])
#define reg_DestBase (MM_RW_32 m_pDPR[0x44])
// Drawing Engine Constant
#define START_DRAWING_ENGINE 0x80000000
#define MONO_PATTERN 0x00000000
#define COLOR_PATTERN 0x40000000
#define UPDATE_DST_X 0x20000000
#define QUICK_START_ENABLE 0x10000000
#define TOP_TO_BOTTOM 0x00000000
#define BOTTOM_TO_TOP 0x08000000
#define RIGHT_TO_LEFT BOTTOM_TO_TOP
#define LEFT_TO_RIGHT TOP_TO_BOTTOM
#define GRAPHICS_STRETCH_ENABLE 0x00800000
#define SOURCE_IS_COLOR 0x00000000
#define SOURCE_IS_MONO 0x00400000
#define NOT_DRAW_LAST_PIXEL 0x00000000
#define DRAW_LAST_PIXEL 0x00200000
#define HOSTBLT_CAPTURE_ENABLE 0x00100000
#define CMD_BITBLT 0x00000000
#define CMD_RECTANGLE_FILL 0x00010000
#define CMD_TRAPEZOID_FILL 0x00030000
#define CMD_RLE_STRIP_DRAW 0x00050000
#define CMD_SHORT_STROKE 0x00060000
#define CMD_BRESENHAM_LINE 0x00070000
#define CMD_HOSTBLT_WRITE 0x00080000
#define CMD_HOSTBLT_READ 0x00090000
#define MONO_NOPACK 0x00000000
#define MONO_PACK8 0x00001000
#define MONO_PACK16 0x00002000
#define MONO_PACK32 0x00003000
#define ROP2_SRC_IS_PAT 0x00004000
#define USE_ROP3 0x00000000
#define USE_ROP2 0x00008000
#define TRANSPARENCY_ENABLE 0x00000100
#define SRC_CONTROL_TRANSP 0x00000000
#define DST_CONTROL_TRANSP 0x00000200
#define MATCH_PIXEL_OPAQUE 0x00000000
#define MATCH_PIXEL_TRANSP 0x00000400
// Video Constants
#define REPLICATE 0
#define INTERPOLATE 1
// Extra DebugZone Definition
#define GPE_ZONE_VPE DEBUGZONE(15)
#ifdef DUMP_2DREG
extern UCHAR DP_reg1[0x60];
extern UCHAR DP_reg2[0x60];
extern int cur_reg;
#define GetReg(store_addr, reg_addr, count) \
for (cur_reg=0; cur_reg<count; cur_reg++) {store_addr[cur_reg]=reg_addr[cur_reg];}
#else //DUMP_2DREG
#define GetReg(store_addr, reg_addr, count)
#endif // DUMP_2DREG
#endif // __SMI_H__
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -