static int sensor_flash_usr_cb (struct rk29camera_gpio_res *res,int on)
{
if(sensor_init_flags == 0){
rk30_mux_api_set(CONFIG_SENSOR_FALSH_MODE_MUX_0, 0);
int ret = gpio_request(CONFIG_SENSOR_FALSH_MODE_PIN_0, "camera_flash_mode");
if (ret != 0) {
printk(">>>>gpio request camera_flash_mode faile !!\n");
}
gpio_direction_output(CONFIG_SENSOR_FALSH_MODE_PIN_0, 0);
sensor_init_flags = 1 ;
}
#if defined (CONFIG_LEDS_LM3642) || defined(CONFIG_LEDS_LM2759)
return leds_flash_torch(on);
#else
switch (on) {
case Flash_Off: {
gpio_set_value(CONFIG_SENSOR_FALSH_EN_PIN_0, 0);
gpio_set_value(CONFIG_SENSOR_FALSH_MODE_PIN_0, 0);
break;
}
case Flash_On: {
gpio_set_value(CONFIG_SENSOR_FALSH_EN_PIN_0, 1);
gpio_set_value(CONFIG_SENSOR_FALSH_MODE_PIN_0, 1);
break;
}
case Flash_Torch: {
gpio_set_value(CONFIG_SENSOR_FALSH_EN_PIN_0, 1);
gpio_set_value(CONFIG_SENSOR_FALSH_MODE_PIN_0, 0);
break;
}
default: {
printk("%s..Flash command(%d) is invalidate \n",__FUNCTION__, on);
gpio_set_value(CONFIG_SENSOR_FALSH_EN_PIN_0, 0);
break;
}
}
return 0;
#endif
}
static int rk_fb_io_init(struct rk29_fb_setting_info *fb_setting)
{
int ret = 0;
rk30_mux_api_set(LCD_MUX_NAME, LCD_GPIO_MODE);
ret = gpio_request(LCD_EN, NULL);
if (ret != 0)
{
gpio_free(LCD_EN);
printk(KERN_ERR "request lcd en pin fail!\n");
return -1;
}
else
{
gpio_direction_output(LCD_EN, LCD_EN_VALUE); //disable
}
return 0;
}
static int rk29_backlight_io_deinit(void)
{
int ret = 0;
#ifdef LCD_DISP_ON_PIN
gpio_set_value(BL_EN_PIN, !BL_EN_VALUE);
gpio_free(BL_EN_PIN);
#endif
rk30_mux_api_set(PWM_MUX_NAME, PWM_MUX_MODE_GPIO);
#if defined(V86_VERSION_1_0) || defined(V86_VERSION_1_1)
#if defined(CONFIG_MFD_TPS65910)
if(g_pmic_type == PMIC_TYPE_TPS65910)
{
gpio_direction_output(PWM_GPIO, GPIO_HIGH);
}
#endif
#endif
return ret;
}
void usb20otg_hw_init(void)
{
#ifndef CONFIG_USB20_HOST
// close USB 2.0 HOST phy and clock
unsigned int * otg_phy_con1 = (unsigned int*)(USBGRF_UOC1_CON5);
*otg_phy_con1 = 0x1D5 |(0x1ff<<16); // enter suspend.
#endif
// usb phy config init
*(unsigned int *)(USBGRF_UOC0_CON0) = 0xe7e7a350;
// other hardware init
#ifdef CONFIG_RK_CONFIG
otg_drv_init(0);
#else
#if defined(CONFIG_MACH_RK2926_V86)
#else
rk30_mux_api_set(GPIO3C1_OTG_DRVVBUS_NAME, GPIO3C_OTG_DRVVBUS);
#endif
#endif
}
static int rk610_power_on_init(void)
{
int ret;
if(RK610_RST_PIN != INVALID_GPIO)
{
rk30_mux_api_set(RK610_RST_PIN_MUX_NAME,RK610_RST_PIN_MUX_MODE);
ret = gpio_request(RK610_RST_PIN, "rk610 reset");
if (ret)
{
printk(KERN_ERR "rk610_control_probe request gpio fail\n");
}
else
{
gpio_direction_output(RK610_RST_PIN, GPIO_HIGH);
msleep(100);
gpio_direction_output(RK610_RST_PIN, GPIO_LOW);
msleep(100);
gpio_set_value(RK610_RST_PIN, GPIO_HIGH);
}
}
return 0;
}
static int rk29_sdmmc1_cfg_gpio(void)
{
#if defined(CONFIG_SDMMC_RK29_OLD)
rk30_mux_api_set(GPIO3C0_SMMC1CMD_NAME, GPIO3C_SMMC1_CMD);
rk30_mux_api_set(GPIO3C5_SDMMC1CLKOUT_NAME, GPIO3C_SDMMC1_CLKOUT);
rk30_mux_api_set(GPIO3C1_SDMMC1DATA0_NAME, GPIO3C_SDMMC1_DATA0);
rk30_mux_api_set(GPIO3C2_SDMMC1DATA1_NAME, GPIO3C_SDMMC1_DATA1);
rk30_mux_api_set(GPIO3C3_SDMMC1DATA2_NAME, GPIO3C_SDMMC1_DATA2);
rk30_mux_api_set(GPIO3C4_SDMMC1DATA3_NAME, GPIO3C_SDMMC1_DATA3);
//rk30_mux_api_set(GPIO3C6_SDMMC1DETECTN_NAME, GPIO3C_SDMMC1_DETECT_N);
#else
#if defined(CONFIG_SDMMC1_RK29_WRITE_PROTECT)
gpio_request(SDMMC1_WRITE_PROTECT_PIN, "sdio-wp");
gpio_direction_input(SDMMC1_WRITE_PROTECT_PIN);
#endif
#endif
return 0;
}
//static void rk29_sdmmc_gpio_open(int device_id, int on)
void rk29_sdmmc_gpio_open(int device_id, int on)
{
switch(device_id)
{
case 0://mmc0
{
#ifdef CONFIG_SDMMC0_RK29
if(on)
{
gpio_direction_output(rksdmmc0_gpio_init.clk_gpio.io, GPIO_HIGH);//set mmc0-clk to high
gpio_direction_output(rksdmmc0_gpio_init.cmd_gpio.io, GPIO_HIGH);// set mmc0-cmd to high.
gpio_direction_output(rksdmmc0_gpio_init.data0_gpio.io,GPIO_HIGH);//set mmc0-data0 to high.
gpio_direction_output(rksdmmc0_gpio_init.data1_gpio.io,GPIO_HIGH);//set mmc0-data1 to high.
gpio_direction_output(rksdmmc0_gpio_init.data2_gpio.io,GPIO_HIGH);//set mmc0-data2 to high.
gpio_direction_output(rksdmmc0_gpio_init.data3_gpio.io,GPIO_HIGH);//set mmc0-data3 to high.
mdelay(30);
}
else
{
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.clk_gpio.iomux.name, rksdmmc0_gpio_init.clk_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.clk_gpio.io, "mmc0-clk");
gpio_direction_output(rksdmmc0_gpio_init.clk_gpio.io,GPIO_LOW);//set mmc0-clk to low.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.cmd_gpio.iomux.name, rksdmmc0_gpio_init.cmd_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.cmd_gpio.io, "mmc0-cmd");
gpio_direction_output(rksdmmc0_gpio_init.cmd_gpio.io,GPIO_LOW);//set mmc0-cmd to low.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.data0_gpio.iomux.name, rksdmmc0_gpio_init.data0_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.data0_gpio.io, "mmc0-data0");
gpio_direction_output(rksdmmc0_gpio_init.data0_gpio.io,GPIO_LOW);//set mmc0-data0 to low.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.data1_gpio.iomux.name, rksdmmc0_gpio_init.data1_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.data1_gpio.io, "mmc0-data1");
gpio_direction_output(rksdmmc0_gpio_init.data1_gpio.io,GPIO_LOW);//set mmc0-data1 to low.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.data2_gpio.iomux.name, rksdmmc0_gpio_init.data2_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.data2_gpio.io, "mmc0-data2");
gpio_direction_output(rksdmmc0_gpio_init.data2_gpio.io,GPIO_LOW);//set mmc0-data2 to low.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.data3_gpio.iomux.name, rksdmmc0_gpio_init.data3_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.data3_gpio.io, "mmc0-data3");
gpio_direction_output(rksdmmc0_gpio_init.data3_gpio.io,GPIO_LOW);//set mmc0-data3 to low.
mdelay(30);
}
#endif
}
break;
case 1://mmc1
{
#ifdef CONFIG_SDMMC1_RK29
if(on)
{
gpio_direction_output(rksdmmc1_gpio_init.clk_gpio.io,GPIO_HIGH);//set mmc1-clk to high
gpio_direction_output(rksdmmc1_gpio_init.cmd_gpio.io,GPIO_HIGH);//set mmc1-cmd to high.
gpio_direction_output(rksdmmc1_gpio_init.data0_gpio.io,GPIO_HIGH);//set mmc1-data0 to high.
gpio_direction_output(rksdmmc1_gpio_init.data1_gpio.io,GPIO_HIGH);//set mmc1-data1 to high.
gpio_direction_output(rksdmmc1_gpio_init.data2_gpio.io,GPIO_HIGH);//set mmc1-data2 to high.
gpio_direction_output(rksdmmc1_gpio_init.data3_gpio.io,GPIO_HIGH);//set mmc1-data3 to high.
mdelay(100);
}
else
{
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc1_gpio_init.clk_gpio.iomux.name, rksdmmc1_gpio_init.clk_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc1_gpio_init.clk_gpio.io, "mmc1-clk");
gpio_direction_output(rksdmmc1_gpio_init.clk_gpio.io,GPIO_LOW);//set mmc1-clk to low.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc1_gpio_init.cmd_gpio.iomux.name, rksdmmc1_gpio_init.cmd_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc1_gpio_init.cmd_gpio.io, "mmc1-cmd");
gpio_direction_output(rksdmmc1_gpio_init.cmd_gpio.io,GPIO_LOW);//set mmc1-cmd to low.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc1_gpio_init.data0_gpio.iomux.name, rksdmmc1_gpio_init.data0_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc1_gpio_init.data0_gpio.io, "mmc1-data0");
gpio_direction_output(rksdmmc1_gpio_init.data0_gpio.io,GPIO_LOW);//set mmc1-data0 to low.
#if defined(CONFIG_WIFI_COMBO_MODULE_CONTROL_FUNC) || defined(CONFIG_MT5931) || defined(CONFIG_MT5931_MT6622)
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk29_mux_api_set(rksdmmc1_gpio_init.data1_gpio.iomux.name, rksdmmc1_gpio_init.data1_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc1_gpio_init.data1_gpio.io, "mmc1-data1");
gpio_direction_output(rksdmmc1_gpio_init.data1_gpio.io,GPIO_LOW);//set mmc1-data1 to low.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk29_mux_api_set(rksdmmc1_gpio_init.data2_gpio.iomux.name, rksdmmc1_gpio_init.data2_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc1_gpio_init.data2_gpio.io, "mmc1-data2");
gpio_direction_output(rksdmmc1_gpio_init.data2_gpio.io,GPIO_LOW);//set mmc1-data2 to low.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk29_mux_api_set(rksdmmc1_gpio_init.data3_gpio.iomux.name, rksdmmc1_gpio_init.data3_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc1_gpio_init.data3_gpio.io, "mmc1-data3");
gpio_direction_output(rksdmmc1_gpio_init.data3_gpio.io,GPIO_LOW);//set mmc1-data3 to low.
#endif
mdelay(100);
}
#endif
}
break;
case 2: //mmc2
break;
default:
break;
}
}
static int __init rk3066b_iomux_init(void)
{
#if defined(CONFIG_UART0_RK29) || (CONFIG_RK_DEBUG_UART == 0)
rk30_mux_api_set(GPIO1A1_UART0SOUT_NAME, GPIO1A_UART0SOUT);
rk30_mux_api_set(GPIO1A0_UART0SIN_NAME, GPIO1A_UART0SIN);
#ifdef CONFIG_UART0_CTS_RTS_RK29
rk30_mux_api_set(GPIO1A3_UART0RTSN_NAME, GPIO1A_UART0RTSN);
rk30_mux_api_set(GPIO1A2_UART0CTSN_NAME, GPIO1A_UART0CTSN);
#endif
#endif
#if defined(CONFIG_UART1_RK29) || (CONFIG_RK_DEBUG_UART == 1)
//UART1 OR SPIM0
rk30_mux_api_set(GPIO1A5_UART1SOUT_SPI0TXD_NAME, GPIO1A_UART1SOUT);
rk30_mux_api_set(GPIO1A4_UART1SIN_SPI0RXD_NAME, GPIO1A_UART1SIN);
#ifdef CONFIG_UART1_CTS_RTS_RK29
rk30_mux_api_set(GPIO1A7_UART1RTSN_SPI0CSN0_NAME, GPIO1A_UART1RTSN);
rk30_mux_api_set(GPIO1A6_UART1CTSN_SPI0CLK_NAME, GPIO1A_UART1CTSN);
#endif
#endif
#if defined(CONFIG_UART2_RK29) || (CONFIG_RK_DEBUG_UART == 2)
rk30_mux_api_set(GPIO1B1_UART2SOUT_JTAGTDO_NAME, GPIO1B_UART2SOUT);
rk30_mux_api_set(GPIO1B0_UART2SIN_JTAGTDI_NAME, GPIO1B_UART2SIN);
#endif
#if defined(CONFIG_UART3_RK29) || (CONFIG_RK_DEBUG_UART == 3)
rk30_mux_api_set(GPIO1B3_UART3SOUT_GPSSIG_NAME, GPIO1B_UART3SOUT);
rk30_mux_api_set(GPIO1B2_UART3SIN_GPSMAG_NAME, GPIO1B_UART3SIN);
#ifdef CONFIG_UART3_CTS_RTS_RK29
rk30_mux_api_set(GPIO1B5_UART3RTSN_NAME, GPIO1B_UART3RTSN);
rk30_mux_api_set(GPIO1B4_UART3CTSN_GPSRFCLK_NAME, GPIO1B_UART3CTSN);
#endif
#endif
#ifdef CONFIG_SPIM0_RK29
//UART1 OR SPIM0
rk30_mux_api_set(GPIO1A6_UART1CTSN_SPI0CLK_NAME, GPIO1A_SPI0CLK);
rk30_mux_api_set(GPIO1A7_UART1RTSN_SPI0CSN0_NAME, GPIO1A_SPI0CSN0);
rk30_mux_api_set(GPIO1A5_UART1SOUT_SPI0TXD_NAME, GPIO1A_SPI0TXD);
rk30_mux_api_set(GPIO1A4_UART1SIN_SPI0RXD_NAME, GPIO1A_SPI0RXD);
#endif
#ifdef CONFIG_SPIM1_RK29
//rk30_mux_api_set(GPIO1B6_SPDIFTX_SPI1CSN1_NAME, GPIO1B_SPI1CSN1);
rk30_mux_api_set(GPIO0D4_SPI1RXD_NAME, GPIO0D_SPI1RXD);
rk30_mux_api_set(GPIO0D5_SPI1TXD_NAME, GPIO0D_SPI1TXD);
rk30_mux_api_set(GPIO0D7_SPI1CSN0_NAME, GPIO0D_SPI1CSN0);
rk30_mux_api_set(GPIO0D6_SPI1CLK_NAME, GPIO0D_SPI1CLK);
#endif
#ifdef CONFIG_I2C0_RK30
rk30_mux_api_set(GPIO1D1_I2C0SCL_NAME, GPIO1D_I2C0SCL);
rk30_mux_api_set(GPIO1D0_I2C0SDA_NAME, GPIO1D_I2C0SDA);
#endif
#ifdef CONFIG_I2C1_RK30
rk30_mux_api_set(GPIO1D3_I2C1SCL_NAME, GPIO1D_I2C1SCL);
rk30_mux_api_set(GPIO1D2_I2C1SDA_NAME, GPIO1D_I2C1SDA);
#endif
#ifdef CONFIG_I2C2_RK30
rk30_mux_api_set(GPIO1D5_I2C2SCL_NAME, GPIO1D_I2C2SCL);
rk30_mux_api_set(GPIO1D4_I2C2SDA_NAME, GPIO1D_I2C2SDA);
#endif
#ifdef CONFIG_I2C3_RK30
rk30_mux_api_set(GPIO3B7_CIFDATA11_I2C3SCL_NAME, GPIO3B_I2C3SCL);
rk30_mux_api_set(GPIO3B6_CIFDATA10_I2C3SDA_NAME, GPIO3B_I2C3SDA);
#endif
#ifdef CONFIG_I2C4_RK30
rk30_mux_api_set(GPIO1D7_I2C4SCL_NAME, GPIO1D_I2C4SCL);
rk30_mux_api_set(GPIO1D6_I2C4SDA_NAME, GPIO1D_I2C4SDA);
#endif
#ifdef CONFIG_RK30_VMAC
rk30_mux_api_set(GPIO3C5_SDMMC1CLKOUT_RMIICLKOUT_RMIICLKIN_NAME, GPIO3C_RMIICLKOUT);
rk30_mux_api_set(GPIO3C0_SDMMC1CMD_RMIITXEN_NAME, GPIO3C_RMIITXEN);
rk30_mux_api_set(GPIO3C1_SDMMC1DATA0_RMIITXD1_NAME, GPIO3C_RMIITXD1);
rk30_mux_api_set(GPIO3C2_SDMMC1DATA1_RMIITXD0_NAME, GPIO3C_RMIITXD0);
rk30_mux_api_set(GPIO3C6_SDMMC1DETECTN_RMIIRXERR_NAME, GPIO3C_RMIIRXERR);
rk30_mux_api_set(GPIO3C7_SDMMC1WRITEPRT_RMIICRS_NAME, GPIO3C_RMIICRS);
rk30_mux_api_set(GPIO3C4_SDMMC1DATA3_RMIIRXD1_NAME, GPIO3C_RMIIRXD1);
rk30_mux_api_set(GPIO3C3_SDMMC1DATA2_RMIIRXD0_NAME, GPIO3C_RMIIRXD0);
rk30_mux_api_set(GPIO3D1_SDMMC1BACKENDPWR_MIIMDCLK_NAME, GPIO3D_MIIMDCLK);
rk30_mux_api_set(GPIO3D0_SDMMC1PWREN_MIIMD_NAME, GPIO3D_MIIMD);
#endif
return 0;
}
int ssd2828_gpio_init(void *data) {
int ret = 0;
struct reset_t *reset = &ssd2828->reset;
struct power_t *vdd = &ssd2828->vddio;
struct spi_t *spi = &ssd2828->spi;
if(reset->reset_pin > INVALID_GPIO) {
ret = gpio_request(reset->reset_pin, "ssd2828_reset");
if (ret != 0) {
//gpio_free(reset->reset_pin);
printk("%s: request ssd2828_RST_PIN error\n", __func__);
} else {
if(reset->mux_name)
rk30_mux_api_set(reset->mux_name, 0);
gpio_direction_output(reset->reset_pin, reset->effect_value);
}
}
if(vdd->enable_pin > INVALID_GPIO) {
ret = gpio_request(vdd->enable_pin, "ssd2828_vddio");
if (ret != 0) {
//gpio_free(vdd->enable_pin);
printk("%s: request ssd2828_vddio_PIN error\n", __func__);
} else {
if(vdd->mux_name)
rk30_mux_api_set(vdd->mux_name, 0);
gpio_direction_output(vdd->enable_pin, !vdd->effect_value);
}
}
vdd = &ssd2828->vdd_mipi;
if(vdd->enable_pin > INVALID_GPIO) {
ret = gpio_request(vdd->enable_pin, "ssd2828_vdd_mipi");
if (ret != 0) {
//gpio_free(vdd->enable_pin);
printk("%s: request ssd2828_vdd_mipi_PIN error\n", __func__);
} else {
if(vdd->mux_name)
rk30_mux_api_set(vdd->mux_name, 0);
gpio_direction_output(vdd->enable_pin, !vdd->effect_value);
}
}
if(spi->cs > INVALID_GPIO) {
ret = gpio_request(spi->cs, "ssd2828_spi_cs");
if (ret != 0) {
//gpio_free(spi->cs);
printk("%s: request ssd2828_spi->cs_PIN error\n", __func__);
} else {
if(spi->cs_mux_name)
rk30_mux_api_set(spi->cs_mux_name, 0);
gpio_direction_output(spi->cs, GPIO_HIGH);
}
}
if(spi->sck > INVALID_GPIO) {
ret = gpio_request(spi->sck, "ssd2828_spi_sck");
if (ret != 0) {
//gpio_free(spi->sck);
printk("%s: request ssd2828_spi->sck_PIN error\n", __func__);
} else {
if(spi->sck_mux_name)
rk30_mux_api_set(spi->sck_mux_name, 0);
gpio_direction_output(spi->sck, GPIO_HIGH);
}
}
if(spi->mosi > INVALID_GPIO) {
ret = gpio_request(spi->mosi, "ssd2828_spi_mosi");
if (ret != 0) {
//gpio_free(spi->mosi);
printk("%s: request ssd2828_spi->mosi_PIN error\n", __func__);
} else {
if(spi->mosi_mux_name)
rk30_mux_api_set(spi->mosi_mux_name, 0);
gpio_direction_output(spi->mosi, GPIO_HIGH);
}
}
if(spi->miso > INVALID_GPIO) {
ret = gpio_request(spi->miso, "ssd2828_spi_miso");
if (ret != 0) {
//gpio_free(spi->miso);
printk("%s: request ssd2828_spi->miso_PIN error\n", __func__);
} else {
if(spi->miso_mux_name)
rk30_mux_api_set(spi->miso_mux_name, 0);
gpio_direction_input(spi->miso);
}
}
return 0;
}
static int rk29sdk_wifi_combo_module_gpio_init(void)
{
#if defined(CONFIG_MTK_COMBO_MT66XX)
mtk_combo_init();
platform_device_register(&mtk_wmt_dev);
platform_device_register(&mtk_sdio_eint_dev);
#else
//VDDIO
#ifdef RK30SDK_WIFI_GPIO_VCCIO_WL
#ifdef RK30SDK_WIFI_GPIO_VCCIO_WL_PIN_NAME
rk30_mux_api_set(rk_platform_wifi_gpio.vddio.iomux.name, rk_platform_wifi_gpio.vddio.iomux.fgpio);
#endif
gpio_request(rk_platform_wifi_gpio.vddio.io, "combo-VDDIO");
gpio_direction_output(rk_platform_wifi_gpio.vddio.io, !(rk_platform_wifi_gpio.power_n.enable));
#endif
//BGF_INT_B
#ifdef RK30SDK_WIFI_GPIO_BGF_INT_B_PIN_NAME
rk30_mux_api_set(rk_platform_wifi_gpio.bgf_int_b.iomux.name, rk_platform_wifi_gpio.bgf_int_b.iomux.fgpio);
#endif
gpio_request(rk_platform_wifi_gpio.bgf_int_b.io, "combo-BGFINT");
gpio_pull_updown(rk_platform_wifi_gpio.bgf_int_b.io, GPIOPullUp);
gpio_direction_input(rk_platform_wifi_gpio.bgf_int_b.io);
//WIFI_INT_B
#ifdef RK30SDK_WIFI_GPIO_WIFI_INT_B_PIN_NAME
rk30_mux_api_set(rk_platform_wifi_gpio.bgf_int_b.iomux.name, rk_platform_wifi_gpio.bgf_int_b.iomux.fgpio);
#endif
gpio_request(rk_platform_wifi_gpio.wifi_int_b.io, "combo-WIFIINT");
gpio_pull_updown(rk_platform_wifi_gpio.wifi_int_b.io, GPIOPullUp);
gpio_direction_input(rk_platform_wifi_gpio.wifi_int_b.io);
//reset
#ifdef RK30SDK_WIFI_GPIO_RESET_PIN_NAME
rk30_mux_api_set(rk_platform_wifi_gpio.reset_n.iomux.name, rk_platform_wifi_gpio.reset_n.iomux.fgpio);
#endif
gpio_request(rk_platform_wifi_gpio.reset_n.io, "combo-RST");
gpio_direction_output(rk_platform_wifi_gpio.reset_n.io, !(rk_platform_wifi_gpio.reset_n.enable));
//power
#ifdef RK30SDK_WIFI_GPIO_POWER_PIN_NAME
rk30_mux_api_set(rk_platform_wifi_gpio.power_n.iomux.name, rk_platform_wifi_gpio.power_n.iomux.fgpio);
#endif
gpio_request(rk_platform_wifi_gpio.power_n.io, "combo-PMUEN");
gpio_direction_output(rk_platform_wifi_gpio.power_n.io, !(rk_platform_wifi_gpio.power_n.enable));
#if defined(COMBO_MODULE_MT6620_CDT) && COMBO_MODULE_MT6620_CDT
//ANTSEL2
#ifdef RK30SDK_WIFI_GPIO_ANTSEL2
#ifdef RK30SDK_WIFI_GPIO_ANTSEL2_PIN_NAME
rk30_mux_api_set(rk_platform_wifi_gpio.ANTSEL2.iomux.name, rk_platform_wifi_gpio.ANTSEL2.iomux.fgpio);
#endif
gpio_request(rk_platform_wifi_gpio.ANTSEL2.io, "combo-ANTSEL2");
gpio_direction_output(rk_platform_wifi_gpio.ANTSEL2.io, rk_platform_wifi_gpio.ANTSEL2.enable);
#endif
//ANTSEL3
#ifdef RK30SDK_WIFI_GPIO_ANTSEL3
#ifdef RK30SDK_WIFI_GPIO_ANTSEL3_PIN_NAME
rk30_mux_api_set(rk_platform_wifi_gpio.ANTSEL3.iomux.name, rk_platform_wifi_gpio.ANTSEL3.iomux.fgpio);
#endif
gpio_request(rk_platform_wifi_gpio.ANTSEL3.io, "combo-ANTSEL3");
gpio_direction_output(rk_platform_wifi_gpio.ANTSEL3.io, !(rk_platform_wifi_gpio.ANTSEL3.enable));
#endif
//GPS_LAN
#ifdef RK30SDK_WIFI_GPIO_GPS_LAN
#ifdef RK30SDK_WIFI_GPIO_GPS_LAN_PIN_NAME
rk30_mux_api_set(rk_platform_wifi_gpio.GPS_LAN.iomux.name, rk_platform_wifi_gpio.GPS_LAN.iomux.fgpio);
#endif
gpio_request(rk_platform_wifi_gpio.GPS_LAN.io, "combo-GPSLAN");
gpio_direction_output(rk_platform_wifi_gpio.GPS_LAN.io, rk_platform_wifi_gpio.GPS_LAN.enable);
#endif
#endif//#if COMBO_MODULE_MT6620_CDT ---#endif
#endif
return 0;
}
static int __devinit rk29_spdif_probe (struct platform_device *pdev)
{
int ret = 0;
struct resource *res = NULL,*dma=NULL;
void __iomem *reg_vir_base;
struct rk29xx_spdif *dws = &rk29_spdif;
struct RK29_SPDIF_REG *reg = &spdif_reg;
struct clk *general_pll;
unsigned long spdif_mclk;
int irq;
int temp;
int i;
DBG("enter rk29_spdif_probe\n");
#if defined (CONFIG_ARCH_RK29)
rk29_mux_api_set(GPIO4A7_SPDIFTX_NAME, GPIO4L_SPDIF_TX);
#endif
#if defined (CONFIG_ARCH_RK30)
rk30_mux_api_set(GPIO1B2_SPDIFTX_NAME, GPIO1B_SPDIF_TX);
#endif
/* get spdif clk */
dws->spdif_clk= clk_get(&pdev->dev, "spdif");
if (IS_ERR(dws->spdif_clk)) {
err("failed to get spdif clk\n");
ret = PTR_ERR(dws->spdif_clk);
goto err0;
}
clk_enable(dws->spdif_clk);
clk_set_rate(dws->spdif_clk, 11289600);
#if defined (CONFIG_ARCH_RK30)
dws->spdif_hclk= clk_get(&pdev->dev, "hclk_spdif");
if (IS_ERR(dws->spdif_hclk)) {
err("failed to get spdif clk\n");
ret = PTR_ERR(dws->spdif_hclk);
goto err1;
}
clk_enable(dws->spdif_hclk);
clk_set_rate(dws->spdif_hclk, 11289600);
#endif
/* get virtual basic address of spdif register */
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "spdif_base");
if (res == NULL){
dev_err(&pdev->dev, "failed to get memory registers\n");
ret = -ENOENT;
goto err1;
}
if (!request_mem_region(res->start, resource_size(res),"rk29_spdif")) {
err("Unable to request register region\n");
return -EBUSY;
}
reg_vir_base = ioremap(res->start, res->end - res->start + 1);
if (!reg_vir_base){
release_mem_region(res->start, res->end - res->start + 1);
ret = -EBUSY;
goto err2;
}
reg->cfgr = reg_vir_base;
reg->sdblr = reg_vir_base + 0x4;
reg->dmacr = reg_vir_base + 0x8;
reg->intcr = reg_vir_base + 0xc;
reg->intsr = reg_vir_base + 0x10;
reg->xfer = reg_vir_base + 0x18;
reg->smpdr = reg_vir_base + 0x20;
reg->vldfr = reg_vir_base + 0x60;
reg->usrdr = reg_vir_base + 0x90;
reg->chnsr = reg_vir_base + 0xC0;
dma = platform_get_resource_byname(pdev, IORESOURCE_DMA, "spdif_dma");
if (dma == NULL){
err("rk29 spdif failed to get dma channel\n");
ret = -ENOENT;
goto err3;
}
dws->dma_ch = dma->start;
dws->dma_size = 4;
dws->client = &rk29_spdif_dma_client;
dws->dma_addr = res->start+0x20;
writel(SPDIF_TRANFER_DISABLE,reg->xfer);
writel(SPDIF_RESET,reg->cfgr);
mdelay(1);
temp = SPDIF_VALID_DATA_WIDTH_16BIT //valid data width, 0:16bit,1:20bit,2:24bit
|SPDIF_HALFWORD_TX_ENABLE //halfword word transform enable, 0:disable
|SPDIF_JUSTIFIED_RIGHT //apb valid audio data justified,0:right
|SPDIF_VALID_FLAG_DISABLE //valid flag enable
|SPDIF_USER_DATA_DISABLE //user data enable
|SPDIF_CHANNEL_STATUS_DISABLE //channel status enable
|SPDIF_NOT_RESET //write 1 to reset mclk domain logic
|(0x01<<16) //Fmclk/Fsdo
;
writel(temp,reg->cfgr);
temp = SPDIF_DMA_CTRL_DISABLE|0x10; //disable spdif dma
writel(temp, reg->dmacr);
writel(SPDIF_INT_CTRL_DISABLE, reg->intcr);//disable spdif int
#if 0
chnsr_byte1= (0x0)|(0x0<<1)|(0x0<<2)|(0x0<<3)|(0x00<<6);//consumer|pcm|copyright?|pre-emphasis|(0x00<<6);
chnsr_byte2= (0x0);//category code general mode??
chnsr_byte3= (0x0)|(0x0<<4)|(0x0<<6);//
chnsr_byte4= (48);//khz;clock acurracy
chnsr_byte5= (0x1)|(0x001<<1);//24 bit;
writel((chnsr_byte2<<24)|(chnsr_byte1<<16)|(chnsr_byte2<<8)|(chnsr_byte1),reg->chnsr);
writel((chnsr_byte4<<24)|(chnsr_byte3<<16)|(chnsr_byte4<<8)|(chnsr_byte3),reg->chnsr+4);
writel((chnsr_byte5<<16)|(chnsr_byte5),reg->chnsr+8);
writel(0,reg->chnsr+0xc);
writel(0,reg->chnsr+0x10);
writel(0,reg->chnsr+0x14);
writel(0,reg->chnsr+0x18);
writel(0,reg->chnsr+0x1C);
writel(0,reg->chnsr+0x20);
writel(0,reg->chnsr+0x24);
writel(0,reg->chnsr+0x28);
writel(0,reg->chnsr+0x2C);
#endif
writel(SPDIF_TRANFER_DISABLE,reg->xfer);// modify SPDIF_XFER to enable SPDIF
rk29_spdif_ctrl(0, 1);
DBG("rk29_spdif_probe ok!!\n");
return 0;
err3:
err2:
// clk_disable(dws->spdif_hclk);
err1:
clk_disable(dws->spdif_clk);
err0:
return ret;
}
int __init wisky_boot_charge_main(void)
{
#if 0 //for test ...Lee
printk("here... ...wulala... wisky_boot_charge_main\n");
wisky_charger_logo_display(LOGO_BLANK);
wisky_charger_logo_display(LOGO_BOOTUP);
return 0;
#endif
int charge_full_cnt = 0;
int full_display_times = 1;//充电满后提示次数
boot_charge_mode = 0;
if(1 == usb_otg_op_state){
//do not enter charge mode when USB OTG insert
return 0;
}
WPRINTK("--------dc_adaptor_status=%d\n", dc_adaptor_status);
//WPRINTK("--------battery_adc_value=%d\n", battery_adc_value);
pr_info("--------battery_capacity=%d\n", battery_capacity);
if(dc_adaptor_status == 0){
//no DC adaptor insert, do not display charge
//#if defined(WISKY_BATTERY_OZ8806)
//电量低于阀值时显示低电logo
if(battery_capacity < BATT_LEVEL_POOR){
//#else
//电量低于阀值时显示低电logo
//if((battery_adc_value < BAT_DISCHARGE_ADC_MIN) || (battery_adc_value -BATTERY_ADC_ADJUST < BAT_DISCHARGE_ADC_MIN)){
//#endif
//clear lcd before show charge logo
wisky_charger_logo_display(LOGO_BLANK);
msleep(100);
wisky_boot_charge_bl(1);
wisky_charger_logo_display(LOGO_POOR);
mdelay(1000);
wisky_boot_charge_bl(0);
mdelay(500);
pr_info("%s:low battery, shut down...\n", __FUNCTION__);
wisky_boot_charge_poweroff();
while(1);
}else{
wisky_charger_logo_display(LOGO_BLANK);
msleep(100);
//wisky_boot_charge_bl(1);
wisky_charger_logo_display(LOGO_BOOTUP);
return 0;
}
}
pr_info("------>Charge mode enter\n");
//clear lcd before show charge logo
wisky_charger_logo_display(LOGO_BLANK);
printk("wisky_charger_logo_display(LOGO_BLANK);\n");
msleep(100);//延时防止闪白屏
wisky_boot_charge_bl(1);
while(1){
if(battery_capacity == BATT_LEVEL_FULL){
dc_adaptor_check_and_poweroff();
wisky_charger_logo_display(LOGO_BLANK);
if(wisky_boot_charge_show_full_logo() == 1){
goto exit;
}
}else{
dc_adaptor_check_and_poweroff();
wisky_charger_logo_display(LOGO_BLANK);
if(wisky_boot_charge_show_logos(3, battery_capacity) == 1){
goto exit;
}
}
#if defined (CONFIG_AXP_PEKINFO)
if(axp_pwr_pressshort){
axp_pwr_pressshort = 0;
}
#endif
dc_adaptor_check_and_poweroff();
wisky_boot_charge_suspend();
while(1){
if(battery_capacity == BATT_LEVEL_FULL && full_display_times > 0){
if(charge_full_cnt++ > 10/*FULL_SHOW_LOGO_TIME*/){
charge_full_cnt = 0;
full_display_times--;
break;
}
}
dc_adaptor_check_and_poweroff();
if(power_key_check()){
break;
}
dc_adaptor_check_and_poweroff();
mdelay(10);
}
dc_adaptor_check_and_poweroff();
wisky_boot_charge_resume();
}
exit:
pr_info("------>Charge mode exit\n");
rk30_mux_api_set(LCD_BL_PWM_MUX_NAME, LCD_BL_PWM_MUX_MODE);
//lcd backlight off here, will be backlight on in backlihgt driver init
if(LCD_BL_EN_PIN != INVALID_GPIO){
gpio_set_value(LCD_BL_EN_PIN, !LCD_BL_EN_VALUE);
}
//
boot_charge_mode = 1;
wisky_charger_logo_display(LOGO_BLANK);
wisky_charger_logo_display(LOGO_BOOTUP);
gpio_request(KEY_SHUTDOWN_PIN, "poweronpin");
gpio_direction_output(KEY_SHUTDOWN_PIN, GPIO_HIGH);
gpio_set_value(KEY_SHUTDOWN_PIN, GPIO_HIGH);
return 0;
}
static int l3g4200d_init_platform_hw(void)
{
rk30_mux_api_set(GPIO4C3_SMCDATA3_TRACEDATA3_NAME, GPIO4C_GPIO4C3);
return 0;
}
static int rk30_rmii_power_control(int enable)
{
if (enable) {
//enable phy power
printk("power on phy\n");
rk30_mux_api_set(GPIO1D6_CIF1DATA11_NAME, GPIO1D_GPIO1D6);
rk30_mux_api_set(GPIO1D2_CIF1CLKIN_NAME, GPIO1D_GPIO1D2);
rk30_mux_api_set(GPIO1D1_CIF1HREF_MIIMDCLK_NAME, GPIO1D_MII_MDCLK);
rk30_mux_api_set(GPIO1D0_CIF1VSYNC_MIIMD_NAME, GPIO1D_MII_MD);
rk30_mux_api_set(GPIO1C7_CIFDATA9_RMIIRXD0_NAME, GPIO1C_RMII_RXD0);
rk30_mux_api_set(GPIO1C6_CIFDATA8_RMIIRXD1_NAME, GPIO1C_RMII_RXD1);
rk30_mux_api_set(GPIO1C5_CIFDATA7_RMIICRSDVALID_NAME, GPIO1C_RMII_CRS_DVALID);
rk30_mux_api_set(GPIO1C4_CIFDATA6_RMIIRXERR_NAME, GPIO1C_RMII_RX_ERR);
rk30_mux_api_set(GPIO1C3_CIFDATA5_RMIITXD0_NAME, GPIO1C_RMII_TXD0);
rk30_mux_api_set(GPIO1C2_CIF1DATA4_RMIITXD1_NAME, GPIO1C_RMII_TXD1);
rk30_mux_api_set(GPIO1C1_CIFDATA3_RMIITXEN_NAME, GPIO1C_RMII_TX_EN);
rk30_mux_api_set(GPIO1C0_CIF1DATA2_RMIICLKOUT_RMIICLKIN_NAME, GPIO1C_RMII_CLKOUT);
gpio_direction_output(PHY_PWR_EN_GPIO, GPIO_HIGH);
gpio_set_value(PHY_PWR_EN_GPIO, GPIO_HIGH);
}else {
gpio_direction_output(PHY_PWR_EN_GPIO, GPIO_LOW);
gpio_set_value(PHY_PWR_EN_GPIO, GPIO_LOW);
}
return 0;
}
static void rk29_sdmmc_set_iomux_mmc0(unsigned int bus_width)
{
switch (bus_width)
{
case 1://SDMMC_CTYPE_4BIT:
{
#if SDMMC_USE_NEW_IOMUX_API
iomux_set(rksdmmc0_gpio_init.data1_gpio.iomux.fmux);
iomux_set(rksdmmc0_gpio_init.data2_gpio.iomux.fmux);
iomux_set(rksdmmc0_gpio_init.data3_gpio.iomux.fmux);
#else
rk30_mux_api_set(rksdmmc0_gpio_init.data1_gpio.iomux.name, rksdmmc0_gpio_init.data1_gpio.iomux.fmux);
rk30_mux_api_set(rksdmmc0_gpio_init.data2_gpio.iomux.name, rksdmmc0_gpio_init.data2_gpio.iomux.fmux);
rk30_mux_api_set(rksdmmc0_gpio_init.data3_gpio.iomux.name, rksdmmc0_gpio_init.data3_gpio.iomux.fmux);
#endif
}
break;
case 0x10000://SDMMC_CTYPE_8BIT:
break;
case 0xFFFF: //gpio_reset
{
#if (!!SDMMC_USE_NEW_IOMUX_API) && !defined(CONFIG_SDMMC0_RK29_SDCARD_DET_FROM_GPIO)
iomux_set(MMC0_DETN);
#endif
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.power_en_gpio.iomux.name, rksdmmc0_gpio_init.power_en_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.power_en_gpio.io,"sdmmc-power");
gpio_direction_output(rksdmmc0_gpio_init.power_en_gpio.io, !(rksdmmc0_gpio_init.power_en_gpio.enable)); //power-off
#if 0 //replace the power control into rk29_sdmmc_set_ios(); modifyed by xbw at 2012-08-12
rk29_sdmmc_gpio_open(0, 0);
gpio_direction_output(rksdmmc0_gpio_init.power_en_gpio.io, rksdmmc0_gpio_init.power_en_gpio.enable); //power-on
rk29_sdmmc_gpio_open(0, 1);
#endif
}
break;
default: //case 0://SDMMC_CTYPE_1BIT:
{
#if SDMMC_USE_NEW_IOMUX_API
iomux_set(rksdmmc0_gpio_init.cmd_gpio.iomux.fmux);
iomux_set(rksdmmc0_gpio_init.clk_gpio.iomux.fmux);
iomux_set(rksdmmc0_gpio_init.data0_gpio.iomux.fmux);
#else
rk30_mux_api_set(rksdmmc0_gpio_init.cmd_gpio.iomux.name, rksdmmc0_gpio_init.cmd_gpio.iomux.fmux);
rk30_mux_api_set(rksdmmc0_gpio_init.clk_gpio.iomux.name, rksdmmc0_gpio_init.clk_gpio.iomux.fmux);
rk30_mux_api_set(rksdmmc0_gpio_init.data0_gpio.iomux.name, rksdmmc0_gpio_init.data0_gpio.iomux.fmux);
#endif
//IO voltage(vccio);
#ifdef RK31SDK_SET_SDMMC0_PIN_VOLTAGE
if(rk31sdk_get_sdmmc0_pin_io_voltage() > 2700)
SDMMC_write_grf_reg(GRF_IO_CON4, (SDMMC0_IO_VOLTAGE_MASK |SDMMC0_IO_VOLTAGE_33)); //set SDMMC0 pin to 3.3v
else
SDMMC_write_grf_reg(GRF_IO_CON4, (SDMMC0_IO_VOLTAGE_MASK |SDMMC0_IO_VOLTAGE_18));//set SDMMC0 pin to 1.8v
#else
//default set the voltage of SDMMC0 to 3.3V
SDMMC_write_grf_reg(GRF_IO_CON4, (SDMMC0_IO_VOLTAGE_MASK |SDMMC0_IO_VOLTAGE_33));
#endif
//sdmmc drive strength control
SDMMC_write_grf_reg(GRF_IO_CON2, (SDMMC0_DRIVER_STRENGTH_MASK |SDMMC0_DRIVER_STRENGTH_8MA));
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.data1_gpio.iomux.name, rksdmmc0_gpio_init.data1_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.data1_gpio.io, "mmc0-data1");
gpio_direction_output(rksdmmc0_gpio_init.data1_gpio.io,GPIO_HIGH);//set mmc0-data1 to high.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.data2_gpio.iomux.name, rksdmmc0_gpio_init.data2_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.data2_gpio.io, "mmc0-data2");
gpio_direction_output(rksdmmc0_gpio_init.data2_gpio.io,GPIO_HIGH);//set mmc0-data2 to high.
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk30_mux_api_set(rksdmmc0_gpio_init.data3_gpio.iomux.name, rksdmmc0_gpio_init.data3_gpio.iomux.fgpio);
#endif
gpio_request(rksdmmc0_gpio_init.data3_gpio.io, "mmc0-data3");
gpio_direction_output(rksdmmc0_gpio_init.data3_gpio.io,GPIO_HIGH);//set mmc0-data3 to high.
}
break;
}
}
static int __init gpio_nwd_init(void)
{
int retval,ret;
#ifdef CONFIG_CHARGE_TPS2546
init_nwd_tps2546();
#endif
///led
#if defined(CONFIG_HUALINGAN_YUANCHEPING)
ret = gpio_request(SOUND_ENABLE, "sound enable");
#endif
rk30_mux_api_set(GPIO4D3_SMCDATA11_TRACEDATA11_NAME, GPIO4D_GPIO4D3); ///RST
ret = gpio_request(RK30_PIN4_PD3, "led pin");
if (ret != 0) {
gpio_free(RK30_PIN4_PD3);
ret = gpio_request(RK30_PIN4_PD3, "led pin");
if (ret != 0) {
printk("led gpio_request error\n");
return -EIO;
}
}
gpio_direction_output(RK30_PIN4_PD3, 0);
gpio_set_value(RK30_PIN4_PD3, 0);
setup_timer( &led2_timer, led2_timer_callback, 0 );
mod_timer(&led2_timer, jiffies + msecs_to_jiffies(1000));
/*
* Create a simple kobject with the name of "kobject_example",
* located under /sys/kernel/
*
* As this is a simple directory, no uevent will be sent to
* userspace. That is why this function should not be used for
* any type of dynamic kobjects, where the name and number are
* not known ahead of time.
*/
gpio_kobj = kobject_create_and_add("tps2546_gpio", kernel_kobj);
if (!gpio_kobj)
return -ENOMEM;
/* Create the files associated with this kobject */
retval = sysfs_create_group(gpio_kobj, &attr_group);
if (retval)
kobject_put(gpio_kobj);
gpiotest_kobj = kobject_create_and_add("nwdtest_gpio", kernel_kobj);
if (!gpiotest_kobj)
return -ENOMEM;
/* Create the files associated with this kobject */
retval = sysfs_create_group(gpiotest_kobj, &attr_gpio_group);
if (retval)
kobject_put(gpiotest_kobj);
#if defined(CONFIG_HBS)
s32 gpio_val1,gpio_val2;
rk30_mux_api_set(GPIO4B7_SPI0CSN1_NAME,0);
gpio_setting_tst( RK30_PIN4_PB7,"GPIO4B7 high","hw tstout");mdelay(10);
rk30_mux_api_set(GPIO6A1_TESTCLOCKOUT_NAME,0);
gpio_setting_tst( RK30_PIN6_PA1,"GPIO6A1 input","hw tstin");mdelay(10);
gpio_val1 = gpio_get_value(RK30_PIN6_PA1);
///rk30_mux_api_set(GPIO4B7_SPI0CSN1_NAME,0);
gpio_setting_tst( RK30_PIN4_PB7,"GPIO4B7 low","hw tstout2");mdelay(10);
rk30_mux_api_set(GPIO6A1_TESTCLOCKOUT_NAME,0);
///gpio_setting_tst( RK30_PIN6_PA1,"GPIO6A1 input","hw tstin2");mdelay(10);
gpio_val2 = gpio_get_value(RK30_PIN6_PA1);
if(gpio_val1==1 && gpio_val2==0)
tp_tst = 1;
else
tp_tst = 0;
printk("=%d===\n",tp_tst);
#endif
#if 1 ///defined(CONFIG_SUOLING)
s32 gpio_val1,gpio_val2,gpio_val3;
rk30_mux_api_set(GPIO4C4_SMCDATA4_TRACEDATA4_NAME,0);
// del by lusterzhang
gpio_setting_tst( RK30_PIN4_PC4,"GPIO4C4 high","hw tstout");mdelay(2);
rk30_mux_api_set(GPIO4C6_SMCDATA6_TRACEDATA6_NAME,0);
gpio_setting_tst( RK30_PIN4_PC6,"GPIO4C6 input","hw tstin");mdelay(2);
gpio_val1 = gpio_get_value(RK30_PIN4_PC6);
///rk30_mux_api_set(GPIO4B7_SPI0CSN1_NAME,0);
gpio_setting_tst( RK30_PIN4_PC4,"GPIO4C4 low","hw tstout2");mdelay(2);
///rk30_mux_api_set(GPIO6A1_TESTCLOCKOUT_NAME,0);
///gpio_setting_tst( RK30_PIN6_PA1,"GPIO6A1 input","hw tstin2");mdelay(10);
gpio_val2 = gpio_get_value(RK30_PIN4_PC6);
gpio_setting_tst( RK30_PIN4_PC4,"GPIO4C4 high","hw tstout");mdelay(2);
gpio_val3 = gpio_get_value(RK30_PIN4_PC6);
if(gpio_val1==1 && gpio_val2==0&&gpio_val3==1)
tp_tst = 1;
else
tp_tst = 0;
#endif
///if(tp_tst == 0)
rk30_mux_api_set(GPIO6A1_TESTCLOCKOUT_NAME,0);
gpio_setting_tst( RK30_PIN6_PA1,"GPIO6A1 high","wifi pwr");mdelay(2);
gpio_set_value(RK30_PIN6_PA1,1);
rk30_mux_api_set(GPIO3B6_SDMMC0DETECTN_NAME,0);
gpio_setting_tst( RK30_PIN3_PB6,"GPIO3B6 high","hw tstout");mdelay(2);
printk_gpio("===%d %s===\n",__LINE__,__FUNCTION__);
ret = gpio_request(RK30_PIN3_PB6, "WIFIHAOBANGSHOU CS");
if(ret != 0)
{
gpio_free(RK30_PIN3_PB6);
ret = gpio_request(RK30_PIN3_PB6, "wifi cs");
if(ret != 0)
printk("gpio req error\n");
}
gpio_direction_output(RK30_PIN3_PB6,0);
gpio_set_value(RK30_PIN3_PB6, 0);
printk_gpio("===%d %s===\n",__LINE__,__FUNCTION__);
///K1103 bt pwr en ,wifi wr en
rk30_mux_api_set(GPIO2C0_LCDCDATA16_GPSCLK_HSADCCLKOUT_NAME,0);
ret = gpio_setting_tst(RK30_PIN2_PC0,"GPIO2C0 high","K1103 BT pwr");///mdelay(3000);
/*** ret = gpio_setting_tst(RK30_PIN2_PC0,"GPIO2C0 low","K1103 BT pwr");mdelay(3000);
ret = gpio_setting_tst(RK30_PIN2_PC0,"GPIO2C0 high","K1103 BT pwr");mdelay(3000);
ret = gpio_setting_tst(RK30_PIN2_PC0,"GPIO2C0 low","K1103 BT pwr");mdelay(3000);
ret = gpio_setting_tst(RK30_PIN2_PC0,"GPIO2C0 high","K1103 BT pwr");mdelay(3000);
ret = gpio_setting_tst(RK30_PIN2_PC0,"GPIO2C0 low","K1103 BT pwr");mdelay(3000);
ret = gpio_setting_tst(RK30_PIN2_PC0,"GPIO2C0 high","K1103 BT pwr");mdelay(3000);
///ret = gpio_setting_tst(RK30_PIN2_PC0,"GPIO2C0 low","K1103 BT pwr");mdelay(3000);*/
#ifdef CONFIG_NWD_K1103
rk30_mux_api_set(GPIO3A7_SDMMC0PWREN_NAME,0);
///ret = gpio_setting_tst(RK30_PIN3_PA7,"GPIO3A7 high","K1103 WIFI pwr");
ret = gpio_request(RK30_PIN3_PA7, "K1103 WIFI pwr");
if(ret != 0)
{
gpio_free(RK30_PIN3_PA7);
ret = gpio_request(RK30_PIN3_PA7, "wK1103 WIFI pwr");
if(ret != 0)
printk("gpio req error\n");
}
gpio_direction_output(RK30_PIN3_PA7,1);
gpio_set_value(RK30_PIN3_PA7, 1);/***mdelay(3000);gpio_set_value(RK30_PIN3_PA7, 0);mdelay(3000);
gpio_set_value(RK30_PIN3_PA7, 1);mdelay(3000);gpio_set_value(RK30_PIN3_PA7, 0);mdelay(3000);
gpio_set_value(RK30_PIN3_PA7, 1);mdelay(3000);gpio_set_value(RK30_PIN3_PA7, 0);mdelay(3000);
gpio_set_value(RK30_PIN3_PA7, 1);mdelay(3000);///gpio_set_value(RK30_PIN3_PA7, 0);mdelay(3000);*/
#endif
bluetooth_reset_func();
return retval;
}
static int rk30_rmii_io_init(void)
{
int err;
rk30_mux_api_set(GPIO1D6_CIF1DATA11_NAME, GPIO1D_GPIO1D6);
rk30_mux_api_set(GPIO1D2_CIF1CLKIN_NAME, GPIO1D_GPIO1D2);
rk30_mux_api_set(GPIO1D1_CIF1HREF_MIIMDCLK_NAME, GPIO1D_MII_MDCLK);
rk30_mux_api_set(GPIO1D0_CIF1VSYNC_MIIMD_NAME, GPIO1D_MII_MD);
rk30_mux_api_set(GPIO1C7_CIFDATA9_RMIIRXD0_NAME, GPIO1C_RMII_RXD0);
rk30_mux_api_set(GPIO1C6_CIFDATA8_RMIIRXD1_NAME, GPIO1C_RMII_RXD1);
rk30_mux_api_set(GPIO1C5_CIFDATA7_RMIICRSDVALID_NAME, GPIO1C_RMII_CRS_DVALID);
rk30_mux_api_set(GPIO1C4_CIFDATA6_RMIIRXERR_NAME, GPIO1C_RMII_RX_ERR);
rk30_mux_api_set(GPIO1C3_CIFDATA5_RMIITXD0_NAME, GPIO1C_RMII_TXD0);
rk30_mux_api_set(GPIO1C2_CIF1DATA4_RMIITXD1_NAME, GPIO1C_RMII_TXD1);
rk30_mux_api_set(GPIO1C1_CIFDATA3_RMIITXEN_NAME, GPIO1C_RMII_TX_EN);
rk30_mux_api_set(GPIO1C0_CIF1DATA2_RMIICLKOUT_RMIICLKIN_NAME, GPIO1C_RMII_CLKOUT);
//phy power gpio
err = gpio_request(PHY_PWR_EN_GPIO, "phy_power_en");
if (err) {
return -1;
}
//phy power down
gpio_direction_output(PHY_PWR_EN_GPIO, GPIO_LOW);
gpio_set_value(PHY_PWR_EN_GPIO, GPIO_LOW);
return 0;
}
static int rk30_rmii_power_control(int enable)
{
struct regulator *ldo_rmii;
ldo_rmii = regulator_get(NULL, "ldo9");
if (ldo_rmii == NULL || IS_ERR(ldo_rmii)){
printk("get rmii ldo failed!\n");
return -1;
}
if (enable) {
//enable phy power
printk("power on phy\n");
rk30_mux_api_set(GPIO1D6_CIF1DATA11_NAME, GPIO1D_GPIO1D6);
rk30_mux_api_set(GPIO1D2_CIF1CLKIN_NAME, GPIO1D_GPIO1D2);
rk30_mux_api_set(GPIO1D1_CIF1HREF_MIIMDCLK_NAME, GPIO1D_MII_MDCLK);
rk30_mux_api_set(GPIO1D0_CIF1VSYNC_MIIMD_NAME, GPIO1D_MII_MD);
rk30_mux_api_set(GPIO1C7_CIFDATA9_RMIIRXD0_NAME, GPIO1C_RMII_RXD0);
rk30_mux_api_set(GPIO1C6_CIFDATA8_RMIIRXD1_NAME, GPIO1C_RMII_RXD1);
rk30_mux_api_set(GPIO1C5_CIFDATA7_RMIICRSDVALID_NAME, GPIO1C_RMII_CRS_DVALID);
rk30_mux_api_set(GPIO1C4_CIFDATA6_RMIIRXERR_NAME, GPIO1C_RMII_RX_ERR);
rk30_mux_api_set(GPIO1C3_CIFDATA5_RMIITXD0_NAME, GPIO1C_RMII_TXD0);
rk30_mux_api_set(GPIO1C2_CIF1DATA4_RMIITXD1_NAME, GPIO1C_RMII_TXD1);
rk30_mux_api_set(GPIO1C1_CIFDATA3_RMIITXEN_NAME, GPIO1C_RMII_TX_EN);
rk30_mux_api_set(GPIO1C0_CIF1DATA2_RMIICLKOUT_RMIICLKIN_NAME, GPIO1C_RMII_CLKOUT);
gpio_direction_output(PHY_PWR_EN_GPIO, GPIO_HIGH);
gpio_set_value(PHY_PWR_EN_GPIO, GPIO_HIGH);
//$_rbox_$_modify_$_chenzhi_20121008: power control by pmu
//$_rbox_$_modify_$_begin
if(!regulator_is_enabled(ldo_rmii)) {
// regulator_set_voltage(ldo_rmii, 3300000, 3300000);
regulator_enable(ldo_rmii);
regulator_put(ldo_rmii);
mdelay(500);
}
//$_rbox_$_modify_$_end
}else {
gpio_direction_output(PHY_PWR_EN_GPIO, GPIO_LOW);
gpio_set_value(PHY_PWR_EN_GPIO, GPIO_LOW);
//$_rbox_$_modify_$_chenzhi_20121008: power control by pmu
//$_rbox_$_modify_$_begin
if(regulator_is_enabled(ldo_rmii)) {
regulator_disable(ldo_rmii);
regulator_put(ldo_rmii);
mdelay(500);
}
//$_rbox_$_modify_$_end
}
return 0;
}
int lcd_io_init(void)
{
int ret = 0;
if(RK_LCD_STANDBY_PIN != INVALID_GPIO){
rk30_mux_api_set(RK_LCD_STANDBY_MUX_NAME, RK_LCD_STANDBY_MUX_MODE);
ret = gpio_request(RK_LCD_STANDBY_PIN, NULL);
if(ret !=0){
printk(KERN_ERR "request lcd standby pin failed!\n");
}else{
gpio_direction_output(RK_LCD_STANDBY_PIN, GPIO_HIGH);
gpio_set_value(RK_LCD_STANDBY_PIN, RK_LCD_STANDBY_VALUE);
mdelay(5);
}
}
if(RK_LCD_EN_PIN != INVALID_GPIO){
rk30_mux_api_set(RK_LCD_EN_MUX_NAME, RK_LCD_EN_MUX_MODE);
ret = gpio_request(RK_LCD_EN_PIN, NULL);
if (ret != 0){
printk(KERN_ERR "request lcd en2 pin fail!\n");
}
else{
gpio_direction_output(RK_LCD_EN_PIN, 1);
gpio_set_value(RK_LCD_EN_PIN, RK_LCD_EN_VALUE);
}
}
if(RK_LCD_RESET_PIN != INVALID_GPIO){
rk30_mux_api_set(RK_LCD_RESET_MUX_NAME, RK_LCD_RESET_MUX_MODE);
ret = gpio_request(RK_LCD_RESET_PIN, NULL);
if(ret !=0){
printk(KERN_ERR "request lcd reset pin failed!\n");
}else{
mdelay(50);
gpio_pull_updown(RK_LCD_RESET_PIN, GPIOPullUp);
gpio_direction_output(RK_LCD_RESET_PIN, GPIO_HIGH);
gpio_set_value(RK_LCD_RESET_PIN, RK_LCD_RESET_VALUE);
}
}
if(LCD_CS_PIN != INVALID_GPIO){
rk30_mux_api_set(LCD_CS_MUX_NAME, LCD_CS_MUX_MODE);
ret = gpio_request(LCD_CS_PIN, NULL);
if (ret != 0){
printk(KERN_ERR "request lcd en pin fail!\n");
}
else{
gpio_direction_output(LCD_CS_PIN, 1);
gpio_set_value(LCD_CS_PIN, LCD_CS_VALUE);
}
}
if(LCD_SPI_CS_PIN != INVALID_GPIO){
rk30_mux_api_set(LCD_SPI_CS_MUX_NAME, LCD_SPI_CS_MUX_MODE);
ret = gpio_request(LCD_SPI_CS_PIN, NULL);
if (ret != 0){
printk(KERN_ERR "request lcd spi cs pin fail!\n");
}else{
gpio_direction_output(LCD_SPI_CS_PIN, 1);
gpio_set_value(LCD_SPI_CS_PIN, GPIO_LOW);
}
}
if(LCD_SPI_SCL_PIN != INVALID_GPIO){
rk30_mux_api_set(LCD_SPI_SCL_MUX_NAME, LCD_SPI_SCL_MUX_MODE);
ret = gpio_request(LCD_SPI_SCL_PIN, NULL);
if (ret != 0){
printk(KERN_ERR "request lcd spi scl pin fail!\n");
}else{
gpio_direction_output(LCD_SPI_SCL_PIN, 1);
gpio_set_value(LCD_SPI_SCL_PIN, GPIO_LOW);
}
}
if(LCD_SPI_SDA_PIN != INVALID_GPIO){
rk30_mux_api_set(LCD_SPI_SDA_MUX_NAME, LCD_SPI_SDA_MUX_MODE);
ret = gpio_request(LCD_SPI_SDA_PIN, NULL);
if (ret != 0){
printk(KERN_ERR "request lcd spi sda pin fail!\n");
}else{
gpio_direction_output(LCD_SPI_SDA_PIN, 1);
gpio_set_value(LCD_SPI_SDA_PIN, GPIO_LOW);
}
}
td043_init();
return 0;
}
static int mma7660_init_platform_hw(void)
{
rk30_mux_api_set(GPIO1B2_SPI_RXD_UART1_SIN_NAME, GPIO1B_GPIO1B2);
return 0;
}
static void rk29_sdmmc_gpio_open(int device_id, int on)
{
switch(device_id)
{
case 0://mmc0
{
#ifdef CONFIG_SDMMC0_RK29
if(on)
{
gpio_direction_output(RK30_PIN3_PA2,GPIO_HIGH);//set mmc0-clk to high
gpio_direction_output(RK30_PIN3_PA3,GPIO_HIGH);// set mmc0-cmd to high.
gpio_direction_output(RK30_PIN3_PA4,GPIO_HIGH);//set mmc0-data0 to high.
gpio_direction_output(RK30_PIN3_PA5,GPIO_HIGH);//set mmc0-data1 to high.
gpio_direction_output(RK30_PIN3_PA6,GPIO_HIGH);//set mmc0-data2 to high.
gpio_direction_output(RK30_PIN3_PA7,GPIO_HIGH);//set mmc0-data3 to high.
mdelay(30);
}
else
{
rk30_mux_api_set(GPIO3A2_SDMMC0CLKOUT_NAME, GPIO3A_GPIO3A2);
gpio_request(RK30_PIN3_PA2, "mmc0-clk");
gpio_direction_output(RK30_PIN3_PA2,GPIO_LOW);//set mmc0-clk to low.
rk30_mux_api_set(GPIO3A3_SDMMC0CMD_NAME, GPIO3A_GPIO3A3);
gpio_request(RK30_PIN3_PA3, "mmc0-cmd");
gpio_direction_output(RK30_PIN3_PA3,GPIO_LOW);//set mmc0-cmd to low.
rk30_mux_api_set(GPIO3A4_SDMMC0DATA0_NAME, GPIO3A_GPIO3A4);
gpio_request(RK30_PIN3_PA4, "mmc0-data0");
gpio_direction_output(RK30_PIN3_PA4,GPIO_LOW);//set mmc0-data0 to low.
rk30_mux_api_set(GPIO3A5_SDMMC0DATA1_NAME, GPIO3A_GPIO3A5);
gpio_request(RK30_PIN3_PA5, "mmc0-data1");
gpio_direction_output(RK30_PIN3_PA5,GPIO_LOW);//set mmc0-data1 to low.
rk30_mux_api_set(GPIO3A6_SDMMC0DATA2_NAME, GPIO3A_GPIO3A6);
gpio_request(RK30_PIN3_PA6, "mmc0-data2");
gpio_direction_output(RK30_PIN3_PA6,GPIO_LOW);//set mmc0-data2 to low.
rk30_mux_api_set(GPIO3A7_SDMMC0DATA3_NAME, GPIO3A_GPIO3A7);
gpio_request(RK30_PIN3_PA7, "mmc0-data3");
gpio_direction_output(RK30_PIN3_PA7,GPIO_LOW);//set mmc0-data3 to low.
mdelay(30);
}
#endif
}
break;
case 1://mmc1
{
#ifdef CONFIG_SDMMC1_RK29
if(on)
{
gpio_direction_output(RK30_PIN3_PC5,GPIO_HIGH);//set mmc1-clk to high
gpio_direction_output(RK30_PIN3_PC0,GPIO_HIGH);//set mmc1-cmd to high.
gpio_direction_output(RK30_PIN3_PC1,GPIO_HIGH);//set mmc1-data0 to high.
gpio_direction_output(RK30_PIN3_PC2,GPIO_HIGH);//set mmc1-data1 to high.
gpio_direction_output(RK30_PIN3_PC3,GPIO_HIGH);//set mmc1-data2 to high.
gpio_direction_output(RK30_PIN3_PC4,GPIO_HIGH);//set mmc1-data3 to high.
mdelay(100);
}
else
{
rk30_mux_api_set(GPIO3C5_SDMMC1CLKOUT_RMIICLKOUT_RMIICLKIN_NAME, GPIO3C_GPIO3C5);
gpio_request(RK30_PIN3_PC5, "mmc1-clk");
gpio_direction_output(RK30_PIN3_PC5,GPIO_LOW);//set mmc1-clk to low.
rk30_mux_api_set(GPIO3C0_SDMMC1CMD_RMIITXEN_NAME, GPIO3C_GPIO3C0);
gpio_request(RK30_PIN3_PC0, "mmc1-cmd");
gpio_direction_output(RK30_PIN3_PC0,GPIO_LOW);//set mmc1-cmd to low.
rk30_mux_api_set(GPIO3C1_SDMMC1DATA0_RMIITXD1_NAME, GPIO3C_GPIO3C1);
gpio_request(RK30_PIN3_PC1, "mmc1-data0");
gpio_direction_output(RK30_PIN3_PC1,GPIO_LOW);//set mmc1-data0 to low.
mdelay(100);
}
#endif
}
break;
case 2: //mmc2
break;
default:
break;
}
}
///6B4 4D6 6B1 6A0 0C5 4C4 4C6 4C7 6B2 2C5 2C6 2C3 6A2 1B3 3D5 3D6 4C1 4C0 3D0 4D2 3A2 3A3 4D1 4D0 3A7 2A0 2A1 2A2 2C0 2B6 6A5
///6A6 6B3 4C3 6A7 0C7
///6B4 6B1 6B2 6B3 6A5 6A0 6A2 6A6 4D6 0C5 4C4 4C6 4C7 2C5 2C6 2C3 1B3 3D5 3D6 4C1 4C0 3D0 4D2 3A2 3A3 4D1 4D0 3A7 2A0 2A1 2A2 2C0 2B6
/// 4C3 6A7 0C7
static ssize_t gpio_nwd_write(struct kobject *kobj, struct kobj_attribute *attr,const char *buf, size_t count)
{
int ret = 0;int cnt = 0;void __iomem * p1;void __iomem *p2;void __iomem *p3;void __iomem *p4;
int new_state = simple_strtoul(buf, NULL, 16);
#ifdef GPIO_HW_TST
char req_name[7];
if(strncmp(buf,"GPIO2C2",7)==0)
{ printk_gpio("===%d %s===\n",__LINE__,__FUNCTION__);
gpio = RK30_PIN2_PC2;
if( strlen(buf) == 7 )
{printk_gpio("===%d %s===\n",__LINE__,__FUNCTION__);goto end_gpio;}
printk_gpio("===%d %s===\n",__LINE__,__FUNCTION__);
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2C2_LCDC1DATA18_SMCBLSN1_HSADCDATA5_NAME,0);
/*** ret = gpio_request(gpio, "gpio2c2");
if(ret != 0)
{
gpio_free(gpio);
ret = gpio_request(gpio, "gpio2c2");
if(ret != 0)
printk("gpio req error\n");
}
if(strncmp(buf+8,"inp",3)==0)
gpio_direction_input(gpio);
if(strncmp(buf+8,"hig",3)==0) {
gpio_direction_output(gpio,1);
gpio_set_value(gpio, 1);
}
if(strncmp(buf+8,"low",3)==0) {
gpio_direction_output(gpio,1);
gpio_set_value(gpio, 0);
}*/
ret = gpio_setting_tst( gpio,buf,req_name);
////}
}
/**/
else if(strncmp(buf,"GPIO4D6",7)==0)
{ gpio = RK30_PIN4_PD6; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4D6_SMCDATA14_TRACEDATA14_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO4D5",7)==0)
{ gpio = RK30_PIN4_PD5; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4D5_SMCDATA13_TRACEDATA13_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO0C6",7)==0)
{ gpio = RK30_PIN0_PC6; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO0C6_TRACECLK_SMCADDR2_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO0C7",7)==0)
{ gpio = RK30_PIN0_PC7; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO0C7_TRACECTL_SMCADDR3_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO4C3",7)==0)
{ gpio = RK30_PIN4_PC3; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4C3_SMCDATA3_TRACEDATA3_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO6A7",7)==0)
{ gpio = RK30_PIN6_PA7; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6A7_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO0C5",7)==0)
{ gpio = RK30_PIN0_PC5;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO0C5_I2S12CHSDO_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO4C4",7)==0)
{ gpio = RK30_PIN4_PC4; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4C4_SMCDATA4_TRACEDATA4_NAME,0);printk_gpio("===%d %s===\n",__LINE__,__FUNCTION__);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO4C6",7)==0)
{ gpio = RK30_PIN4_PC6;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4C6_SMCDATA6_TRACEDATA6_NAME,0); printk_gpio("===%d %s===\n",__LINE__,__FUNCTION__);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO4C7",7)==0)
{ gpio = RK30_PIN4_PC7; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4C7_SMCDATA7_TRACEDATA7_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2C3",7)==0)
{ gpio = RK30_PIN2_PC3;
strncpy(req_name,buf,7);
rk30_mux_api_set( GPIO2C3_LCDC1DATA19_SPI1CLK_HSADCDATA0_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2C5",7)==0)
{ gpio = RK30_PIN2_PC5; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2C5_LCDC1DATA21_SPI1TXD_HSADCDATA2_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2C6",7)==0)
{ gpio = RK30_PIN2_PC6;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2C6_LCDC1DATA22_SPI1RXD_HSADCDATA3_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO1B3",7)==0)
{ gpio = RK30_PIN1_PB3; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO1B3_CIF0CLKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3D5",7)==0)
{ gpio = RK30_PIN3_PD5;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO3D5_UART3CTSN_NAME ,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3D6",7)==0)
{ gpio = RK30_PIN3_PD6; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set( GPIO3D6_UART3RTSN_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO4C0",7)==0)
{ gpio = RK30_PIN4_PC0;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4C0_SMCDATA0_TRACEDATA0_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO4C1",7)==0)
{ gpio = RK30_PIN4_PC1; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4C1_SMCDATA1_TRACEDATA1_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3D0",7)==0)
{ gpio = RK30_PIN3_PD0;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO3D0_SDMMC1PWREN_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO4D2",7)==0)
{ gpio = RK30_PIN4_PD2; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4D2_SMCDATA10_TRACEDATA10_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3A2",7)==0)
{ gpio = RK30_PIN3_PA2;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO3A2_I2C3SDA_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3A3",7)==0)
{ gpio = RK30_PIN3_PA3; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set( GPIO3A3_I2C3SCL_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO4D0",7)==0)
{ gpio = RK30_PIN4_PD0;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4D0_SMCDATA8_TRACEDATA8_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO4D1",7)==0)
{ gpio = RK30_PIN4_PD1;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4D1_SMCDATA9_TRACEDATA9_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3A7",7)==0)
{ gpio = RK30_PIN3_PA7;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO3A7_SDMMC0PWREN_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2A0",7)==0)
{ gpio = RK30_PIN2_PA0;
strncpy(req_name,buf,7);
rk30_mux_api_set( GPIO2A0_LCDC1DATA0_SMCADDR4_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2B6",7)==0)
{ gpio = RK30_PIN2_PB6;
strncpy(req_name,buf,7);
rk30_mux_api_set( GPIO2B6_LCDC1DATA14_SMCADDR18_TSSYNC_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2C0",7)==0)
{ gpio = RK30_PIN2_PC0;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2C0_LCDCDATA16_GPSCLK_HSADCCLKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2A2",7)==0)
{ gpio = RK30_PIN2_PA2;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2A2_LCDCDATA2_SMCADDR6_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2A1",7)==0)
{ gpio = RK30_PIN2_PA1;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2A1_LCDC1DATA1_SMCADDR5_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO6B1",7)==0)
{ gpio = RK30_PIN6_PB1;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6B1_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO6B2",7)==0)
{ gpio = RK30_PIN6_PB2;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6B2_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO6B3",7)==0)
{ gpio = RK30_PIN6_PB3;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6B3_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO6B4",7)==0)
{ gpio = RK30_PIN6_PB4;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6B4_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO6A0",7)==0)
{ gpio = RK30_PIN6_PA0;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6A0_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO6A2",7)==0)
{ gpio = RK30_PIN6_PA2;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6A2_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO6A5",7)==0)
{ gpio = RK30_PIN6_PA5;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6A5_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO6A6",7)==0)
{ gpio = RK30_PIN6_PA6;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6A6_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
else if(strncmp(buf,"GPIO2C1",7)==0)
{ gpio = RK30_PIN2_PC1; ///if( strlen(buf) == 7 ) goto end_gpio;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2C1_LCDC1DATA17_SMCBLSN0_HSADCDATA6_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2B7",7)==0)
{ gpio = RK30_PIN2_PB7;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2B7_LCDC1DATA15_SMCADDR19_HSADCDATA7_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2B5",7)==0)
{ gpio = RK30_PIN2_PB5;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2B5_LCDC1DATA13_SMCADDR17_HSADCDATA8_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2C4",7)==0) ///
{ gpio = RK30_PIN2_PC4;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2C4_LCDC1DATA20_SPI1CSN0_HSADCDATA1_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO2C7",7)==0)
{ gpio = RK30_PIN2_PC7;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO2C7_LCDC1DATA23_SPI1CSN1_HSADCDATA4_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO4C5",7)==0)///
{ gpio = RK30_PIN4_PC5;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4C5_SMCDATA5_TRACEDATA5_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO4C2",7)==0)
{ gpio = RK30_PIN4_PC2;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4C2_SMCDATA2_TRACEDATA2_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3A1",7)==0) ///
{ gpio = RK30_PIN3_PA1;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO3A1_I2C2SCL_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3A0",7)==0)
{ gpio = RK30_PIN3_PA0;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO3A0_I2C2SDA_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO4B7",7)==0)///
{ gpio = RK30_PIN4_PB7;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO4B7_SPI0CSN1_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO6A1",7)==0)
{ gpio = RK30_PIN6_PA1;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6A1_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name); ////FOLLWOING IS CAM
}else if(strncmp(buf,"GPIO1B1",7)==0)
{ gpio = RK30_PIN1_PB1;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO1B1_UART2SOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO1B0",7)==0)
{ gpio = RK30_PIN1_PB0;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO1B0_UART2SIN_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3D4",7)==0)
{ gpio = RK30_PIN3_PD4;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO3D4_UART3SOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3D3",7)==0)
{ gpio = RK30_PIN3_PD3;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO3D3_UART3SIN_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO1A5",7)==0)
{ gpio = RK30_PIN1_PA5;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO1A5_UART1SOUT_SPI0CLK_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO1A4",7)==0)
{ gpio = RK30_PIN1_PA4;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO1A4_UART1SIN_SPI0CSN0_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO6A5",7)==0)
{ gpio = RK30_PIN6_PA5;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6A5_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO6A7",7)==0)
{ gpio = RK30_PIN6_PA7;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO6A7_TESTCLOCKOUT_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO3B6",7)==0)
{ gpio = RK30_PIN3_PB6;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO3B6_SDMMC0DETECTN_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO0A4",7)==0) ///add for v2
{ gpio = RK30_PIN0_PA4;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO0A4_PWM1_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}else if(strncmp(buf,"GPIO0D6",7)==0)
{ gpio = RK30_PIN0_PD6;
strncpy(req_name,buf,7);
rk30_mux_api_set(GPIO0D6_PWM2_NAME,0);
ret = gpio_setting_tst( gpio,buf,req_name);
}
#endif
end_gpio:
return ret;///ret;
}
static int init_rk3066b_lcdc(struct rk_lcdc_device_driver *dev_drv)
{
struct rk3066b_lcdc_device *lcdc_dev = container_of(dev_drv,struct rk3066b_lcdc_device,driver);
if(lcdc_dev->id == 0) //lcdc0
{
lcdc_dev->pd = clk_get(NULL,"pd_lcdc0");
lcdc_dev->hclk = clk_get(NULL,"hclk_lcdc0");
lcdc_dev->aclk = clk_get(NULL,"aclk_lcdc0");
lcdc_dev->dclk = clk_get(NULL,"dclk_lcdc0");
}
else if(lcdc_dev->id == 1)
{
lcdc_dev->pd = clk_get(NULL,"pd_lcdc1");
lcdc_dev->hclk = clk_get(NULL,"hclk_lcdc1");
lcdc_dev->aclk = clk_get(NULL,"aclk_lcdc1");
lcdc_dev->dclk = clk_get(NULL,"dclk_lcdc1");
}
else
{
printk(KERN_ERR "invalid lcdc device!\n");
return -EINVAL;
}
if (IS_ERR(lcdc_dev->pd) || (IS_ERR(lcdc_dev->aclk)) ||(IS_ERR(lcdc_dev->dclk)) || (IS_ERR(lcdc_dev->hclk)))
{
printk(KERN_ERR "failed to get lcdc%d clk source\n",lcdc_dev->id);
}
clk_enable(lcdc_dev->pd);
clk_enable(lcdc_dev->hclk); //enable aclk and hclk for register config
clk_enable(lcdc_dev->aclk);
lcdc_dev->clk_on = 1;
if(lcdc_dev->id == 1) //iomux for lcdc1
{
rk30_mux_api_set(GPIO2D0_LCDC1DCLK_SMCCSN0_NAME,GPIO2D_LCDC1DCLK);
rk30_mux_api_set(GPIO2D1_LCDC1DEN_SMCWEN_NAME,GPIO2D_LCDC1DEN);
rk30_mux_api_set(GPIO2D2_LCDC1HSYNC_SMCOEN_NAME,GPIO2D_LCDC1HSYNC);
rk30_mux_api_set(GPIO2D3_LCDC1VSYNC_SMCADVN_NAME,GPIO2D_LCDC1VSYNC);
rk30_mux_api_set(GPIO2A0_LCDC1DATA0_SMCDATA0_TRACEDATA0_NAME,GPIO2A_LCDC1DATA0);
rk30_mux_api_set(GPIO2A1_LCDC1DATA1_SMCDATA1_TRACEDATA1_NAME,GPIO2A_LCDC1DATA1);
rk30_mux_api_set(GPIO2A2_LCDC1DATA2_SMCDATA2_TRACEDATA2_NAME,GPIO2A_LCDC1DATA2);
rk30_mux_api_set(GPIO2A3_LCDC1DATA3_SMCDATA3_TRACEDATA3_NAME,GPIO2A_LCDC1DATA3);
rk30_mux_api_set(GPIO2A4_LCDC1DATA4_SMCDATA4_TRACEDATA4_NAME,GPIO2A_LCDC1DATA4);
rk30_mux_api_set(GPIO2A5_LCDC1DATA5_SMCDATA5_TRACEDATA5_NAME,GPIO2A_LCDC1DATA5);
rk30_mux_api_set(GPIO2A6_LCDC1DATA6_SMCDATA6_TRACEDATA6_NAME,GPIO2A_LCDC1DATA6);
rk30_mux_api_set(GPIO2A7_LCDC1DATA7_SMCDATA7_TRACEDATA7_NAME,GPIO2A_LCDC1DATA7);
rk30_mux_api_set(GPIO2B0_LCDC1DATA8_SMCDATA8_TRACEDATA8_NAME,GPIO2B_LCDC1DATA8);
rk30_mux_api_set(GPIO2B1_LCDC1DATA9_SMCDATA9_TRACEDATA9_NAME,GPIO2B_LCDC1DATA9);
rk30_mux_api_set(GPIO2B2_LCDC1DATA10_SMCDATA10_TRACEDATA10_NAME,GPIO2B_LCDC1DATA10);
rk30_mux_api_set(GPIO2B3_LCDC1DATA11_SMCDATA11_TRACEDATA11_NAME,GPIO2B_LCDC1DATA11);
rk30_mux_api_set(GPIO2B4_LCDC1DATA12_SMCDATA12_TRACEDATA12_NAME,GPIO2B_LCDC1DATA12);
rk30_mux_api_set(GPIO2B5_LCDC1DATA13_SMCDATA13_TRACEDATA13_NAME,GPIO2B_LCDC1DATA13);
rk30_mux_api_set(GPIO2B6_LCDC1DATA14_SMCDATA14_TRACEDATA14_NAME,GPIO2B_LCDC1DATA14);
rk30_mux_api_set(GPIO2B7_LCDC1DATA15_SMCDATA15_TRACEDATA15_NAME,GPIO2B_LCDC1DATA15);
rk30_mux_api_set(GPIO2C0_LCDC1DATA16_SMCADDR0_TRACECLK_NAME,GPIO2C_LCDC1DATA16);
rk30_mux_api_set(GPIO2C1_LCDC1DATA17_SMCADDR1_TRACECTL_NAME,GPIO2C_LCDC1DATA17);
rk30_mux_api_set(GPIO2C2_LCDC1DATA18_SMCADDR2_NAME,GPIO2C_LCDC1DATA18);
rk30_mux_api_set(GPIO2C3_LCDC1DATA19_SMCADDR3_NAME,GPIO2C_LCDC1DATA19);
rk30_mux_api_set(GPIO2C4_LCDC1DATA20_SMCADDR4_NAME,GPIO2C_LCDC1DATA20);
rk30_mux_api_set(GPIO2C5_LCDC1DATA21_SMCADDR5_NAME,GPIO2C_LCDC1DATA21);
rk30_mux_api_set(GPIO2C6_LCDC1DATA22_SMCADDR6_NAME,GPIO2C_LCDC1DATA22);
rk30_mux_api_set(GPIO2C7_LCDC1DATA23_SMCADDR7_NAME,GPIO2C_LCDC1DATA23);
}
LcdMskReg(lcdc_dev,SYS_CFG, m_LCDC_AXICLK_AUTO_ENABLE | m_W0_AXI_OUTSTANDING2 |
m_W1_AXI_OUTSTANDING2,v_LCDC_AXICLK_AUTO_ENABLE(1) | v_W0_AXI_OUTSTANDING2(1) |
v_W1_AXI_OUTSTANDING2(1));//eanble axi-clk auto gating for low power
LcdWrReg(lcdc_dev,AXI_MS_ID,v_HWC_CHANNEL_ID(5) | v_WIN2_CHANNEL_ID(4) |
v_WIN1_YRGB_CHANNEL_ID(3) | v_WIN0_CBR_CHANNEL_ID(2) |
v_WIN0_YRGB_CHANNEL_ID(1));
LcdMskReg(lcdc_dev, INT_STATUS,m_HOR_STARTMASK| m_FRM_STARTMASK |
m_SCANNING_MASK, v_HOR_STARTMASK(1) | v_FRM_STARTMASK(1) |
v_SCANNING_MASK(1)); //mask all interrupt in init
LcdMskReg(lcdc_dev,FIFO_WATER_MARK,m_WIN1_FIFO_FULL_LEVEL,v_WIN1_FIFO_FULL_LEVEL(0x1e0));
//LCDC_REG_CFG_DONE(); // write any value to REG_CFG_DONE let config become effective
return 0;
}
static int kxtik_init_platform_hw(void)
{
rk30_mux_api_set(GPIO4C0_SMCDATA0_TRACEDATA0_NAME, GPIO4C_GPIO4C0);
return 0;
}
static void rk29_sdmmc_gpio_open(int device_id, int on)
{
switch(device_id)
{
case 0://mmc0
{
#ifdef CONFIG_SDMMC0_RK29
if(on)
{
gpio_direction_output(GPIO3B_GPIO3B0,GPIO_HIGH);//set mmc0-clk to high
gpio_direction_output(GPIO3B_GPIO3B1,GPIO_HIGH);// set mmc0-cmd to high.
gpio_direction_output(GPIO3B_GPIO3B2,GPIO_HIGH);//set mmc0-data0 to high.
gpio_direction_output(GPIO3B_GPIO3B3,GPIO_HIGH);//set mmc0-data1 to high.
gpio_direction_output(GPIO3B_GPIO3B4,GPIO_HIGH);//set mmc0-data2 to high.
gpio_direction_output(GPIO3B_GPIO3B5,GPIO_HIGH);//set mmc0-data3 to high.
mdelay(30);
}
else
{
rk30_mux_api_set(GPIO3B0_SDMMC0CLKOUT_NAME, GPIO3B_GPIO3B0);
gpio_request(RK30_PIN3_PB0, "mmc0-clk");
gpio_direction_output(RK30_PIN3_PB0,GPIO_LOW);//set mmc0-clk to low.
rk30_mux_api_set(GPIO3B1_SDMMC0CMD_NAME, GPIO3B_GPIO3B1);
gpio_request(RK30_PIN3_PB1, "mmc0-cmd");
gpio_direction_output(RK30_PIN3_PB1,GPIO_LOW);//set mmc0-cmd to low.
rk30_mux_api_set(GPIO3B2_SDMMC0DATA0_NAME, GPIO3B_GPIO3B2);
gpio_request(RK30_PIN3_PB2, "mmc0-data0");
gpio_direction_output(RK30_PIN3_PB2,GPIO_LOW);//set mmc0-data0 to low.
rk30_mux_api_set(GPIO3B3_SDMMC0DATA1_NAME, GPIO3B_GPIO3B3);
gpio_request(RK30_PIN3_PB3, "mmc0-data1");
gpio_direction_output(RK30_PIN3_PB3,GPIO_LOW);//set mmc0-data1 to low.
rk30_mux_api_set(GPIO3B4_SDMMC0DATA2_NAME, GPIO3B_GPIO3B4);
gpio_request(RK30_PIN3_PB4, "mmc0-data2");
gpio_direction_output(RK30_PIN3_PB4,GPIO_LOW);//set mmc0-data2 to low.
rk30_mux_api_set(GPIO3B5_SDMMC0DATA3_NAME, GPIO3B_GPIO3B5);
gpio_request(RK30_PIN3_PB5, "mmc0-data3");
gpio_direction_output(RK30_PIN3_PB5,GPIO_LOW);//set mmc0-data3 to low.
mdelay(30);
}
#endif
}
break;
case 1://mmc1
{
#ifdef CONFIG_SDMMC1_RK29
if(on)
{
gpio_direction_output(RK30_PIN3_PC5,GPIO_HIGH);//set mmc1-clk to high
gpio_direction_output(RK30_PIN3_PC0,GPIO_HIGH);//set mmc1-cmd to high.
gpio_direction_output(RK30_PIN3_PC1,GPIO_HIGH);//set mmc1-data0 to high.
gpio_direction_output(RK30_PIN3_PC2,GPIO_HIGH);//set mmc1-data1 to high.
gpio_direction_output(RK30_PIN3_PC3,GPIO_HIGH);//set mmc1-data2 to high.
gpio_direction_output(RK30_PIN3_PC5,GPIO_HIGH);//set mmc1-data3 to high.
mdelay(100);
}
else
{
rk30_mux_api_set(GPIO3C5_SDMMC1CLKOUT_NAME, GPIO3C_GPIO3C5);
gpio_request(RK30_PIN3_PC5, "mmc1-clk");
gpio_direction_output(RK30_PIN3_PC5,GPIO_LOW);//set mmc1-clk to low.
rk30_mux_api_set(GPIO3C0_SMMC1CMD_NAME, GPIO3C_GPIO3C0);
gpio_request(RK30_PIN3_PC0, "mmc1-cmd");
gpio_direction_output(RK30_PIN3_PC0,GPIO_LOW);//set mmc1-cmd to low.
rk30_mux_api_set(GPIO3C1_SDMMC1DATA0_NAME, GPIO3C_GPIO3C1);
gpio_request(RK30_PIN3_PC1, "mmc1-data0");
gpio_direction_output(RK30_PIN3_PC1,GPIO_LOW);//set mmc1-data0 to low.
mdelay(100);
}
#endif
}
break;
case 2: //mmc2
break;
default:
break;
}
}
static int adv7180_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct adv7180_state *state;
struct v4l2_subdev *sd;
struct soc_camera_device *icd = client->dev.platform_data;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int ret;
printk("%s %d\n", __func__, __LINE__);
/* Check if the adapter supports the needed features */
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
printk("%s %d\n", __func__, __LINE__);
v4l_info(client, "chip found @ 0x%02x (%s)\n",
client->addr << 1, client->adapter->name);
printk("%s %d\n", __func__, __LINE__);
state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL);
if (state == NULL) {
ret = -ENOMEM;
goto err;
}
printk("%s %d\n", __func__, __LINE__);
rk30_mux_api_set(GPIO0B7_I2S8CHSDO3_NAME, GPIO0B_GPIO0B7);
ret = gpio_request(ADV7180_CVBS_IN_DET, "ADV_CVBS_INT");
if (ret != 0)
{
gpio_free(ADV7180_CVBS_IN_DET);
printk(KERN_ERR "request ADV7180_CVBS_IN_DET pin fail!\n");
return -1;
}
gpio_direction_input(ADV7180_CVBS_IN_DET);
ret = gpio_request(ADV7180_YCRCB_IN_DET, "ADV_YCRCB_INT");
if (ret != 0)
{
gpio_free(ADV7180_YCRCB_IN_DET);
printk(KERN_ERR "request ADV7180_YCRCB_IN_DET pin fail!\n");
return -1;
}
gpio_direction_input(ADV7180_YCRCB_IN_DET);
state->cvbs_irq = gpio_to_irq(ADV7180_CVBS_IN_DET);
state->ycrcb_irq = gpio_to_irq(ADV7180_YCRCB_IN_DET);
INIT_WORK(&state->cvbs_work, adv7180_cvbs_work);
INIT_WORK(&state->ycrcb_work, adv7180_ycrcb_work);
mutex_init(&state->mutex);
state->autodetect = true;
sd = &state->sd;
v4l2_i2c_subdev_init(sd, client, &adv7180_ops);
state->icd = icd;
icd->ops = &adv7180_sensor_ops;
icd->user_width = adv7180_pic_sizes[0].width;
icd->user_height = adv7180_pic_sizes[0].height;
icd->colorspace = adv7180_colour_fmts[0].colorspace;
adv7180_pwr_ctl(icd, 1);
ret = 0;
printk("%s %d\n", __func__, __LINE__);
ret = i2c_smbus_read_byte_data(client, ADV7180_IDENT_REG);
/*
if (ret != ADV7180_ID_7180)
goto err_unreg_subdev;
*/
printk("%s %d\n", __func__, __LINE__);
ret = i2c_smbus_write_byte_data(client, 0x1d, 0x00); /* 27M/28M crystal */
int i;
if(gpio_get_value(ADV7180_YCRCB_IN_DET)==GPIO_LOW) {
printk("adv7180 ycrcb init\n");
for(i=0; i<15; i++)
i2c_smbus_write_byte_data(client, init_ycrcb[i].reg, init_ycrcb[i].val);
} else {
printk("adv7180 cvbs init\n");
for(i=0; i<15; i++)
i2c_smbus_write_byte_data(client, init_cvbs[i].reg, init_cvbs[i].val);
}
#if 0
/* register for interrupts */
if (state->irq > 0) {
ret = request_irq(state->irq, adv7180_irq, 0, DRIVER_NAME,
state);
if (ret)
goto err_unreg_subdev;
printk("%s %d\n", __func__, __LINE__);
ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
ADV7180_ADI_CTRL_IRQ_SPACE);
if (ret < 0)
goto err_unreg_subdev;
printk("%s %d\n", __func__, __LINE__);
/* config the Interrupt pin to be active low */
ret = i2c_smbus_write_byte_data(client, ADV7180_ICONF1_ADI,
ADV7180_ICONF1_ACTIVE_LOW | ADV7180_ICONF1_PSYNC_ONLY);
if (ret < 0)
goto err_unreg_subdev;
printk("%s %d\n", __func__, __LINE__);
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR1_ADI, 0);
if (ret < 0)
goto err_unreg_subdev;
printk("%s %d\n", __func__, __LINE__);
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR2_ADI, 0);
if (ret < 0)
goto err_unreg_subdev;
printk("%s %d\n", __func__, __LINE__);
/* enable AD change interrupts interrupts */
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR3_ADI,
ADV7180_IRQ3_AD_CHANGE);
if (ret < 0)
goto err_unreg_subdev;
printk("%s %d\n", __func__, __LINE__);
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR4_ADI, 0);
if (ret < 0)
goto err_unreg_subdev;
printk("%s %d\n", __func__, __LINE__);
ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
0);
if (ret < 0)
goto err_unreg_subdev;
printk("%s %d\n", __func__, __LINE__);
}
#endif
adv7180_pwr_ctl(icd, 0);
ret = device_create_file(&client->dev, &adv7180_dev_attr);
if (ret) {
printk("create device file failed!\n");
}
v4l_info(client, "chip probe success @ 0x%02x (%s)\n",
client->addr << 1, client->adapter->name);
return 0;
err_unreg_subdev:
adv7180_pwr_ctl(icd, 0);
mutex_destroy(&state->mutex);
v4l2_device_unregister_subdev(sd);
kfree(state);
err:
printk(KERN_ERR DRIVER_NAME ": Failed to probe: %d\n", ret);
return ret;
}
static int mxc6225_init_platform_hw(void)
{
rk30_mux_api_set(GPIO1B1_SPI_TXD_UART1_SOUT_NAME, GPIO1B_GPIO1B1);
return 0;
}
