static int __init rk29sdk_wifi_bt_gpio_control_init(void)
{
rk29sdk_init_wifi_mem();
rk29_mux_api_set(rk_platform_wifi_gpio.power_n.iomux.name, rk_platform_wifi_gpio.power_n.iomux.fgpio);
if (rk_platform_wifi_gpio.power_n.io != INVALID_GPIO) {
if (gpio_request(rk_platform_wifi_gpio.power_n.io, "wifi_power")) {
pr_info("%s: request wifi power gpio failed\n", __func__);
return -1;
}
}
#ifdef RK30SDK_WIFI_GPIO_RESET_N
if (rk_platform_wifi_gpio.reset_n.io != INVALID_GPIO) {
if (gpio_request(rk_platform_wifi_gpio.reset_n.io, "wifi reset")) {
pr_info("%s: request wifi reset gpio failed\n", __func__);
gpio_free(rk_platform_wifi_gpio.power_n.io);
return -1;
}
}
#endif
if (rk_platform_wifi_gpio.power_n.io != INVALID_GPIO)
gpio_direction_output(rk_platform_wifi_gpio.power_n.io, !(rk_platform_wifi_gpio.power_n.enable) );
#ifdef RK30SDK_WIFI_GPIO_RESET_N
if (rk_platform_wifi_gpio.reset_n.io != INVALID_GPIO)
gpio_direction_output(rk_platform_wifi_gpio.reset_n.io, !(rk_platform_wifi_gpio.reset_n.enable) );
#endif
#if defined(CONFIG_SDMMC1_RK29) && !defined(CONFIG_SDMMC_RK29_OLD)
#if !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
rk29_sdmmc_gpio_open(1, 0); //added by xbw at 2011-10-13
#endif
pr_info("%s: init finished\n",__func__);
return 0;
}
static int rk29_uart_to_gpio(int uart_id)
{
if(uart_id == 3) {
rk29_mux_api_set(GPIO2B3_UART3SOUT_NAME, GPIO2L_GPIO2B3);
rk29_mux_api_set(GPIO2B2_UART3SIN_NAME, GPIO2L_GPIO2B2);
gpio_request(RK29_PIN2_PB3, NULL);
gpio_request(RK29_PIN2_PB2, NULL);
gpio_direction_output(RK29_PIN2_PB3, GPIO_LOW);
gpio_direction_output(RK29_PIN2_PB2, GPIO_LOW);
}
else if(uart_id == 2) {
rk29_mux_api_set(GPIO2B1_UART2SOUT_NAME, GPIO2L_GPIO2B1);
rk29_mux_api_set(GPIO2B0_UART2SIN_NAME, GPIO2L_GPIO2B0);
gpio_request(RK29_PIN2_PB1, NULL);
gpio_request(RK29_PIN2_PB0, NULL);
gpio_direction_output(RK29_PIN2_PB1, GPIO_LOW);
gpio_direction_output(RK29_PIN2_PB0, GPIO_LOW);
}
else if(uart_id == 1) {
rk29_mux_api_set(GPIO2A5_UART1SOUT_NAME, GPIO2L_GPIO2A5);
rk29_mux_api_set(GPIO2A4_UART1SIN_NAME, GPIO2L_GPIO2A4);
gpio_request(RK29_PIN2_PA5, NULL);
gpio_request(RK29_PIN2_PA4, NULL);
gpio_direction_output(RK29_PIN2_PA5, GPIO_LOW);
gpio_direction_output(RK29_PIN2_PA4, GPIO_LOW);
}
else if(uart_id == 0){
rk29_mux_api_set(GPIO1B7_UART0SOUT_NAME, GPIO1L_GPIO1B7);
gpio_request(RK29_PIN1_PB7, NULL);
gpio_direction_output(RK29_PIN1_PB7,GPIO_LOW);
gpio_pull_updown(RK29_PIN1_PB7, PullDisable); // 下拉禁止
rk29_mux_api_set(GPIO1B6_UART0SIN_NAME, GPIO1L_GPIO1B6);
gpio_request(RK29_PIN1_PB6, NULL);
gpio_direction_output(RK29_PIN1_PB6,GPIO_LOW);
gpio_pull_updown(RK29_PIN1_PB6, PullDisable); // 下拉禁止
rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_GPIO1C1);
gpio_request(RK29_PIN1_PC1, NULL);
gpio_direction_output(RK29_PIN1_PC1,GPIO_LOW);
rk29_mux_api_set(GPIO1C0_UART0CTSN_SDMMC1DETECTN_NAME, GPIO1H_GPIO1C0);
gpio_request(RK29_PIN1_PC0, NULL);
//gpio_direction_input(RK29_PIN1_PC0);
gpio_direction_output(RK29_PIN1_PC0,GPIO_LOW);
}
return 0;
}
static int __init rk29sdk_wifi_bt_gpio_control_init(void)
{
rk29sdk_init_wifi_mem();
#if 0
rk29_mux_api_set(GPIO3D0_SDMMC1PWREN_NAME, GPIO3D_GPIO3D0);
if (gpio_request(RK30SDK_WIFI_GPIO_POWER_N, "wifi_power")) {
pr_info("%s: request wifi power gpio failed\n", __func__);
return -1;
}
/*if (gpio_request(RK29SDK_WIFI_GPIO_RESET_N, "wifi reset")) {
pr_info("%s: request wifi reset gpio failed\n", __func__);
gpio_free(RK30SDK_WIFI_GPIO_POWER_N);
return -1;
}
if (gpio_request(RK29SDK_BT_GPIO_RESET_N, "bt reset")) {
pr_info("%s: request bt reset gpio failed\n", __func__);
gpio_free(RK29SDK_WIFI_GPIO_RESET_N);
return -1;
}*/
gpio_direction_output(RK30SDK_WIFI_GPIO_POWER_N, GPIO_LOW);
//gpio_direction_output(RK29SDK_WIFI_GPIO_RESET_N, GPIO_LOW);
//gpio_direction_output(RK29SDK_BT_GPIO_RESET_N, GPIO_LOW);
#endif
#if defined(CONFIG_SDMMC1_RK29) && !defined(CONFIG_SDMMC_RK29_OLD)
rk29_mux_api_set(GPIO3C2_SDMMC1DATA1_NAME, GPIO3C_GPIO3C2);
gpio_request(RK30_PIN3_PC2, "mmc1-data1");
gpio_direction_output(RK30_PIN3_PC2,GPIO_LOW);//set mmc1-data1 to low.
rk29_mux_api_set(GPIO3C3_SDMMC1DATA2_NAME, GPIO3C_GPIO3C3);
gpio_request(RK30_PIN3_PC3, "mmc1-data2");
gpio_direction_output(RK30_PIN3_PC3,GPIO_LOW);//set mmc1-data2 to low.
rk29_mux_api_set(GPIO3C4_SDMMC1DATA3_NAME, GPIO3C_GPIO3C4);
gpio_request(RK30_PIN3_PC4, "mmc1-data3");
gpio_direction_output(RK30_PIN3_PC4,GPIO_LOW);//set mmc1-data3 to low.
rk29_sdmmc_gpio_open(1, 0); //added by xbw at 2011-10-13
#endif
pr_info("%s: init finished\n",__func__);
return 0;
}
static void screen_set_iomux(u8 enable)
{
int ret=-1;
if(enable)
{
rk29_mux_api_set(GPIOH6_IQ_SEL_NAME, 0);
ret = gpio_request(RK29_PIN_PH6, NULL);
if(0)//(ret != 0)
{
gpio_free(RK29_PIN_PH6);
printk(">>>>>> lcd cs gpio_request err \n ");
goto pin_err;
}
rk29_mux_api_set(GPIOE_I2C0_SEL_NAME, 1);
ret = gpio_request(RK29_PIN_PE5, NULL);
if(0)//(ret != 0)
{
gpio_free(RK29_PIN_PE5);
printk(">>>>>> lcd clk gpio_request err \n ");
goto pin_err;
}
ret = gpio_request(RK29_PIN_PE4, NULL);
if(0)//(ret != 0)
{
gpio_free(RK29_PIN_PE4);
printk(">>>>>> lcd txd gpio_request err \n ");
goto pin_err;
}
}
else
{
gpio_free(RK29_PIN_PH6);
// rk29_mux_api_set(CXGPIO_HSADC_SEL_NAME, 1);
gpio_free(RK29_PIN_PE5);
gpio_free(RK29_PIN_PE4);
rk29_mux_api_set(GPIOE_I2C0_SEL_NAME, 0);
}
return ;
pin_err:
return ;
}
static int rk1000_control_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret;
struct clk *iis_clk;
struct rkdisplay_platform_data *tv_data;
/* reg[0x00] = 0x88, --> ADC_CON
reg[0x01] = 0x0d, --> CODEC_CON
reg[0x02] = 0x22, --> I2C_CON
reg[0x03] = 0x00, --> TVE_CON
*/
char data[4] = {0x88, 0x0d, 0x22, 0x00};
printk("rk1000_control_probe\n");
iis_clk = clk_get_sys("rk29_i2s.0", "i2s");
if (IS_ERR(iis_clk)) {
printk("failed to get i2s clk\n");
ret = PTR_ERR(iis_clk);
}else{
DBG("got i2s clk ok!\n");
clk_enable(iis_clk);
clk_set_rate(iis_clk, 11289600);
#ifdef CONFIG_ARCH_RK29
rk29_mux_api_set(GPIO2D0_I2S0CLK_MIIRXCLKIN_NAME, GPIO2H_I2S0_CLK);
#else
rk30_mux_api_set(GPIO0B0_I2S8CHCLK_NAME, GPIO0B_I2S_8CH_CLK);
#endif
clk_put(iis_clk);
}
if(client->dev.platform_data) {
tv_data = client->dev.platform_data;
if(tv_data->io_reset_pin != INVALID_GPIO) {
ret = gpio_request(tv_data->io_reset_pin, "rk1000 reset");
if (ret){
printk("rk1000_control_probe request gpio fail\n");
//goto err1;
}
gpio_set_value(tv_data->io_reset_pin, GPIO_LOW);
gpio_direction_output(tv_data->io_reset_pin, GPIO_LOW);
mdelay(2);
gpio_set_value(tv_data->io_reset_pin, GPIO_HIGH);
}
}
rk1000_control_client = client;
#ifdef CONFIG_SND_SOC_RK1000
data[1] = 0x00;
#endif
ret = i2c_master_reg8_send(client,0,data, 4, 20 * 1000);
printk("rk1000_control_probe ok\n");
return 0;
}
static int rk29_gpio_to_uart(int uart_id)
{
if(uart_id == 3) {
rk29_mux_api_set(GPIO2B3_UART3SOUT_NAME, GPIO2L_UART3_SOUT);
rk29_mux_api_set(GPIO2B2_UART3SIN_NAME, GPIO2L_UART3_SIN);
gpio_request(RK29_PIN2_PB3, NULL);
gpio_request(RK29_PIN2_PB2, NULL);
gpio_direction_output(RK29_PIN2_PB3, GPIO_HIGH);
gpio_direction_output(RK29_PIN2_PB2, GPIO_HIGH);
}
else if(uart_id == 2) {
rk29_mux_api_set(GPIO2B1_UART2SOUT_NAME, GPIO2L_UART2_SOUT);
rk29_mux_api_set(GPIO2B0_UART2SIN_NAME, GPIO2L_UART2_SIN);
gpio_request(RK29_PIN2_PB1, NULL);
gpio_request(RK29_PIN2_PB0, NULL);
gpio_direction_output(RK29_PIN2_PB1, GPIO_HIGH);
gpio_direction_output(RK29_PIN2_PB0, GPIO_HIGH);
}
else if(uart_id == 1) {
rk29_mux_api_set(GPIO2A5_UART1SOUT_NAME, GPIO2L_UART1_SOUT);
rk29_mux_api_set(GPIO2A4_UART1SIN_NAME, GPIO2L_UART1_SIN);
gpio_request(RK29_PIN2_PA5, NULL);
gpio_request(RK29_PIN2_PA4, NULL);
gpio_direction_output(RK29_PIN2_PA5, GPIO_HIGH);
gpio_direction_output(RK29_PIN2_PA4, GPIO_HIGH);
}
else if(uart_id == 0){
rk29_mux_api_set(GPIO1B7_UART0SOUT_NAME, GPIO1L_UART0_SOUT);
rk29_mux_api_set(GPIO1B6_UART0SIN_NAME, GPIO1L_UART0_SIN);
rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_UART0_RTS_N);
rk29_mux_api_set(GPIO1C0_UART0CTSN_SDMMC1DETECTN_NAME, GPIO1H_UART0_CTS_N);
}
return 0;
}
static int __devinit setup_pendown(struct i2c_client *client, struct gt801_ts_data *ts)
{
int err;
struct gt801_platform_data *pdata = client->dev.platform_data;
if (!client->irq) {
dev_dbg(&client->dev, "no IRQ?\n");
return -ENODEV;
}
if (!gpio_is_valid(pdata->gpio_pendown)) {
dev_err(&client->dev, "no gpio_pendown?\n");
return -EINVAL;
}
ts->gpio_pendown = pdata->gpio_pendown;
strcpy(ts->pendown_iomux_name,pdata->pendown_iomux_name);
ts->pendown_iomux_mode = pdata->pendown_iomux_mode;
gt801printk("%s=%d,%s,%d\n",__FUNCTION__,ts->gpio_pendown,ts->pendown_iomux_name,ts->pendown_iomux_mode);
if (!gpio_is_valid(ts->gpio_pendown)) {
dev_err(&client->dev, "no gpio_pendown?\n");
return -EINVAL;
}
rk29_mux_api_set(ts->pendown_iomux_name,ts->pendown_iomux_mode);
err = gpio_request(ts->gpio_pendown, "gt801_pendown");
if (err) {
dev_err(&client->dev, "failed to request pendown GPIO%d\n",
ts->gpio_pendown);
return err;
}
err = gpio_pull_updown(ts->gpio_pendown, GPIOPullUp);
if (err) {
dev_err(&client->dev, "failed to pullup pendown GPIO%d\n",
ts->gpio_pendown);
gpio_free(ts->gpio_pendown);
return err;
}
return 0;
}
static int rt5621_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct rt5621_priv *rt5621;
struct clk *iis_clk;
int ret;
printk("%s\n", __FUNCTION__);
iis_clk = clk_get_sys("rk29_i2s.0", "i2s");
if (IS_ERR(iis_clk)) {
dev_err(&i2c->dev, "failed to get i2s clk\n");
ret = PTR_ERR(iis_clk);
}else{
clk_enable(iis_clk);
clk_set_rate(iis_clk, 11289600);
clk_put(iis_clk);
}
rk29_mux_api_set(GPIO2D0_I2S0CLK_MIIRXCLKIN_NAME, GPIO2H_I2S0_CLK);
ret = rk29_rt5621_detect_device(i2c);
if(ret < 0){
printk("%s: detect alc5621 error!\n", __FUNCTION__);
return ret;
}
audio_card_init();
rt5621 = kzalloc(sizeof(struct rt5621_priv), GFP_KERNEL);
if (NULL == rt5621)
return -ENOMEM;
i2c_set_clientdata(i2c, rt5621);
ret = snd_soc_register_codec(&i2c->dev,
&soc_codec_dev_rt5621, &rt5621_dai, 1);
if (ret < 0)
kfree(rt5621);
return ret;
}
static int __devinit setup_resetPin(struct i2c_client *client, struct gt801_ts_data *ts)
{
struct gt801_platform_data *pdata = client->dev.platform_data;
int err;
ts->gpio_reset = pdata->gpio_reset;
ts->gpio_reset_active_low = pdata->gpio_reset_active_low;
ts->resetpin_iomux_mode = pdata->resetpin_iomux_mode;
if(pdata->resetpin_iomux_name != NULL)
strcpy(ts->resetpin_iomux_name,pdata->resetpin_iomux_name);
gt801printk("%s=%d,%s,%d,%d\n",__FUNCTION__,ts->gpio_reset,ts->resetpin_iomux_name,ts->resetpin_iomux_mode,ts->gpio_reset_active_low);
if (!gpio_is_valid(ts->gpio_reset)) {
dev_err(&client->dev, "no gpio_reset?\n");
return -EINVAL;
}
rk29_mux_api_set(ts->resetpin_iomux_name,ts->resetpin_iomux_mode);
err = gpio_request(ts->gpio_reset, "gt801_resetPin");
if (err) {
dev_err(&client->dev, "failed to request resetPin GPIO%d\n",
ts->gpio_reset);
return err;
}
err = gpio_direction_output(ts->gpio_reset, ts->gpio_reset_active_low? GPIO_LOW:GPIO_HIGH);
if (err) {
dev_err(&client->dev, "failed to pulldown resetPin GPIO%d,err%d\n",
ts->gpio_reset,err);
gpio_free(ts->gpio_reset);
return err;
}
mdelay(100);
gpio_set_value(ts->gpio_reset, ts->gpio_reset_active_low? GPIO_HIGH:GPIO_LOW);
mdelay(100);
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 rk29sdk_wifi_bt_gpio_control_init(void)
{
rk29sdk_init_wifi_mem();
#if !(!!SDMMC_USE_NEW_IOMUX_API)
rk29_mux_api_set(rk_platform_wifi_gpio.power_n.iomux.name, rk_platform_wifi_gpio.power_n.iomux.fgpio);
#endif
#ifdef CONFIG_MACH_RK_FAC
if(wifi_pwr!=-1)
port_output_init(wifi_pwr, 1, "wifi_pwr");
#else
if (rk_platform_wifi_gpio.power_n.io != INVALID_GPIO) {
if (gpio_request(rk_platform_wifi_gpio.power_n.io, "wifi_power")) {
pr_info("%s: request wifi power gpio failed\n", __func__);
return -1;
}
}
#endif
#ifdef RK30SDK_WIFI_GPIO_RESET_N
if (rk_platform_wifi_gpio.reset_n.io != INVALID_GPIO) {
if (gpio_request(rk_platform_wifi_gpio.reset_n.io, "wifi reset")) {
pr_info("%s: request wifi reset gpio failed\n", __func__);
gpio_free(rk_platform_wifi_gpio.power_n.io);
return -1;
}
}
#endif
#ifdef CONFIG_MACH_RK_FAC
if(wifi_pwr!=-1)
port_output_off(wifi_pwr);
#else
if (rk_platform_wifi_gpio.power_n.io != INVALID_GPIO)
gpio_direction_output(rk_platform_wifi_gpio.power_n.io, !(rk_platform_wifi_gpio.power_n.enable) );
#endif
#ifdef RK30SDK_WIFI_GPIO_RESET_N
if (rk_platform_wifi_gpio.reset_n.io != INVALID_GPIO)
gpio_direction_output(rk_platform_wifi_gpio.reset_n.io, !(rk_platform_wifi_gpio.reset_n.enable) );
#endif
#if defined(CONFIG_ARCH_RK319X)|| defined(CONFIG_USE_SDMMC0_FOR_WIFI_DEVELOP_BOARD)
//////////////////////////////////////////////////////////////////////////////////////////
//mmc0--used for Wifi; mmc1--used for sd-card in project RK3190
gpio_request(rksdmmc0_gpio_init.data1_gpio.io, "mmc0-data1");
gpio_direction_output(rksdmmc0_gpio_init.data1_gpio.io,GPIO_LOW);//set mmc1-data1 to low.
gpio_request(rksdmmc1_gpio_init.data2_gpio.io, "mmc0-data2");
gpio_direction_output(rksdmmc1_gpio_init.data2_gpio.io,GPIO_LOW);//set mmc1-data2 to low.
gpio_request(rksdmmc0_gpio_init.data3_gpio.io, "mmc0-data3");
gpio_direction_output(rksdmmc0_gpio_init.data3_gpio.io,GPIO_LOW);//set mmc1-data3 to low.
rk29_sdmmc_gpio_open(0, 0);
printk("%d..%s ====test ===\n",__LINE__, __FUNCTION__);
//////////////////////////////////////////////////////////////////////////////////////////
#else //--#if defined(CONFIG_ARCH_RK319X)
#if defined(CONFIG_SDMMC1_RK29) && !defined(CONFIG_SDMMC_RK29_OLD)
#if !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
rk29_sdmmc_gpio_open(1, 0); //added by xbw at 2011-10-13
#endif
#endif//--#else //--#if defined(CONFIG_ARCH_RK319X)
pr_info("%s: init finished\n",__func__);
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;
}
static int ft5x0x_chip_init(struct i2c_client * client)
{
int ret = 0;
int w_value;
char r_value;
int err = -1;
int reg;
int i = 0, flag = 1;
struct ft5x0x_data *ft5x0x_ts = i2c_get_clientdata(client);
gpio_free(ft5x0x_ts->reset_gpio);
err = gpio_request(ft5x0x_ts->reset_gpio, "ft5x0x rst");
if (err) {
DBG( "failed to request ft5x0x reset GPIO%d\n", ft5x0x_ts->reset_gpio);
goto exit_alloc_gpio_rst_failed;
}
#if defined (TOUCH_POWER_PIN)
#if defined (TOUCH_POWER_MUX_NAME)
rk29_mux_api_set(TOUCH_POWER_MUX_NAME, TOUCH_POWER_MUX_MODE_GPIO);
#endif
gpio_free(ft5x0x_ts->touch_en_gpio);
err = gpio_request(ft5x0x_ts->touch_en_gpio, "ft5x0x power enable");
if (err) {
DBG( "failed to request ft5x0x power enable GPIO%d\n", ft5x0x_ts->touch_en_gpio);
goto exit_alloc_gpio_power_failed;
}
#endif
//ft5x0x_chip_reset(ft5x0x_ts);
gpio_direction_output(ft5x0x_ts->reset_gpio, 1);
gpio_set_value(ft5x0x_ts->reset_gpio, 1);
ft5x0x_power_en(ft5x0x_ts, 0);
mdelay(50);
ft5x0x_power_en(ft5x0x_ts, 1);
mdelay(500);
ft_cmd_write(0x07,0x00,0x00,0x00,1);
mdelay(10);
ret = ft5x0x_read_reg(client, 0xA8);//read touchpad ID for adjust touchkey place
if (ret < 0) {
printk(KERN_ERR "ft5x0x i2c rxdata failed\n");
//goto out;
}
printk("ft5406 g_vid = 0x%X\n", ret);
g_vid = ret;
#if 0
reg = 0x88;
w_value = 4;
ret = ft5x0x_write_reg(client, reg, w_value); /* adjust sensitivity */
if (ret < 0) {
printk(KERN_ERR "ft5x0x i2c txdata failed\n");
}
#endif
#if 1
while (1) {
reg = 0x88;
w_value = 7;
ret = ft5x0x_write_reg(client, reg, w_value); /* adjust frequency 70Hz */
if (ret < 0) {
printk(KERN_ERR "ft5x0x i2c txdata failed\n");
//goto out;
}
r_value = ft5x0x_read_reg(client, reg);
if (ret < 0) {
printk(KERN_ERR "ft5x0x i2c rxdata failed\n");
//goto out;
}
printk("r_value = %d\n, i = %d, flag = %d", r_value, i, flag);
i++;
if (w_value != r_value) {
ret = -1;
flag = 0;
if (i > 5) { /* test 5 count */
break;
}
} else {
ret = 0;
break;
}
}
#endif
return ret;
exit_alloc_gpio_power_failed:
#if defined (TOUCH_POWER_PIN)
gpio_free(ft5x0x_ts->touch_en_gpio);
#endif
exit_alloc_gpio_rst_failed:
gpio_free(ft5x0x_ts->reset_gpio);
printk("%s error\n",__FUNCTION__);
return err;
}
static __devinit int wm8994_ldo_probe(struct platform_device *pdev)
{
struct wm8994 *wm8994 = dev_get_drvdata(pdev->dev.parent);
struct wm8994_pdata *pdata = wm8994->dev->platform_data;
int id = pdev->id % ARRAY_SIZE(pdata->ldo);
struct wm8994_ldo *ldo;
int ret;
dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
if (!pdata)
return -ENODEV;
ldo = kzalloc(sizeof(struct wm8994_ldo), GFP_KERNEL);
if (ldo == NULL) {
dev_err(&pdev->dev, "Unable to allocate private data\n");
return -ENOMEM;
}
ldo->wm8994 = wm8994;
if(pdata->ldo[id].iomux_name != NULL)
rk29_mux_api_set(pdata->ldo[id].iomux_name, pdata->ldo[id].iomux_mode);
if (pdata->ldo[id].enable && gpio_is_valid(pdata->ldo[id].enable)) {
ldo->enable = pdata->ldo[id].enable;
ldo->is_enabled = true;
ret = gpio_request(ldo->enable, "WM8994 LDO enable");
if (ret < 0) {
dev_err(&pdev->dev, "Failed to get enable GPIO: %d\n",
ret);
goto err;
}
ret = gpio_direction_output(ldo->enable, ldo->is_enabled);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to set GPIO up: %d\n",
ret);
goto err_gpio;
}
msleep(50);
} else
ldo->is_enabled = true;
ldo->regulator = regulator_register(&wm8994_ldo_desc[id], &pdev->dev,
pdata->ldo[id].init_data, ldo);
if (IS_ERR(ldo->regulator)) {
ret = PTR_ERR(ldo->regulator);
dev_err(wm8994->dev, "Failed to register LDO%d: %d\n",
id + 1, ret);
goto err_gpio;
}
platform_set_drvdata(pdev, ldo);
return 0;
err_gpio:
if (gpio_is_valid(ldo->enable))
gpio_free(ldo->enable);
err:
kfree(ldo);
return ret;
}
static int goodix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret = 0;
int retry=0;
struct gt818_ts_data *ts;
struct gt818_platform_data *pdata;
dev_info(&client->dev,"Install touch driver.\n");
printk("gt818: Install touch driver.\n");
//Check I2C function
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
{
dev_err(&client->dev, "Must have I2C_FUNC_I2C.\n");
ret = -ENODEV;
goto err_check_functionality_failed;
}
ts = kzalloc(sizeof(*ts), GFP_KERNEL);
if (ts == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
i2c_connect_client = client; //used by Guitar_Update
pdata = client->dev.platform_data;
ts->client = client;
i2c_set_clientdata(client, ts);
//init int and reset ports
ret = gpio_request(pdata->gpio_pendown, "TS_INT"); //Request IO
if (ret){
dev_err(&client->dev, "Failed to request GPIO:%d, ERRNO:%d\n",(int)pdata->gpio_pendown, ret);
goto err_gpio_request_failed;
}
rk29_mux_api_set(pdata->pendown_iomux_name, pdata->pendown_iomux_mode);
gpio_direction_input(pdata->gpio_pendown);
gpio_pull_updown(pdata->gpio_pendown, 0);
ret = gpio_request(pdata->gpio_reset, "gt818_resetPin");
if(ret){
dev_err(&client->dev, "failed to request resetPin GPIO%d\n", pdata->gpio_reset);
goto err_gpio_request_failed;
}
rk29_mux_api_set(pdata->resetpin_iomux_name, pdata->resetpin_iomux_mode);
#if 1
for(retry = 0; retry < 4; retry++)
{
gpio_pull_updown(pdata->gpio_reset, 1);
gpio_direction_output(pdata->gpio_reset, 0);
msleep(1); //delay at least 1ms
gpio_direction_input(pdata->gpio_reset);
gpio_pull_updown(pdata->gpio_reset, 0);
msleep(25); //delay at least 20ms
ret = i2c_pre_cmd(ts);
if (ret > 0)
break;
msleep(50);
}
if(ret <= 0)
{
dev_err(&client->dev, "Warnning: I2C communication might be ERROR!\n");
goto err_i2c_failed;
}
#endif
for(retry = 0; retry < 3; retry++)
{
ret = goodix_init_panel(ts);
dev_info(&client->dev,"the config ret is :%d\n", ret);
msleep(20);
if(ret < 0) //Initiall failed
continue;
else
break;
}
if(ret < 0) {
ts->bad_data = 1;
goto err_init_godix_ts;
}
goodix_read_version(ts);
INIT_WORK(&ts->work, goodix_ts_work_func); //init work_struct
ts->input_dev = input_allocate_device();
if (ts->input_dev == NULL) {
ret = -ENOMEM;
dev_dbg(&client->dev,"goodix_ts_probe: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
//ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;
//ts->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
//ts->input_dev->absbit[0] = BIT_MASK(ABS_MT_POSITION_X) | BIT_MASK(ABS_MT_POSITION_Y) |
// BIT_MASK(ABS_MT_TOUCH_MAJOR) | BIT_MASK(ABS_MT_WIDTH_MAJOR); // for android
#ifdef HAVE_TOUCH_KEY
for(retry = 0; retry < MAX_KEY_NUM; retry++)
{
input_set_capability(ts->input_dev, EV_KEY, gt818_key_array[retry]);
}
#endif
snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&client->dev));
snprintf(ts->name, sizeof(ts->name), "gt818-touchscreen");
ts->input_dev->name = "gt818_ts";//ts->name;
ts->input_dev->phys = ts->phys;
ts->input_dev->dev.parent = &client->dev;
ts->input_dev->id.bustype = BUS_I2C;
ts->input_dev->id.vendor = 0xDEAD;
ts->input_dev->id.product = 0xBEEF;
ts->input_dev->id.version = 10427; //screen firmware version
__set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
__set_bit(EV_ABS, ts->input_dev->evbit);
#ifdef GOODIX_MULTI_TOUCH
input_mt_init_slots(ts->input_dev, MAX_FINGER_NUM);
//input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, SCREEN_MAX_WIDTH, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, SCREEN_MAX_HEIGHT, 0, 0);
//input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, MAX_FINGER_NUM, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
#else
input_set_abs_params(ts->input_dev, ABS_X, 0, SCREEN_MAX_HEIGHT, 0, 0);
input_set_abs_params(ts->input_dev, ABS_Y, 0, SCREEN_MAX_WIDTH, 0, 0);
input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, 0, 0);
#endif
ret = input_register_device(ts->input_dev);
if (ret) {
dev_err(&client->dev,"Probe: Unable to register %s input device\n", ts->input_dev->name);
goto err_input_register_device_failed;
}
ts->bad_data = 0;
// 16finger_list.length = 0;
client->irq = gpio_to_irq(pdata->gpio_pendown); //If not defined in client
if (client->irq)
{
#if INT_TRIGGER==0
#define GT801_PLUS_IRQ_TYPE IRQ_TYPE_EDGE_RISING
#elif INT_TRIGGER==1
#define GT801_PLUS_IRQ_TYPE IRQ_TYPE_EDGE_FALLING
#elif INT_TRIGGER==2
#define GT801_PLUS_IRQ_TYPE IRQ_TYPE_LEVEL_LOW
#elif INT_TRIGGER==3
#define GT801_PLUS_IRQ_TYPE IRQ_TYPE_LEVEL_HIGH
#endif
ret = request_irq(client->irq, goodix_ts_irq_handler, GT801_PLUS_IRQ_TYPE,
client->name, ts);
if (ret != 0) {
dev_err(&client->dev,"Cannot allocate ts INT!ERRNO:%d\n", ret);
gpio_direction_input(pdata->gpio_pendown);
gpio_free(pdata->gpio_pendown);
goto err_gpio_request_failed;
}
else
{
disable_irq(client->irq);
ts->use_irq = 1;
dev_dbg(&client->dev,"Reques EIRQ %d succesd on GPIO:%d\n", client->irq, pdata->gpio_pendown);
}
}
err_gpio_request_failed:
ts->power = goodix_ts_power;
#ifdef CONFIG_HAS_EARLYSUSPEND
ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
ts->early_suspend.suspend = goodix_ts_early_suspend;
ts->early_suspend.resume = goodix_ts_late_resume;
register_early_suspend(&ts->early_suspend);
#endif
dev_info(&client->dev,"Start %s in %s mode\n",
ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
if (ts->use_irq)
{
enable_irq(client->irq);
}
else
{
hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
ts->timer.function = goodix_ts_timer_func;
hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
}
i2c_end_cmd(ts);
return 0;
err_init_godix_ts:
i2c_end_cmd(ts);
if(ts->use_irq)
{
ts->use_irq = 0;
free_irq(client->irq,ts);
gpio_direction_input(pdata->gpio_pendown);
gpio_free(pdata->gpio_pendown);
}
else
hrtimer_cancel(&ts->timer);
err_input_register_device_failed:
input_free_device(ts->input_dev);
err_input_dev_alloc_failed:
i2c_set_clientdata(client, NULL);
err_i2c_failed:
kfree(ts);
err_alloc_data_failed:
err_check_functionality_failed:
return ret;
}
static int rk_sensor_iomux(int pin)
{
switch (pin)
{
case RK29_PIN0_PA0:
case RK29_PIN0_PA1:
case RK29_PIN0_PA2:
case RK29_PIN0_PA3:
case RK29_PIN0_PA4:
{
break;
}
case RK29_PIN0_PA5:
{
rk29_mux_api_set(GPIO0A5_FLASHDQS_NAME,0);
break;
}
case RK29_PIN0_PA6:
{
rk29_mux_api_set(GPIO0A6_MIIMD_NAME,0);
break;
}
case RK29_PIN0_PA7:
{
rk29_mux_api_set(GPIO0A7_MIIMDCLK_NAME,0);
break;
}
case RK29_PIN0_PB0:
{
rk29_mux_api_set(GPIO0B0_EBCSDCE0_SMCADDR0_HOSTDATA0_NAME,0);
break;
}
case RK29_PIN0_PB1:
{
rk29_mux_api_set(GPIO0B1_EBCSDCE1_SMCADDR1_HOSTDATA1_NAME,0);
break;
}
case RK29_PIN0_PB2:
{
rk29_mux_api_set(GPIO0B2_EBCSDCE2_SMCADDR2_HOSTDATA2_NAME,0);
break;
}
case RK29_PIN0_PB3:
{
rk29_mux_api_set(GPIO0B3_EBCBORDER0_SMCADDR3_HOSTDATA3_NAME,0);
break;
}
case RK29_PIN0_PB4:
{
rk29_mux_api_set(GPIO0B4_EBCBORDER1_SMCWEN_NAME,0);
break;
}
case RK29_PIN0_PB5:
{
rk29_mux_api_set(GPIO0B5_EBCVCOM_SMCBLSN0_NAME,0);
break;
}
case RK29_PIN0_PB6:
{
rk29_mux_api_set(GPIO0B6_EBCSDSHR_SMCBLSN1_HOSTINT_NAME,0);
break;
}
case RK29_PIN0_PB7:
{
rk29_mux_api_set(GPIO0B7_EBCGDOE_SMCOEN_NAME,0);
break;
}
case RK29_PIN0_PC0:
{
rk29_mux_api_set(GPIO0C0_EBCGDSP_SMCDATA8_NAME,0);
break;
}
case RK29_PIN0_PC1:
{
rk29_mux_api_set(GPIO0C1_EBCGDR1_SMCDATA9_NAME,0);
break;
}
case RK29_PIN0_PC2:
{
rk29_mux_api_set(GPIO0C2_EBCSDCE0_SMCDATA10_NAME,0);
break;
}
case RK29_PIN0_PC3:
{
rk29_mux_api_set(GPIO0C3_EBCSDCE1_SMCDATA11_NAME,0);
break;
}
case RK29_PIN0_PC4:
{
rk29_mux_api_set(GPIO0C4_EBCSDCE2_SMCDATA12_NAME,0);
break;
}
case RK29_PIN0_PC5:
{
rk29_mux_api_set(GPIO0C5_EBCSDCE3_SMCDATA13_NAME,0);
break;
}
case RK29_PIN0_PC6:
{
rk29_mux_api_set(GPIO0C6_EBCSDCE4_SMCDATA14_NAME,0);
break;
}
case RK29_PIN0_PC7:
{
rk29_mux_api_set(GPIO0C7_EBCSDCE5_SMCDATA15_NAME,0);
break;
}
case RK29_PIN0_PD0:
{
rk29_mux_api_set(GPIO0D0_EBCSDOE_SMCADVN_NAME,0);
break;
}
case RK29_PIN0_PD1:
{
rk29_mux_api_set(GPIO0D1_EBCGDCLK_SMCADDR4_HOSTDATA4_NAME,0);
break;
}
case RK29_PIN0_PD2:
{
rk29_mux_api_set(GPIO0D2_FLASHCSN1_NAME,0);
break;
}
case RK29_PIN0_PD3:
{
rk29_mux_api_set(GPIO0D3_FLASHCSN2_NAME,0);
break;
}
case RK29_PIN0_PD4:
{
rk29_mux_api_set(GPIO0D4_FLASHCSN3_NAME,0);
break;
}
case RK29_PIN0_PD5:
{
rk29_mux_api_set(GPIO0D5_FLASHCSN4_NAME,0);
break;
}
case RK29_PIN0_PD6:
{
rk29_mux_api_set(GPIO0D6_FLASHCSN5_NAME,0);
break;
}
case RK29_PIN0_PD7:
{
rk29_mux_api_set(GPIO0D7_FLASHCSN6_NAME,0);
break;
}
case RK29_PIN1_PA0:
{
rk29_mux_api_set(GPIO1A0_FLASHCS7_MDDRTQ_NAME,0);
break;
}
case RK29_PIN1_PA1:
{
rk29_mux_api_set(GPIO1A1_SMCCSN0_NAME,0);
break;
}
case RK29_PIN1_PA2:
{
rk29_mux_api_set(GPIO1A2_SMCCSN1_NAME,0);
break;
}
case RK29_PIN1_PA3:
{
rk29_mux_api_set(GPIO1A3_EMMCDETECTN_SPI1CS1_NAME,0);
break;
}
case RK29_PIN1_PA4:
{
rk29_mux_api_set(GPIO1A4_EMMCWRITEPRT_SPI0CS1_NAME,0);
break;
}
case RK29_PIN1_PA5:
{
rk29_mux_api_set(GPIO1A5_EMMCPWREN_PWM3_NAME,0);
break;
}
case RK29_PIN1_PA6:
{
rk29_mux_api_set(GPIO1A6_I2C1SDA_NAME,0);
break;
}
case RK29_PIN1_PA7:
{
rk29_mux_api_set(GPIO1A7_I2C1SCL_NAME,0);
break;
}
case RK29_PIN1_PB0:
{
rk29_mux_api_set(GPIO1B0_VIPDATA0_NAME,0);
break;
}
case RK29_PIN1_PB1:
{
rk29_mux_api_set(GPIO1B1_VIPDATA1_NAME,0);
break;
}
case RK29_PIN1_PB2:
{
rk29_mux_api_set(GPIO1B2_VIPDATA2_NAME,0);
break;
}
case RK29_PIN1_PB3:
{
rk29_mux_api_set(GPIO1B3_VIPDATA3_NAME,0);
break;
}
case RK29_PIN1_PB4:
{
rk29_mux_api_set(GPIO1B4_VIPCLKOUT_NAME,0);
break;
}
case RK29_PIN1_PB5:
{
rk29_mux_api_set(GPIO1B5_PWM0_NAME,0);
break;
}
case RK29_PIN1_PB6:
{
rk29_mux_api_set(GPIO1B6_UART0SIN_NAME,0);
break;
}
case RK29_PIN1_PB7:
{
rk29_mux_api_set(GPIO1B7_UART0SOUT_NAME,0);
break;
}
case RK29_PIN1_PC0:
{
rk29_mux_api_set(GPIO1C0_UART0CTSN_SDMMC1DETECTN_NAME,0);
break;
}
case RK29_PIN1_PC1:
{
rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME,0);
break;
}
case RK29_PIN1_PC2:
{
rk29_mux_api_set(GPIO1C2_SDMMC1CMD_NAME,0);
break;
}
case RK29_PIN1_PC3:
{
rk29_mux_api_set(GPIO1C3_SDMMC1DATA0_NAME,0);
break;
}
case RK29_PIN1_PC4:
{
rk29_mux_api_set(GPIO1C4_SDMMC1DATA1_NAME,0);
break;
}
case RK29_PIN1_PC5:
{
rk29_mux_api_set(GPIO1C5_SDMMC1DATA2_NAME,0);
break;
}
case RK29_PIN1_PC6:
{
rk29_mux_api_set(GPIO1C6_SDMMC1DATA3_NAME,0);
break;
}
case RK29_PIN1_PC7:
{
rk29_mux_api_set(GPIO1C7_SDMMC1CLKOUT_NAME,0);
break;
}
case RK29_PIN1_PD0:
{
rk29_mux_api_set(GPIO1D0_SDMMC0CLKOUT_NAME,0);
break;
}
case RK29_PIN1_PD1:
{
rk29_mux_api_set(GPIO1D1_SDMMC0CMD_NAME,0);
break;
}
case RK29_PIN1_PD2:
{
rk29_mux_api_set(GPIO1D2_SDMMC0DATA0_NAME,0);
break;
}
case RK29_PIN1_PD3:
{
rk29_mux_api_set(GPIO1D3_SDMMC0DATA1_NAME,0);
break;
}
case RK29_PIN1_PD4:
{
rk29_mux_api_set(GPIO1D4_SDMMC0DATA2_NAME,0);
break;
}
case RK29_PIN1_PD5:
{
rk29_mux_api_set(GPIO1D5_SDMMC0DATA3_NAME,0);
break;
}
case RK29_PIN1_PD6:
{
rk29_mux_api_set(GPIO1D6_SDMMC0DATA4_NAME,0);
break;
}
case RK29_PIN1_PD7:
{
rk29_mux_api_set(GPIO1D7_SDMMC0DATA5_NAME,0);
break;
}
case RK29_PIN2_PA0:
{
rk29_mux_api_set(GPIO2A0_SDMMC0DATA6_NAME,0);
break;
}
case RK29_PIN2_PA1:
{
rk29_mux_api_set(GPIO2A1_SDMMC0DATA7_NAME,0);
break;
}
case RK29_PIN2_PA2:
{
rk29_mux_api_set(GPIO2A2_SDMMC0DETECTN_NAME,0);
break;
}
case RK29_PIN2_PA3:
{
rk29_mux_api_set(GPIO2A3_SDMMC0WRITEPRT_PWM2_NAME,0);
break;
}
case RK29_PIN2_PA4:
{
rk29_mux_api_set(GPIO2A4_UART1SIN_NAME,0);
break;
}
case RK29_PIN2_PA5:
{
rk29_mux_api_set(GPIO2A5_UART1SOUT_NAME,0);
break;
}
case RK29_PIN2_PA6:
{
rk29_mux_api_set(GPIO2A6_UART2CTSN_NAME,0);
break;
}
case RK29_PIN2_PA7:
{
rk29_mux_api_set(GPIO2A7_UART2RTSN_NAME,0);
break;
}
case RK29_PIN2_PB0:
{
rk29_mux_api_set(GPIO2B0_UART2SIN_NAME,0);
break;
}
case RK29_PIN2_PB1:
{
rk29_mux_api_set(GPIO2B1_UART2SOUT_NAME,0);
break;
}
case RK29_PIN2_PB2:
{
rk29_mux_api_set(GPIO2B2_UART3SIN_NAME,0);
break;
}
case RK29_PIN2_PB3:
{
rk29_mux_api_set(GPIO2B3_UART3SOUT_NAME,0);
break;
}
case RK29_PIN2_PB4:
{
rk29_mux_api_set(GPIO2B4_UART3CTSN_I2C3SDA_NAME,0);
break;
}
case RK29_PIN2_PB5:
{
rk29_mux_api_set(GPIO2B5_UART3RTSN_I2C3SCL_NAME,0);
break;
}
case RK29_PIN2_PB6:
{
rk29_mux_api_set(GPIO2B6_I2C0SDA_NAME,0);
break;
}
case RK29_PIN2_PB7:
{
rk29_mux_api_set(GPIO2B7_I2C0SCL_NAME,0);
break;
}
case RK29_PIN2_PC0:
{
rk29_mux_api_set(GPIO2C0_SPI0CLK_NAME,0);
break;
}
case RK29_PIN2_PC1:
{
rk29_mux_api_set(GPIO2C1_SPI0CSN0_NAME,0);
break;
}
case RK29_PIN2_PC2:
{
rk29_mux_api_set(GPIO2C2_SPI0TXD_NAME,0);
break;
}
case RK29_PIN2_PC3:
{
rk29_mux_api_set(GPIO2C3_SPI0RXD_NAME,0);
break;
}
case RK29_PIN2_PC4:
{
rk29_mux_api_set(GPIO2C4_SPI1CLK_NAME,0);
break;
}
case RK29_PIN2_PC5:
{
rk29_mux_api_set(GPIO2C5_SPI1CSN0_NAME,0);
break;
}
case RK29_PIN2_PC6:
{
rk29_mux_api_set(GPIO2C6_SPI1TXD_NAME,0);
break;
}
case RK29_PIN2_PC7:
{
rk29_mux_api_set(GPIO2C7_SPI1RXD_NAME,0);
break;
}
case RK29_PIN2_PD0:
{
rk29_mux_api_set(GPIO2D0_I2S0CLK_MIIRXCLKIN_NAME,0);
break;
}
case RK29_PIN2_PD1:
{
rk29_mux_api_set(GPIO2D1_I2S0SCLK_MIICRS_NAME,0);
break;
}
case RK29_PIN2_PD2:
{
rk29_mux_api_set(GPIO2D2_I2S0LRCKRX_MIITXERR_NAME,0);
break;
}
case RK29_PIN2_PD3:
{
rk29_mux_api_set(GPIO2D3_I2S0SDI_MIICOL_NAME,0);
break;
}
case RK29_PIN2_PD4:
{
rk29_mux_api_set(GPIO2D4_I2S0SDO0_MIIRXD2_NAME,0);
break;
}
case RK29_PIN2_PD5:
{
rk29_mux_api_set(GPIO2D5_I2S0SDO1_MIIRXD3_NAME,0);
break;
}
case RK29_PIN2_PD6:
{
rk29_mux_api_set(GPIO2D6_I2S0SDO2_MIITXD2_NAME,0);
break;
}
case RK29_PIN2_PD7:
{
rk29_mux_api_set(GPIO2D7_I2S0SDO3_MIITXD3_NAME,0);
break;
}
case RK29_PIN3_PA0:
{
rk29_mux_api_set(GPIO3A0_I2S1CLK_NAME,0);
break;
}
case RK29_PIN3_PA1:
{
rk29_mux_api_set(GPIO3A1_I2S1SCLK_NAME,0);
break;
}
case RK29_PIN3_PA2:
{
rk29_mux_api_set(GPIO3A2_I2S1LRCKRX_NAME,0);
break;
}
case RK29_PIN3_PA3:
{
rk29_mux_api_set(GPIO3A3_I2S1SDI_NAME,0);
break;
}
case RK29_PIN3_PA4:
{
rk29_mux_api_set(GPIO3A4_I2S1SDO_NAME,0);
break;
}
case RK29_PIN3_PA5:
{
rk29_mux_api_set(GPIO3A5_I2S1LRCKTX_NAME,0);
break;
}
case RK29_PIN3_PA6:
{
rk29_mux_api_set(GPIO3A6_SMCADDR14_HOSTDATA14_NAME,0);
break;
}
case RK29_PIN3_PA7:
{
rk29_mux_api_set(GPIO3A7_SMCADDR15_HOSTDATA15_NAME,0);
break;
}
case RK29_PIN3_PB0:
{
rk29_mux_api_set(GPIO3B0_EMMCLKOUT_NAME,0);
break;
}
case RK29_PIN3_PB1:
{
rk29_mux_api_set(GPIO3B1_EMMCMD_NAME,0);
break;
}
case RK29_PIN3_PB2:
{
rk29_mux_api_set(GPIO3B2_EMMCDATA0_NAME,0);
break;
}
case RK29_PIN3_PB3:
{
rk29_mux_api_set(GPIO3B3_EMMCDATA1_NAME,0);
break;
}
case RK29_PIN3_PB4:
{
rk29_mux_api_set(GPIO3B4_EMMCDATA2_NAME,0);
break;
}
case RK29_PIN3_PB5:
{
rk29_mux_api_set(GPIO3B5_EMMCDATA3_NAME,0);
break;
}
case RK29_PIN3_PB6:
{
rk29_mux_api_set(GPIO3B6_EMMCDATA4_NAME,0);
break;
}
case RK29_PIN3_PB7:
{
rk29_mux_api_set(GPIO3B7_EMMCDATA5_NAME,0);
break;
}
case RK29_PIN3_PC0:
{
rk29_mux_api_set(GPIO3C0_EMMCDATA6_NAME,0);
break;
}
case RK29_PIN3_PC1:
{
rk29_mux_api_set(GPIO3C1_EMMCDATA7_NAME,0);
break;
}
case RK29_PIN3_PC2:
{
rk29_mux_api_set(GPIO3C2_SMCADDR13_HOSTDATA13_NAME,0);
break;
}
case RK29_PIN3_PC3:
{
rk29_mux_api_set(GPIO3C3_SMCADDR10_HOSTDATA10_NAME,0);
break;
}
case RK29_PIN3_PC4:
{
rk29_mux_api_set(GPIO3C4_SMCADDR11_HOSTDATA11_NAME,0);
break;
}
case RK29_PIN3_PC5:
{
rk29_mux_api_set(GPIO3C5_SMCADDR12_HOSTDATA12_NAME,0);
break;
}
case RK29_PIN3_PC6:
{
rk29_mux_api_set(GPIO3C6_SMCADDR16_HOSTDATA16_NAME,0);
break;
}
case RK29_PIN3_PC7:
{
rk29_mux_api_set(GPIO3C7_SMCADDR17_HOSTDATA17_NAME,0);
break;
}
case RK29_PIN3_PD0:
{
rk29_mux_api_set(GPIO3D0_SMCADDR18_HOSTADDR0_NAME,0);
break;
}
case RK29_PIN3_PD1:
{
rk29_mux_api_set(GPIO3D1_SMCADDR19_HOSTADDR1_NAME,0);
break;
}
case RK29_PIN3_PD2:
{
rk29_mux_api_set(GPIO3D2_HOSTCSN_NAME,0);
break;
}
case RK29_PIN3_PD3:
{
rk29_mux_api_set(GPIO3D3_HOSTRDN_NAME,0);
break;
}
case RK29_PIN3_PD4:
{
rk29_mux_api_set(GPIO3D4_HOSTWRN_NAME,0);
break;
}
case RK29_PIN3_PD5:
{
rk29_mux_api_set(GPIO3D5_SMCADDR7_HOSTDATA7_NAME,0);
break;
}
case RK29_PIN3_PD6:
{
rk29_mux_api_set(GPIO3D6_SMCADDR8_HOSTDATA8_NAME,0);
break;
}
case RK29_PIN3_PD7:
{
rk29_mux_api_set(GPIO3D7_SMCADDR9_HOSTDATA9_NAME,0);
break;
}
case RK29_PIN4_PA0:
case RK29_PIN4_PA1:
case RK29_PIN4_PA2:
case RK29_PIN4_PA3:
case RK29_PIN4_PA4:
{
break;
}
case RK29_PIN4_PA5:
{
rk29_mux_api_set(GPIO4A5_OTG0DRVVBUS_NAME,0);
break;
}
case RK29_PIN4_PA6:
{
rk29_mux_api_set(GPIO4A6_OTG1DRVVBUS_NAME,0);
break;
}
case RK29_PIN4_PA7:
{
rk29_mux_api_set(GPIO4A7_SPDIFTX_NAME,0);
break;
}
case RK29_PIN4_PB0:
{
rk29_mux_api_set(GPIO4B0_FLASHDATA8_NAME,0);
break;
}
case RK29_PIN4_PB1:
{
rk29_mux_api_set(GPIO4B1_FLASHDATA9_NAME,0);
break;
}
case RK29_PIN4_PB2:
{
rk29_mux_api_set(GPIO4B2_FLASHDATA10_NAME,0);
break;
}
case RK29_PIN4_PB3:
{
rk29_mux_api_set(GPIO4B3_FLASHDATA11_NAME,0);
break;
}
case RK29_PIN4_PB4:
{
rk29_mux_api_set(GPIO4B4_FLASHDATA12_NAME,0);
break;
}
case RK29_PIN4_PB5:
{
rk29_mux_api_set(GPIO4B5_FLASHDATA13_NAME,0);
break;
}
case RK29_PIN4_PB6:
{
rk29_mux_api_set(GPIO4B6_FLASHDATA14_NAME ,0);
break;
}
case RK29_PIN4_PB7:
{
rk29_mux_api_set(GPIO4B7_FLASHDATA15_NAME,0);
break;
}
case RK29_PIN4_PC0:
{
rk29_mux_api_set(GPIO4C0_RMIICLKOUT_RMIICLKIN_NAME,0);
break;
}
case RK29_PIN4_PC1:
{
rk29_mux_api_set(GPIO4C1_RMIITXEN_MIITXEN_NAME,0);
break;
}
case RK29_PIN4_PC2:
{
rk29_mux_api_set(GPIO4C2_RMIITXD1_MIITXD1_NAME,0);
break;
}
case RK29_PIN4_PC3:
{
rk29_mux_api_set(GPIO4C3_RMIITXD0_MIITXD0_NAME,0);
break;
}
case RK29_PIN4_PC4:
{
rk29_mux_api_set(GPIO4C4_RMIIRXERR_MIIRXERR_NAME,0);
break;
}
case RK29_PIN4_PC5:
{
rk29_mux_api_set(GPIO4C5_RMIICSRDVALID_MIIRXDVALID_NAME,0);
break;
}
case RK29_PIN4_PC6:
{
rk29_mux_api_set(GPIO4C6_RMIIRXD1_MIIRXD1_NAME,0);
break;
}
case RK29_PIN4_PC7:
{
rk29_mux_api_set(GPIO4C7_RMIIRXD0_MIIRXD0_NAME,0);
break;
}
case RK29_PIN4_PD0:
case RK29_PIN4_PD1:
{
rk29_mux_api_set(GPIO4D10_CPUTRACEDATA10_NAME,0);
break;
}
case RK29_PIN4_PD2:
case RK29_PIN4_PD3:
{
rk29_mux_api_set(GPIO4D32_CPUTRACEDATA32_NAME,0);
break;
}
case RK29_PIN4_PD4:
{
rk29_mux_api_set(GPIO4D4_CPUTRACECLK_NAME,0);
break;
}
case RK29_PIN4_PD5:
{
rk29_mux_api_set(GPIO4D5_CPUTRACECTL_NAME,0);
break;
}
case RK29_PIN4_PD6:
{
rk29_mux_api_set(GPIO4D6_I2S0LRCKTX0_NAME,0);
break;
}
case RK29_PIN4_PD7:
{
rk29_mux_api_set(GPIO4D7_I2S0LRCKTX1_NAME,0);
break;
}
case RK29_PIN5_PA0:
case RK29_PIN5_PA1:
case RK29_PIN5_PA2:
{
break;
}
case RK29_PIN5_PA3:
{
rk29_mux_api_set(GPIO5A3_MIITXCLKIN_NAME,0);
break;
}
case RK29_PIN5_PA4:
{
rk29_mux_api_set(GPIO5A4_TSSYNC_NAME,0);
break;
}
case RK29_PIN5_PA5:
{
rk29_mux_api_set(GPIO5A5_HSADCDATA0_NAME,0);
break;
}
case RK29_PIN5_PA6:
{
rk29_mux_api_set(GPIO5A6_HSADCDATA1_NAME,0);
break;
}
case RK29_PIN5_PA7:
{
rk29_mux_api_set(GPIO5A7_HSADCDATA2_NAME,0);
break;
}
case RK29_PIN5_PB0:
{
rk29_mux_api_set(GPIO5B0_HSADCDATA3_NAME,0);
break;
}
case RK29_PIN5_PB1:
{
rk29_mux_api_set(GPIO5B1_HSADCDATA4_NAME,0);
break;
}
case RK29_PIN5_PB2:
{
rk29_mux_api_set(GPIO5B2_HSADCDATA5_NAME,0);
break;
}
case RK29_PIN5_PB3:
{
rk29_mux_api_set(GPIO5B3_HSADCDATA6_NAME,0);
break;
}
case RK29_PIN5_PB4:
{
rk29_mux_api_set(GPIO5B4_HSADCDATA7_NAME,0);
break;
}
case RK29_PIN5_PB5:
{
rk29_mux_api_set(GPIO5B5_HSADCDATA8_NAME,0);
break;
}
case RK29_PIN5_PB6:
{
rk29_mux_api_set(GPIO5B6_HSADCDATA9_NAME,0);
break;
}
case RK29_PIN5_PB7:
{
rk29_mux_api_set(GPIO5B7_HSADCCLKOUTGPSCLK_NAME,0);
break;
}
case RK29_PIN5_PC0:
{
rk29_mux_api_set(GPIO5C0_EBCSDDO0_SMCDATA0_NAME,0);
break;
}
case RK29_PIN5_PC1:
{
rk29_mux_api_set(GPIO5C1_EBCSDDO1_SMCDATA1_NAME,0);
break;
}
case RK29_PIN5_PC2:
{
rk29_mux_api_set(GPIO5C2_EBCSDDO2_SMCDATA2_NAME,0);
break;
}
case RK29_PIN5_PC3:
{
rk29_mux_api_set(GPIO5C3_EBCSDDO3_SMCDATA3_NAME,0);
break;
}
case RK29_PIN5_PC4:
{
rk29_mux_api_set(GPIO5C4_EBCSDDO4_SMCDATA4_NAME,0);
break;
}
case RK29_PIN5_PC5:
{
rk29_mux_api_set(GPIO5C5_EBCSDDO5_SMCDATA5_NAME,0);
break;
}
case RK29_PIN5_PC6:
{
rk29_mux_api_set(GPIO5C6_EBCSDDO6_SMCDATA6_NAME,0);
break;
}
case RK29_PIN5_PC7:
{
rk29_mux_api_set(GPIO5C7_EBCSDDO7_SMCDATA7_NAME,0);
break;
}
case RK29_PIN5_PD0:
{
rk29_mux_api_set(GPIO5D0_EBCSDLE_SMCADDR5_HOSTDATA5_NAME,0);
break;
}
case RK29_PIN5_PD1:
{
rk29_mux_api_set(GPIO5D1_EBCSDCLK_SMCADDR6_HOSTDATA6_NAME,0);
break;
}
case RK29_PIN5_PD2:
{
rk29_mux_api_set(GPIO5D2_PWM1_UART1SIRIN_NAME,0);
break;
}
case RK29_PIN5_PD3:
{
rk29_mux_api_set(GPIO5D3_I2C2SDA_NAME,0);
break;
}
case RK29_PIN5_PD4:
{
rk29_mux_api_set(GPIO5D4_I2C2SCL_NAME,0);
break;
}
case RK29_PIN5_PD5:
{
rk29_mux_api_set(GPIO5D5_SDMMC0PWREN_NAME,0);
break;
}
case RK29_PIN5_PD6:
{
rk29_mux_api_set(GPIO5D6_SDMMC1PWREN_NAME,0);
break;
}
case RK29_PIN5_PD7:
case RK29_PIN6_PA0:
case RK29_PIN6_PA1:
case RK29_PIN6_PA2:
case RK29_PIN6_PA3:
case RK29_PIN6_PA4:
case RK29_PIN6_PA5:
case RK29_PIN6_PA6:
case RK29_PIN6_PA7:
case RK29_PIN6_PB0:
case RK29_PIN6_PB1:
case RK29_PIN6_PB2:
case RK29_PIN6_PB3:
case RK29_PIN6_PB4:
case RK29_PIN6_PB5:
case RK29_PIN6_PB6:
case RK29_PIN6_PB7:
case RK29_PIN6_PC0:
case RK29_PIN6_PC1:
case RK29_PIN6_PC2:
case RK29_PIN6_PC3:
{
break;
}
case RK29_PIN6_PC4:
case RK29_PIN6_PC5:
{
rk29_mux_api_set(GPIO6C54_CPUTRACEDATA54_NAME,0);
break;
}
case RK29_PIN6_PC6:
case RK29_PIN6_PC7:
{
rk29_mux_api_set(GPIO6C76_CPUTRACEDATA76_NAME,0);
break;
}
case RK29_PIN6_PD0:
case RK29_PIN6_PD1:
case RK29_PIN6_PD2:
case RK29_PIN6_PD3:
case RK29_PIN6_PD4:
case RK29_PIN6_PD5:
case RK29_PIN6_PD6:
case RK29_PIN6_PD7:
{
break;
}
default:
{
printk("Pin=%d isn't RK29 GPIO, Please init it's iomux yourself!",pin);
break;
}
}
return 0;
}
