// =============================================================================
// 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);
}
}
}
}
// =============================================================================
// fmd_Close
// -----------------------------------------------------------------------------
/// This function closes the FM driver and desactivate the FM chip
/// and stops any pending #fmd_Tune or #fmd_Seek operation.
/// @return \c FMD_ERR_NO, or \c FMD_ERR_RESOURCE_BUSY
// =============================================================================
PUBLIC FMD_ERR_T fmd_Close(VOID)
{
//set mute,close adac
// fmd_Write(0x10,0xc500);
//set pdn low
RDA5888FM_Exit();
hal_GpioClr(g_fmdConfig->pinPdn);
#ifdef RDA5888_FM_26MCRYSTAL_ENABLE
//if ( 0==rdabt_getCurrentState() )
{
hal_SysAuxClkOut(FALSE);
}
#endif
//close 32k here
#ifdef RDA5888_32KFMMODE_ENALBE
{
RDA_Close32KOnClip();
}
#endif
#ifdef I2C_BASED_ON_GPIO
gpio_i2c_close();
#else
//xiaoyifeng for atv
hal_I2cClose(g_atvdI2cBusId);
#endif
g_band = FMD_BAND_QTY; // close marker
return FMD_ERR_NO;
}
void rda_bt_poweroff_for_test(void)
{
pmd_EnablePower(PMD_POWER_BT, FALSE);
hal_GpioClr(g_btdConfig->pinReset);
rdabt_uart_stop();
#ifdef __RDA_SHARE_CRYSTAL__
L1SM_SleepEnable(bt_sleephdl);
#endif
}
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++;
}
}
}
}
PRIVATE UINT16 lcddp_Open_Read_LcdId(VOID)
{
// return 1;
UINT32 count;
// UINT8 data[6] = {0x0,0x0,0x0,0x0,0x0,0x0};
// UINT8 iTempData[6] = {0x9, 0xff,0xff,0xff,0xff,0xff};
UINT8 data[3] = {0x0,0x0,0x0};
UINT8 iTempData[3] = {0xdb,0xff, 0xff};
// UINT8 dummy = 0;
HAL_SPI_CFG_T slcd_spiCfg =
{
.enabledCS = HAL_SPI_CS0,
.csActiveLow = TRUE,
.inputEn = TRUE,
.clkFallEdge = TRUE,
.clkDelay = HAL_SPI_HALF_CLK_PERIOD_0,
.doDelay = HAL_SPI_HALF_CLK_PERIOD_0,
.diDelay = HAL_SPI_HALF_CLK_PERIOD_1,
.csDelay = HAL_SPI_HALF_CLK_PERIOD_1,
.csPulse = HAL_SPI_HALF_CLK_PERIOD_0,//HAL_SPI_HALF_CLK_PERIOD_1
.frameSize = 8,
.oeRatio = 8,
.spiFreq = 1000000,//5M 5000000
.rxTrigger = HAL_SPI_RX_TRIGGER_4_BYTE,
.txTrigger = HAL_SPI_TX_TRIGGER_1_EMPTY,
.rxMode = HAL_SPI_DIRECT_POLLING,
.txMode = HAL_SPI_DIRECT_POLLING,
.mask = {0,0,0,0,0},
.handler = NULL
};
hal_SpiOpen(HAL_SPI,HAL_SPI_CS0, &slcd_spiCfg);
hal_SpiActivateCs(HAL_SPI,HAL_SPI_CS0);
hal_GpioClr(g_slcd_a0);
// hal_SpiSendData(HAL_SPI,HAL_SPI_CS0,&dummy,1);
//wait until any previous transfers have ended
// while(!hal_SpiTxFinished(HAL_SPI,HAL_SPI_CS0));hal_GpioSet(g_slcd_a0);
hal_SpiSendData(HAL_SPI,HAL_SPI_CS0,iTempData,3);
//wait until any previous transfers have ended
while(!hal_SpiTxFinished(HAL_SPI,HAL_SPI_CS0));//hal_GpioSet(g_slcd_a0);
count = hal_SpiGetData(HAL_SPI,HAL_SPI_CS0,data, 3);
hal_SpiDeActivateCs(HAL_SPI,HAL_SPI_CS0);
hal_SpiClose(HAL_SPI,HAL_SPI_CS0);
SXS_TRACE(TSTDOUT, "hx8535d: lcd read id is 0x%x 0x%x 0x%x ,count=%d",data[0],data[1],data[2],count);
return (UINT16)data[1];
}
PRIVATE VOID lcddp_Open_Spi(VOID)
{
HAL_SPI_CFG_T slcd_spiCfg =
{
.enabledCS = HAL_SPI_CS0,
.csActiveLow = TRUE,
.inputEn = TRUE,
.clkFallEdge = TRUE,
.clkDelay = HAL_SPI_HALF_CLK_PERIOD_0,
.doDelay = HAL_SPI_HALF_CLK_PERIOD_0,
.diDelay = HAL_SPI_HALF_CLK_PERIOD_1,
.csDelay = HAL_SPI_HALF_CLK_PERIOD_1,
.csPulse = HAL_SPI_HALF_CLK_PERIOD_0,//HAL_SPI_HALF_CLK_PERIOD_1
.frameSize = 8,
.oeRatio = 0,
.spiFreq = 20000000,//5M 5000000 15M 20M(33ms-per-frame) 39M(13ms-per-frame)
.rxTrigger = HAL_SPI_RX_TRIGGER_4_BYTE,
.txTrigger = HAL_SPI_TX_TRIGGER_1_EMPTY,
.rxMode = HAL_SPI_DIRECT_POLLING,
.txMode = HAL_SPI_DMA_POLLING,
.mask = {0,0,0,0,0},
.handler = NULL
};
hal_SpiOpen(HAL_SPI,HAL_SPI_CS0, &slcd_spiCfg);
}
// ============================================================================
// lcddp_Open
// ----------------------------------------------------------------------------
/// Open the LCDD driver.
/// It must be called before any call to any other function of this driver.
/// This function is to be called only once.
/// @return #LCDD_ERR_NO or #LCDD_ERR_DEVICE_NOT_FOUND.
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_Open(VOID)
{
hal_HstSendEvent(0x88855503);
//hal_GoudaOpen(&g_tgtLcddCfg.config, g_tgtLcddCfg.timings, 0);
hal_GpioSetOut(g_slcd_a0.gpioId);
lcddp_Open_Spi();
lcddp_Init();
hal_TimDelay(1 MS_WAITING);
g_lcddInSleep = FALSE;
return LCDD_ERR_NO;
}
// ============================================================================
// lcddp_Close
// ----------------------------------------------------------------------------
/// Close the LCDD driver
/// No other functions of this driver should be called after a call to
/// #lcddp_Close.
/// @return #LCDD_ERR_NO or #LCDD_ERR_DEVICE_NOT_FOUND.
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_Close(VOID)
{
// hal_GoudaClose();
lcddp_SpiDeActivateCs();
return LCDD_ERR_NO;
}
// ============================================================================
// lcddp_SetContrast
// ----------------------------------------------------------------------------
/// Set the contrast of the 'main'LCD screen.
/// @param contrast Value to set the contrast to.
/// @return #LCDD_ERR_NO, #LCDD_ERR_NOT_OPENED or
/// #LCDD_ERR_INVALID_PARAMETER.
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_SetContrast(UINT32 contrast)
{
//#warning This function is not implemented yet
return LCDD_ERR_NO;
}
// ============================================================================
// lcddp_SetStandbyMode
// ----------------------------------------------------------------------------
/// Set the main LCD in standby mode or exit from it
/// @param standbyMode If \c TRUE, go in standby mode.
/// If \c FALSE, cancel standby mode.
/// @return #LCDD_ERR_NO, #LCDD_ERR_NOT_OPENED or
/// #LCDD_ERR_INVALID_PARAMETER.
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_SetStandbyMode(BOOL standbyMode)
{
if (standbyMode)
{
lcddp_Sleep();
}
else
{
lcddp_WakeUp();
}
return LCDD_ERR_NO;
}
// ============================================================================
// lcddp_Sleep
// ----------------------------------------------------------------------------
/// Set the main LCD screen in sleep mode.
/// @return #LCDD_ERR_NO or #LCDD_ERR_NOT_OPENED
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_Sleep(VOID)
{
while (0 == lcdd_MutexGet())
{
sxr_Sleep(LCDD_TIME_MUTEX_RETRY);
LCDD_TRACE(TSTDOUT, 0, "LCDD: Sleep while another LCD operation in progress. Sleep %d ticks",
LCDD_TIME_MUTEX_RETRY);
}
if (g_lcddInSleep)
{
lcdd_MutexFree();
return LCDD_ERR_NO;
}
WriteCommand_Addr(0x10); //Set Sleep In
sxr_Sleep(10 MS_WAITING);
LCDD_TRACE(TSTDOUT, 0, "lcddp_Sleep: calling hal_GoudaClose");
g_lcddInSleep = TRUE;
hal_SpiDeActivateCs(HAL_SPI,HAL_SPI_CS0);
lcdd_MutexFree();
return LCDD_ERR_NO;
}
// ============================================================================
// lcddp_PartialOn
// ----------------------------------------------------------------------------
/// Set the Partial mode of the LCD
/// @param vsa : Vertical Start Active
/// @param vea : Vertical End Active
/// @return #LCDD_ERR_NO, #LCDD_ERR_NOT_OPENED
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_PartialOn(UINT16 vsa, UINT16 vea)
{
return LCDD_ERR_NO;
}
// ============================================================================
// lcddp_PartialOff
// ----------------------------------------------------------------------------
/// return to Normal Mode
/// @return #LCDD_ERR_NO, #LCDD_ERR_NOT_OPENED
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_PartialOff(VOID)
{
return LCDD_ERR_NO;
}
// ============================================================================
// lcddp_WakeUp
// ----------------------------------------------------------------------------
/// Wake the main LCD screen out of sleep mode
/// @return #LCDD_ERR_NO, #LCDD_ERR_NOT_OPENED
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_WakeUp(VOID)
{
if (0 == lcdd_MutexGet())
{
sxr_Sleep(LCDD_TIME_MUTEX_RETRY);
LCDD_TRACE(TSTDOUT, 0, "LCDD: Wakeup while another LCD operation in progress. Sleep %d ticks",
LCDD_TIME_MUTEX_RETRY);
}
if (!g_lcddInSleep)
{
lcdd_MutexFree();
return LCDD_ERR_NO;
}
LCDD_TRACE(TSTDOUT, 0, "lcddp_WakeUp: calling hal_GoudaOpen");
// hal_GoudaOpen(&g_tgtLcddCfg.config, g_tgtLcddCfg.timings, 0);
#if 0
lcddp_SpiActivateCs();
WriteCommand_Addr(0x11); //Set Sleep Out
sxr_Sleep(120 MS_WAITING);
#else
lcddp_Init();
#endif
g_lcddInSleep = FALSE;
lcdd_MutexFree();
// Set a comfortable background color to avoid screen flash
LCDD_FBW_T frameBufferWin;
frameBufferWin.fb.buffer = NULL;
frameBufferWin.fb.colorFormat = LCDD_COLOR_FORMAT_RGB_565;
frameBufferWin.roi.x=0;
frameBufferWin.roi.y=0;
if (g_lcddRotate)
{
frameBufferWin.roi.width = LCDD_DISP_Y;
frameBufferWin.roi.height = LCDD_DISP_X;
frameBufferWin.fb.width = LCDD_DISP_Y;
frameBufferWin.fb.height = LCDD_DISP_X;
}
else
{
frameBufferWin.roi.width = LCDD_DISP_X;
frameBufferWin.roi.height = LCDD_DISP_Y;
frameBufferWin.fb.width = LCDD_DISP_X;
frameBufferWin.fb.height = LCDD_DISP_Y;
}
lcddp_Blit16(&frameBufferWin,frameBufferWin.roi.x,frameBufferWin.roi.y);
return LCDD_ERR_NO;
}
// ============================================================================
// lcddp_GetScreenInfo
// ----------------------------------------------------------------------------
/// Get information about the main LCD device.
/// @param screenInfo Pointer to the structure where the information
/// obtained will be stored
/// @return #LCDD_ERR_NO, #LCDD_ERR_NOT_OPENED or
/// #LCDD_ERR_INVALID_PARAMETER.
// ============================================================================
PRIVATE LCDD_ERR_T lcddp_GetScreenInfo(LCDD_SCREEN_INFO_T* screenInfo)
{
{
screenInfo->width = LCDD_DISP_X;
screenInfo->height = LCDD_DISP_Y;
screenInfo->bitdepth = LCDD_COLOR_FORMAT_RGB_565;
screenInfo->nReserved = 0;
return LCDD_ERR_NO;
}
}
