// =============================================================================
// hal_CameraReset(BOOL InReset)
// -----------------------------------------------------------------------------
/// Puts the Camera sensor in Reset or out of Reset.
///
/// @param InReset if true, put the external camera sensor in reset
// =============================================================================
PUBLIC VOID hal_CameraReset(BOOL InReset)
{
if (g_halCameraConfig.camId == 0)
{
// Use sensor 0
if (g_halCfg->camCfg.camRstRemap.gpioId == HAL_GPIO_NONE)
{
// Configures the Reset bit to the camera
if (InReset)
{
hwp_camera->CMD_SET = CAMERA_RESET;
}
else
{
hwp_camera->CMD_CLR = CAMERA_RESET;
}
}
else
{
// Use GPIO
if ((g_halCameraConfig.rstActiveH && InReset) || ((!g_halCameraConfig.rstActiveH) && (!InReset)))
{
hal_GpioSet(g_halCfg->camCfg.camRstRemap);
}
else
{
hal_GpioClr(g_halCfg->camCfg.camRstRemap);
}
}
}
else
{
// Use sensor 1
// Use GPIO
if (g_halCfg->camCfg.cam1RstRemap.gpioId == HAL_GPIO_NONE)
{
// Configures the Reset bit to the camera
if (InReset)
{
hwp_camera->CMD_SET = CAMERA_RESET;
}
else
{
hwp_camera->CMD_CLR = CAMERA_RESET;
}
}
else
{
// Use GPIO
if ((g_halCameraConfig.rstActiveH && InReset) || ((!g_halCameraConfig.rstActiveH) && (!InReset)))
{
hal_GpioSet(g_halCfg->camCfg.cam1RstRemap);
}
else
{
hal_GpioClr(g_halCfg->camCfg.cam1RstRemap);
}
}
}
}
PUBLIC FMD_ERR_T fmd_Open(CONST TGT_FMD_CONFIG_T* fmdTgtCfg,
FMD_BAND_T band,
FMD_CALLBACK_T* callback,
FMD_INIT_T* initValues)
{
UINT8 dacVol;
UINT32 chan;
// Check if already opened
// -----------------------
if (g_band != FMD_BAND_QTY)
{
return FMD_ERR_ALREADY_OPENED;
}
// Check the parameters and store them
// -----------------------------------
switch (band)
{
case FMD_BAND_US_EUROPE:
case FMD_BAND_JAPAN:
case FMD_BAND_WORLD:
case FMD_BAND_EAST_EUROPE:
g_band = band;
break;
default:
// this chip has limited band support...
return FMD_ERR_BAD_PARAMETER;
}
if (fmdTgtCfg == NULL)
{
g_band = FMD_BAND_QTY; // close marker
return FMD_ERR_BAD_PARAMETER;
}
g_fmdConfig = fmdTgtCfg;
g_callback = callback;
// default : mute , stereo, no bass boost
dacVol = 0;
chan = 0;
// set the required initial state
// ------------------------------
if (initValues != NULL)
{
// set given parameters
dacVol = g_fmdConfig->volumeVal[initValues->volume];
chan = (initValues->freqKHz) ;
}
SXS_TRACE(TSTDOUT,"fmd_Open chanfreqKHz:%d ",chan);
// Sets the PowerDown
if(g_fmdConfig->pinPdn.type==HAL_GPIO_TYPE_IO)
{
hal_GpioSetOut(g_fmdConfig->pinPdn.gpioId);
}
hal_GpioSet(g_fmdConfig->pinPdn);
#ifdef I2C_BASED_ON_GPIO
gpio_i2c_open();
#else
//xiaoyifeng for atv
//for IIC pull up
pmd_EnablePower(PMD_POWER_CAMERA,TRUE);
g_atvdI2cBusId = tgt_GetAtvdConfig()->i2cBusId;
hal_I2cOpen(g_atvdI2cBusId);
#endif
#ifdef RDA5888_FM_26MCRYSTAL_ENABLE
{
hal_SysAuxClkOut(TRUE);
}
#endif
RDA5888FM_Init();
//open 32k here
#ifdef RDA5888_32KFMMODE_ENALBE
#ifdef RDA5888_FM_26MCRYSTAL_ENABLE
{
hal_SysAuxClkOut(FALSE);
}
#endif
{
RDA_Open32KOnChip();
}
#endif
//set volume about dacVol
if (dacVol == FMD_ANA_MUTE)
{
// fmd_Write(0x10,0xc500); // close adac
}
else
{
//fmd_Write(0x10,0x8500); // open adac
}
// sxr_Sleep(10 MILLI_SECONDS);
// fmd_FieldWrite(0x125, 0xff80, dacVol);
// sxr_Sleep(50 MILLI_SECONDS);
return FMD_ERR_NO;
}
PROTECTED VOID hal_KeyIrqHandler(UINT8 interruptId)
{
// interrupt status
UINT32 status;
// Keys pressed a the time of the interrupt
HAL_KEY_MATRIX_T scannedKeys;
// On-Off key state at the time of the interrupt
BOOL scannedOnOff;
// Variables to store the state of the different keys
HAL_KEY_MATRIX_T downKeys;
HAL_KEY_MATRIX_T upKeys;
HAL_KEY_MATRIX_T pressedKeys;
BOOL ExpKeyDet = FALSE;
status = hwp_keypad->KP_IRQ_CAUSE &
(KEYPAD_KP_EVT0_IRQ_CAUSE|KEYPAD_KP_EVT1_IRQ_CAUSE|KEYPAD_KP_ITV_IRQ_CAUSE) ;
// Clear IRQ
hwp_keypad->KP_IRQ_CLR = KEYPAD_KP_IRQ_CLR;
if ((status & KEYPAD_KP_EVT0_IRQ_CAUSE) || (status & KEYPAD_KP_ITV_IRQ_CAUSE))
{
hal_KeySingleScan(scannedKeys);
if (scannedKeys[0] == COL0_PATTERN)
{
g_expKey[0] = 0;
ExpKeyDet = TRUE;
}
else if (scannedKeys[0] == COL1_PATTERN)
{
g_expKey[0] = 1;
ExpKeyDet = TRUE;
}
else if (scannedKeys[0] == COL2_PATTERN)
{
g_expKey[0] = 2;
ExpKeyDet = TRUE;
}
else if (scannedKeys[0] == COL3_PATTERN)
{
g_expKey[0] = 3;
ExpKeyDet = TRUE;
}
else if (scannedKeys[0] == COL4_PATTERN)
{
g_expKey[0] = 4;
ExpKeyDet = TRUE;
}
else if (scannedKeys[0] == COL5_PATTERN)
{
g_expKey[0] = 5;
ExpKeyDet = TRUE;
}
else
{
ExpKeyDet = FALSE;
}
}
if (status & KEYPAD_KP_EVT1_IRQ_CAUSE)
{
if (g_ExpKeyPressed)
{
HAL_TRACE(HAL_IO_TRC, 0, "HAL_KEY: Key Up -> Finish Exp Key config");
hwp_keypad->KP_CTRL = g_kpCtrlReg | KEYPAD_KP_ITV_TIME(g_kpItvReg) | KEYPAD_KP_DBN_TIME(g_kpdbReg);
g_ItvTimeShort = FALSE;
g_ExpKeyPressed = FALSE;
g_kpItvCnt = 0;
if (g_RowToDisable == 6)
{
g_RowToDisable = 7;
}
else
{
g_RowToDisable = 6;
}
hal_ExpKeyCallHandler(g_expKey, HAL_KEY_UP);
// Reset KeyOut6 & 7 to '1'
hal_GpioSet(g_keyOut6);
hal_GpioSet(g_keyOut7);
}
}
if (!ExpKeyDet)
{
// All keys are released
if ((status & KEYPAD_KP_EVT1_IRQ_CAUSE) && g_eventOnUp)
{
pressedKeys[0] = 0;
pressedKeys[1] = 0;
scannedOnOff = FALSE;
// All previously pressed keys are released
hal_KeyCallHandler(g_previousKeys, HAL_KEY_UP);
// on-off button
if (g_previousOnOff)
{
g_keyIrqHandler(255, HAL_KEY_UP);
}
// Keep track of the pressed buttons.
g_previousKeys[0] = pressedKeys[0];
g_previousKeys[1] = pressedKeys[1];
g_previousOnOff = scannedOnOff;
}
else
{
// Key up or down
if (status & KEYPAD_KP_EVT0_IRQ_CAUSE)
{
hal_KeySingleScan(scannedKeys);
scannedOnOff = hal_KeyOnOffStateGet();
// Send the ***pressed events*** only if user requested it.
if (g_eventOnPressed && NULL != g_keyIrqHandler)
{
// Pressed key detection
// Those are the one previously pressed and still pressed now
pressedKeys[0] = (scannedKeys[0] & g_previousKeys[0]);
pressedKeys[1] = (scannedKeys[1] & g_previousKeys[1]);
hal_KeyCallHandler(pressedKeys, HAL_KEY_PRESSED);
// on-off button
if (g_previousOnOff & scannedOnOff)
{
g_keyIrqHandler(255, HAL_KEY_PRESSED);
}
}
// If the pressed buttons changed.
if (scannedKeys[0] != g_previousKeys[0] ||
scannedKeys[1] != g_previousKeys[1] ||
scannedOnOff != g_previousOnOff)
{
// Send the ***down events*** only if user requested it.
if (g_eventOnDown && NULL != g_keyIrqHandler)
{
// Key that are now pressed but weren't before
downKeys[0] = scannedKeys[0] & ~g_previousKeys[0];
downKeys[1] = scannedKeys[1] & ~g_previousKeys[1];
// low and high keys
hal_KeyCallHandler(downKeys, HAL_KEY_DOWN);
// on-off button
if (~g_previousOnOff & scannedOnOff)
{
g_keyIrqHandler(255, HAL_KEY_DOWN);
}
}
// Send the ***up events*** only if user requested it.
if (g_eventOnUp && NULL != g_keyIrqHandler)
{
// Keys that are now unpressed but were pressed before
upKeys[0] = ~scannedKeys[0] & g_previousKeys[0];
upKeys[1] = ~scannedKeys[1] & g_previousKeys[1];
// low and high keys
hal_KeyCallHandler(upKeys, HAL_KEY_UP);
// on-off key
if (g_previousOnOff & ~scannedOnOff)
{
g_keyIrqHandler(255, HAL_KEY_UP);
}
}
// Keep track of the pressed buttons.
g_previousKeys[0] = scannedKeys[0];
g_previousKeys[1] = scannedKeys[1];
g_previousOnOff = scannedOnOff;
}
}
else
{
// There are only already pressed keys
// still pressed, so no change in pressed keys
// and no need for a new scan
if ((status & KEYPAD_KP_ITV_IRQ_CAUSE) && g_eventOnPressed)
{
hal_KeyCallHandler(g_previousKeys, HAL_KEY_PRESSED);
// on-off button
if (g_previousOnOff)
{
g_keyIrqHandler(255, HAL_KEY_PRESSED);
}
}
}
}
}
else // Expand Key
{
if (status & KEYPAD_KP_EVT0_IRQ_CAUSE)
{
hwp_keypad->KP_CTRL = g_kpCtrlReg | KEYPAD_KP_ITV_TIME(0) | KEYPAD_KP_DBN_TIME(1);
g_ItvTimeShort = TRUE;
HAL_TRACE(HAL_IO_TRC, 0, "HAL_KEY: COL_DET");
if (g_RowToDisable == 6)
{
hal_GpioClr(g_keyOut6);
}
else
{
hal_GpioClr(g_keyOut7);
}
g_ExpKeyPressed = TRUE;
}
if (status & KEYPAD_KP_ITV_IRQ_CAUSE)
{
if (g_ItvTimeShort)
{
hwp_keypad->KP_CTRL = g_kpCtrlReg | KEYPAD_KP_ITV_TIME(g_kpItvReg) | KEYPAD_KP_DBN_TIME(g_kpdbReg);
g_ItvTimeShort=FALSE;
if (g_RowToDisable == 6)
{
// Row 6 is disabled, so exp key is on row 7
g_expKey[1] = 1;
HAL_TRACE(HAL_IO_TRC, 0, "HAL_KEY: Key Down 7");
}
else
{
// Row 7 is disabled, so exp key is on row 6
g_expKey[1] = 0;
HAL_TRACE(HAL_IO_TRC, 0, "HAL_KEY: Key Down 6");
}
hal_ExpKeyCallHandler(g_expKey, HAL_KEY_DOWN);
}
else
{
if (g_RowToDisable == 6)
{
// Row 6 is disabled, so exp key is on row 7
g_expKey[1] = 1;
HAL_TRACE(HAL_IO_TRC, 0, "HAL_KEY: Key Pressed 7");
}
else
{
// Row 7 is disabled, so exp key is on row 6
g_expKey[1] = 0;
HAL_TRACE(HAL_IO_TRC, 0, "HAL_KEY: Key Pressed 6");
}
if (g_kpItvCnt)
{
hal_ExpKeyCallHandler(g_expKey, HAL_KEY_PRESSED);
}
g_kpItvCnt++;
}
}
}
}
// ============================================================================
// hal_KeyOpen
// ----------------------------------------------------------------------------
/// This function initializes the keypad driver. The configuration of the key
/// pins used is board dependent and is built in HAL through the
/// #tgt_BoardConfig.halCfg structure.
///
/// @param debounceTime defines the time to wait for debounce, in number of
/// 16384Hz steps. Boundaries applied to the possible values of this time,
/// which are dependent on the board config, especially the number of
/// out line of the keypad: the value of this parameter must be chosen
/// between 5*Number of Enabled KeyOu and 1280*Number of Enabled
/// Please refer to the keypad documentation for
/// details.
/// @param kpItvTime defines the interval time between the generation of IRQ
/// when one or more keys are being held down. It defines a multiple of the
/// debounce time.
// ============================================================================
PUBLIC VOID hal_KeyOpen(UINT16 debounceTime, UINT16 kpItvTime)
{
CONST HAL_CFG_CONFIG_T* halCfg = g_halCfg;
UINT32 keyOutMask = halCfg->keyOutMask | 0x1;
UINT32 temp;
UINT32 nbKeyOut = 0;
// Debounce value to enter in the control reg
UINT32 dbnTimeReg = 0;
// Save current OnOff key status for power-on check (Otherwise
// we will have to wait the debounce time after enabling keypad.
// See the last comments of this function)
hal_KeyOnOffStateAtPowerOn();
// Count the number of enabled keyout.
temp = keyOutMask;
while (temp != 0)
{
if (temp & 0x1)
{
nbKeyOut += 1;
}
temp = temp >>1;
}
#ifdef TGT_WITH_EXPKEY
g_ExpKeyCfg = tgt_GetExpKeyConfig();
if (g_ExpKeyCfg->expKeyUsed)
{
g_keyOut6 = g_ExpKeyCfg->expKeyOut6;
g_keyOut7 = g_ExpKeyCfg->expKeyOut7;
if ((g_keyOut6.type == HAL_GPIO_TYPE_O) &&
(g_keyOut7.type == HAL_GPIO_TYPE_O))
{
hal_GpioSet(g_keyOut6);
hal_GpioSet(g_keyOut7);
}
else
{
HAL_ASSERT(FALSE, "Should Use GPO as KeyOut!");
}
}
#endif
// Reset the event generation configuration.
g_eventOnUp = FALSE;
g_eventOnPressed = FALSE;
g_eventOnDown = FALSE;
g_keyIrqHandler = NULL;
// Initialize the previous state.
g_previousKeys[0] = 0;
g_previousKeys[1] = 0;
g_previousOnOff = hal_KeyOnOffStateGet();
if(nbKeyOut != 0)
{
HAL_ASSERT( (debounceTime >= 5 * nbKeyOut ) && (debounceTime <= 256*5*nbKeyOut),
"Improper debounce times used: %d", debounceTime);
// Value to enter in the register bitfield
// De-bounce time = (KP_DBN_TIME + 1) * SCAN_TIME,
// SCAN_TIME = 0.3125 ms * Number of Enabled KeyOut (determined by KP_OUT_MASK).
// For example, if KP_DBN_TIME = 7, KP_OUT_MASK = "111111", then
// De-bounce time = (7+1)*0.3125*6=15 ms. The maximum debounce time is 480 ms.
dbnTimeReg = (debounceTime / (5 * nbKeyOut)) - 1;
}
else
{
dbnTimeReg = (debounceTime) - 1;
}
// Ensure keypad runs out of its state machine
// (Keypad might have been enabled at boot time)
hwp_keypad->KP_CTRL = 0;
// It needs 1 cycle of 16K clock to disable keypad
hal_TimDelay(3);
hwp_keypad->KP_CTRL = KEYPAD_KP_DBN_TIME(dbnTimeReg)
| KEYPAD_KP_ITV_TIME(kpItvTime)
| KEYPAD_KP_EN | KEYPAD_KP_IN_MASK(halCfg->keyInMask)
| KEYPAD_KP_OUT_MASK(keyOutMask);
// clear current IRQ
hwp_keypad->KP_IRQ_CLR = KEYPAD_KP_IRQ_CLR;
//g_halMapAccess.keypadPulseHandler = (void*)hal_KeyRemoteHandler;
#ifdef TGT_WITH_EXPKEY
g_kpItvReg = kpItvTime;
g_kpdbReg = dbnTimeReg;
g_kpCtrlReg = KEYPAD_KP_ITV_IRQ_MASK
| KEYPAD_KP_EVT1_IRQ_MASK
| KEYPAD_KP_EVT0_IRQ_MASK | KEYPAD_KP_EN
| KEYPAD_KP_IN_MASK(halCfg->keyInMask)
| KEYPAD_KP_OUT_MASK(keyOutMask);
#endif
// !!! CAUTION !!!
// After keypad is enabled, the status of individual keys (including
// OnOff key) will NOT be available until the debouce time elapses.
}
// ============================================================================
// lcddp_Blit16
// ----------------------------------------------------------------------------
/// This function provides the basic bit-block transfer capabilities.
/// This function copies the data (such as characters/bmp) on the LCD directly
/// as a (rectangular) block. The data is drawn in the active window.
/// The buffer has to be properly aligned (@todo define properly 'properly')
///
/// @param pPixelData Pointer to the buffer holding the data to be displayed
/// as a block. The dimension of this block are the one of the #pDestRect
/// parameter
/// @return #LCDD_ERR_NO, #LCDD_ERR_RESOURCE_BUSY or #LCDD_ERR_NOT_OPENED.
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_Blit16(CONST LCDD_FBW_T* frameBufferWin, UINT16 startX, UINT16 startY)
{
LCDD_ASSERT((frameBufferWin->fb.width&1) == 0, "LCDD: FBW must have an even number "
"of pixels per line. Odd support is possible at the price of a huge "
"performance lost");
// Active window coordinates.
HAL_GOUDA_WINDOW_T inputWin;
HAL_GOUDA_WINDOW_T activeWin;
hal_HstSendEvent(0x88855516);
UINT32 now = hal_TimGetUpTime();
if (0 == lcdd_MutexGet())
{
return LCDD_ERR_RESOURCE_BUSY;
}
else
{
if (g_lcddInSleep)
{
lcdd_MutexFree();
return LCDD_ERR_NO;
}
// Set Input window
inputWin.tlPX = frameBufferWin->roi.x;
inputWin.brPX = frameBufferWin->roi.x + frameBufferWin->roi.width - 1;
inputWin.tlPY = frameBufferWin->roi.y;
inputWin.brPY = frameBufferWin->roi.y + frameBufferWin->roi.height - 1;
// Set Active window
activeWin.tlPX = startX;
activeWin.brPX = startX + frameBufferWin->roi.width - 1;
activeWin.tlPY = startY;
activeWin.brPY = startY + frameBufferWin->roi.height - 1;
// Check parameters
// ROI must be within the screen boundary
// ROI must be within the Frame buffer
// Color format must be 16 bits
BOOL badParam = FALSE;
if (g_lcddRotate)
{
if ( (activeWin.tlPX >= LCDD_DISP_Y) ||
(activeWin.brPX >= LCDD_DISP_Y) ||
(activeWin.tlPY >= LCDD_DISP_X) ||
(activeWin.brPY >= LCDD_DISP_X)
)
{
badParam = TRUE;
}
}
else
{
if ( (activeWin.tlPX >= LCDD_DISP_X) ||
(activeWin.brPX >= LCDD_DISP_X) ||
(activeWin.tlPY >= LCDD_DISP_Y) ||
(activeWin.brPY >= LCDD_DISP_Y)
)
{
badParam = TRUE;
}
}
if (!badParam)
{
if ( (frameBufferWin->roi.width > frameBufferWin->fb.width) ||
(frameBufferWin->roi.height > frameBufferWin->fb.height) ||
(frameBufferWin->fb.colorFormat != LCDD_COLOR_FORMAT_RGB_565)
)
{
badParam = TRUE;;
}
}
if (badParam)
{
lcdd_MutexFree();
return LCDD_ERR_INVALID_PARAMETER;
}
// this will allow to keep LCDD interface for blit while using gouda
// directly for configuring layers
if (frameBufferWin->fb.buffer != NULL)
{
g_lcddAutoCloseLayer = FALSE;
WriteCommand_Addr(0x2a);WriteCommand_Data(0x00);WriteCommand_Data(activeWin.tlPX);
WriteCommand_Data(0x00);WriteCommand_Data(activeWin.brPX);
WriteCommand_Addr(0x2b);WriteCommand_Data(0x00);WriteCommand_Data(activeWin.tlPY );
WriteCommand_Data(0x00);WriteCommand_Data(activeWin.brPY);
#if 0
LCM_WR_REG(0x0002,(hsa>>8)&0x00ff); // Column address start2
LCM_WR_REG(0x0003,hsa&0x00ff); // Column address start1
LCM_WR_REG(0x0004,(hea>>8)&0x00ff); // Column address end2
LCM_WR_REG(0x0005,hea&0x00ff); // Column address end1
LCM_WR_REG(0x0006,(vsa>>8)&0x00ff); // Row address start2
LCM_WR_REG(0x0007,vsa&0x00ff); // Row address start1
LCM_WR_REG(0x0008,(vea>>8)&0x00ff); // Row address end2
LCM_WR_REG(0x0009,vea&0x00ff); // Row address end1
#endif
WriteCommand_Addr(0x2c);
hal_GpioSet(g_slcd_a0);
}
if (frameBufferWin->roi.width == frameBufferWin->fb.width)
{
// The source buffer and the roi have the same width, we can
// do a single linear transfer
lcdd_TransferData(frameBufferWin->fb.buffer+frameBufferWin->roi.y*frameBufferWin->roi.width
,frameBufferWin->roi.width*frameBufferWin->roi.height,TRUE);
hal_HstSendEvent(0x88855528);
}
else
{
// The source buffer is wider than the roi
// we have to do a 2D transfer
UINT16 curLine=0;
UINT16 startLine = frameBufferWin->roi.y;
UINT16 endLine = frameBufferWin->roi.y+frameBufferWin->roi.height-1;
// Start at the base of the buffer
// add the number of pixels corresponding to the start line
// add the number of pixel corresponding to the startx
UINT16* curBuf = frameBufferWin->fb.buffer
+(frameBufferWin->roi.y*frameBufferWin->fb.width)
+(frameBufferWin->roi.x);
for (curLine=startLine; curLine<=endLine; curLine++)
{
// transfer one line
if (curLine == endLine)
{
lcdd_TransferData(curBuf, frameBufferWin->roi.width, TRUE);hal_HstSendEvent(0x88855521);
}
else
{
lcdd_TransferData(curBuf, frameBufferWin->roi.width, FALSE);
}
// goto next line
curBuf+=frameBufferWin->fb.width;
}
}
UINT32 now2 = hal_TimGetUpTime();
SXS_TRACE(TSTDOUT, "lcd speed on frame %d ms ",(now2-now)*1000/16384);
return LCDD_ERR_NO;
}
// ============================================================================
// lcddp_BlitRoi2Win
// ----------------------------------------------------------------------------
// Private function to transfer data to the LCD
// ============================================================================
PRIVATE VOID lcddp_BlitRoi2Win(CONST HAL_GOUDA_WINDOW_T* pRoi, CONST HAL_GOUDA_WINDOW_T* pActiveWin, UINT16 bgColor)
{
hal_HstSendEvent(0x88855509);
HAL_GOUDA_LCD_CMD_T cmd[13];
UINT32 j = 0,k =0;
if(!((pRoi->tlPX < pRoi->brPX) && (pRoi->tlPY < pRoi->brPY)))
{
LCDD_TRACE(LCDD_WARN_TRC,0,"lcddp_BlitRoi2Win: Invalid Roi x:%d < %d, y:%d < %d",pRoi->tlPX, pRoi->brPX, pRoi->tlPY, pRoi->brPY);
lcddp_GoudaBlitHandler();
return;
}
// building set roi sequence:
#if 1
if(g_lcddRotate)
{
//Window Horizontal RAM Address Start
LCDD_BUILD_CMD_WR_REG(cmd,0,0x0050,pActiveWin->tlPY);
//Window Horizontal RAM Address End
LCDD_BUILD_CMD_WR_REG(cmd,2,0x0051,pActiveWin->brPY);
//Window Vertical RAM Address Start
LCDD_BUILD_CMD_WR_REG(cmd,4,0x0052,LCDD_DISP_Y-1-pActiveWin->brPX);
//Window Vertical RAM Address End
LCDD_BUILD_CMD_WR_REG(cmd,6,0x0053,LCDD_DISP_Y-1-pActiveWin->tlPX);
//Start point
LCDD_BUILD_CMD_WR_REG(cmd,8,0x0020,pActiveWin->tlPY);
LCDD_BUILD_CMD_WR_REG(cmd,10,0x0021,LCDD_DISP_Y-1-pActiveWin->tlPX);
}
else
{ hal_HstSendEvent(0x88855510);
//Window Horizontal RAM Address Start
// LCDD_BUILD_CMD_WR_REG(cmd,0,0x0050,pActiveWin->tlPX);
WriteCommand_Addr(0x2a);WriteCommand_Data(0x00);WriteCommand_Data(pActiveWin->tlPX);
WriteCommand_Data(0x00);WriteCommand_Data(pActiveWin->brPX);
//Window Horizontal RAM Address End
// LCDD_BUILD_CMD_WR_REG(cmd,2,0x0051,pActiveWin->brPX);
//Window Vertical RAM Address Start
// LCDD_BUILD_CMD_WR_REG(cmd,4,0x0052,pActiveWin->tlPY);
//Window Vertical RAM Address End
// LCDD_BUILD_CMD_WR_REG(cmd,6,0x0053,pActiveWin->brPY);
WriteCommand_Addr(0x2b);WriteCommand_Data(0x00);WriteCommand_Data(pActiveWin->tlPY);
WriteCommand_Data(0x00);WriteCommand_Data(pActiveWin->brPY);
//Start point
// LCDD_BUILD_CMD_WR_REG(cmd,8,0x0020,pActiveWin->tlPX);
// LCDD_BUILD_CMD_WR_REG(cmd,10,0x0021,pActiveWin->tlPY);
}
k = ((pActiveWin->brPX-pActiveWin->tlPX)+1)*(1+(pActiveWin->brPY-pActiveWin->tlPY));
hal_HstSendEvent(0x88855511);
hal_HstSendEvent(k);
// Send command after which the data we sent
// are recognized as pixels.
WriteCommand_Addr(0x2c);
hal_GpioSet(g_slcd_a0);
// g_image[0]=0xf8 ;
// g_image[1]= 0x00;
g_image[0]=(UINT8)((bgColor&0xff00)>>8);g_image[1]=(UINT8)(bgColor&0x00ff);
for( j =0; j<k; j++ )
{
Write_Data_Image; // red
}
lcdd_MutexFree();
#else
LCM_WR_REG(0x0050,pActiveWin->tlPX);//Window Horizontal RAM Address Start
LCM_WR_REG(0x0051,pActiveWin->brPX);//Window Horizontal RAM Address End
LCM_WR_REG(0x0052,pActiveWin->tlPY);//Window Vertical RAM Address Start
LCM_WR_REG(0x0053,pActiveWin->brPY);//Window Vertical RAM Address End
LCM_WR_REG(0x0020,pActiveWin->tlPX);
LCM_WR_REG(0x0021,pActiveWin->tlPY);
LCDD_BUILD_CMD_WR_CMD(cmd,0,0x0022);
while(HAL_ERR_NO != hal_GoudaBlitRoi(pRoi, 1, cmd, lcddp_GoudaBlitHandler));
#endif
}
