static void gsbi1_quptable_i2c_gpio_config(int adap_id,int config_type) { int rc; if (adap_id < 0 || adap_id > 1) return; printk("linxc %s adap_id=%d, config_type=%d\n", __func__, adap_id, config_type); if(config_type == 0) { rc = msm_gpios_request_enable(&qup_i2c_gpios_io[adap_id*2], 2); if(rc < 0){ printk("linxc %s check 1111 \n", __func__); msm_gpios_free(&qup_i2c_gpios_hw[adap_id*2], 2); rc = msm_gpios_request_enable(&qup_i2c_gpios_io[adap_id*2], 2); } } else { rc = msm_gpios_request_enable(&qup_i2c_gpios_hw[adap_id*2], 2); if(rc < 0){ printk("linxc %s check 2222 \n", __func__); msm_gpios_free(&qup_i2c_gpios_io[adap_id*2], 2); rc = msm_gpios_request_enable(&qup_i2c_gpios_hw[adap_id*2], 2); } } if (rc < 0) printk("QUP GPIO request/enable failed: %d\n", rc); }
static void gsbi_qup_i2c_gpio_config(int adap_id, int config_type) { int rc; if (adap_id < 0 || adap_id > 1) return; if (config_type) rc = msm_gpios_request_enable(&qup_i2c_gpios_hw[adap_id*2], 2); else rc = msm_gpios_request_enable(&qup_i2c_gpios_io[adap_id*2], 2); if (rc < 0) pr_err("QUP GPIO request/enable failed: %d\n", rc); }
int mi2s_config_data_gpio(u32 direction, u8 sd_line_mask) { int i , rc = 0; sd_line_mask &= MI2S_SD_LINE_MASK; if (direction == DIR_TX) { if ((sd_line_mask & MI2S_SD_0) || (sd_line_mask & MI2S_SD_1) || (sd_line_mask & MI2S_SD_2) || !(sd_line_mask & MI2S_SD_3)) { pr_err("%s: can not use SD0 or SD1 or SD2 for TX" ".only can use SD3. sd_line_mask = 0x%x\n", __func__ , sd_line_mask); return -EINVAL; } rc = msm_gpios_request_enable(mi2s_tx_data_lines_gpios, 1); if (rc) pr_err("%s: enable mi2s gpios for TX failed\n", __func__); return rc; } if (direction != DIR_RX) { pr_err("%s: Invaild direction direction = %u\n", __func__, direction); return -EINVAL; } i = 0; while (sd_line_mask) { if (sd_line_mask & 0x1) { rc = msm_gpios_request_enable( mi2s_rx_data_lines_gpios + i , 1); if (rc) { pr_err("%s: enable mi2s gpios for RX failed. " "SD line = %s\n", __func__, (mi2s_rx_data_lines_gpios + i)->label); return rc; } } sd_line_mask = sd_line_mask >> 1; i++; } return rc; }
static int msm_sdcc_setup_gpio(int dev_id, unsigned int enable) { int rc = 0; struct sdcc_gpio *curr; curr = &sdcc_cfg_data[dev_id - 1]; if (!(test_bit(dev_id, &gpio_sts)^enable)) return rc; if (enable) { set_bit(dev_id, &gpio_sts); rc = msm_gpios_request_enable(curr->cfg_data, curr->size); if (rc) pr_err("%s: Failed to turn on GPIOs for slot %d\n", __func__, dev_id); } else { clear_bit(dev_id, &gpio_sts); if (curr->sleep_cfg_data) { rc = msm_gpios_enable(curr->sleep_cfg_data, curr->size); msm_gpios_free(curr->sleep_cfg_data, curr->size); return rc; } msm_gpios_disable_free(curr->cfg_data, curr->size); } return rc; }
static int a4_ts_hw_init(int on) { int rc; if (on) { vreg_ts_ldo15 = vreg_get(NULL, "gp6"); if (IS_ERR(vreg_ts_ldo15)) { pr_err("%s: vreg_ldo15 get failed (%ld)\n", __func__, PTR_ERR(vreg_ts_ldo15)); return -ENOTSUPP; } rc = vreg_set_level(vreg_ts_ldo15, 2850); if (rc) { pr_err("%s: vreg set level failed (%d)\n", __func__, rc); return rc; } rc = vreg_enable(vreg_ts_ldo15); if (rc) { pr_err("%s: vreg enable failed (%d)\n", __func__, rc); return rc; } return msm_gpios_request_enable(ts_config_data, ARRAY_SIZE(ts_config_data)); } else { msm_gpios_disable_free(ts_config_data, ARRAY_SIZE(ts_config_data)); return 0; } }
static int synaptics_touchpad_setup(void) { int retval = 0; virtual_key_properties_kobj = kobject_create_and_add("board_properties", NULL); if (virtual_key_properties_kobj) retval = sysfs_create_group(virtual_key_properties_kobj, &virtual_key_properties_attr_group); if (!virtual_key_properties_kobj || retval) pr_err("failed to create ft5202 board_properties\n"); retval = msm_gpios_request_enable(clearpad3000_cfg_data, sizeof(clearpad3000_cfg_data)/sizeof(struct msm_gpio)); if (retval) { pr_err("%s:Failed to obtain touchpad GPIO %d. Code: %d.", __func__, CLEARPAD3000_ATTEN_GPIO, retval); retval = 0; /* ignore the err */ } synaptics_platformdata.irq = gpio_to_irq(CLEARPAD3000_ATTEN_GPIO); gpio_set_value(CLEARPAD3000_RESET_GPIO, 0); usleep(10000); gpio_set_value(CLEARPAD3000_RESET_GPIO, 1); usleep(50000); return retval; }
static void __init msm_fb_add_devices(void) { int rc; msm_fb_register_device("mdp", &mdp_pdata); // msm_fb_register_device("pmdh", &mddi_pdata); // msm_fb_register_device("emdh", &mddi_pdata); // msm_fb_register_device("tvenc", 0); if (machine_is_qsd8x50a_st1_5()) { /* rc = st15_hdmi_vreg_init(); if (rc) return; */ rc = msm_gpios_request_enable( msm_fb_st15_gpio_config_data, ARRAY_SIZE(msm_fb_st15_gpio_config_data)); if (rc) { printk(KERN_ERR "%s: unable to init lcdc gpios\n", __func__); return; } msm_fb_register_device("lcdc", &lcdc_pdata); } else msm_fb_register_device("lcdc", 0); }
static void msm7x27a_cfg_uart2dm_serial(void) { int ret; ret = msm_gpios_request_enable(uart2dm_gpios, ARRAY_SIZE(uart2dm_gpios)); if (ret) pr_err("%s: unable to enable gpios for uart2dm\n", __func__); }
static int ltr558_gpio_setup(void) { int ret = 0; ret = msm_gpios_request_enable(ltr558_gpio_cfg_data, 1); if(ret < 0) printk(KERN_ERR "%s: Failed to obtain acc int GPIO %d. Code: %d\n", __func__, ltr558_pdata.int_gpio, ret); return ret; }
static int akm_gpio_setup(void) { int ret = 0; akm_gpio_cfg_data[0].gpio_cfg = GPIO_CFG(18, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_6MA); ret = msm_gpios_request_enable(akm_gpio_cfg_data, sizeof(akm_gpio_cfg_data)/sizeof(struct msm_gpio)); return ret; }
static int __init phy_init(void) { msm_gpios_request_enable(phy_config_data, ARRAY_SIZE(phy_config_data)); gpio_direction_output(GPIO_MAC_RST_N, 0); udelay(100); gpio_set_value(GPIO_MAC_RST_N, 1); return 0; }
static void taos_init_irq(void){ int ret = 0; ret = msm_gpios_request_enable(taos_gpio_int_config_data, 1); if (ret < 0) { pr_err("%s: gpio enable failed: %d\n", __func__, ret); return; } printk("%s\n", __func__); return; }
static int lis3dh_acc_gpio_setup(void) { int ret = 0; ret = msm_gpios_request_enable(lis3dh_acc_gpio_cfg_data, sizeof(lis3dh_acc_gpio_cfg_data)/sizeof(struct msm_gpio)); if( ret<0 ) printk(KERN_ERR "%s: Failed to obtain acc int GPIO %d. Code: %d\n", __func__, GPIO_ACC_INT, ret); //lis3dh_acc_i2c_info[0].irq = gpio_to_irq(GPIO_ACC_INT); return ret; }
static void lcdc_config_gpios(int enable) { if (enable) { msm_gpios_request_enable(lcdc_gpio_config_data, ARRAY_SIZE( lcdc_gpio_config_data)); } else msm_gpios_free(lcdc_gpio_config_data, ARRAY_SIZE( lcdc_gpio_config_data)); }
int mi2s_config_clk_gpio(void) { int rc = 0; rc = msm_gpios_request_enable(mi2s_clk_gpios, ARRAY_SIZE(mi2s_clk_gpios)); if (rc) { pr_err("%s: enable mi2s clk gpios failed\n", __func__); return rc; } return 0; }
static int ltr502_light_gpio_setup(void) { int ret = 0; ltr502_pdata.int_gpio = 17; ltr502_light_gpio_cfg_data[0].gpio_cfg = GPIO_CFG(ltr502_pdata.int_gpio, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_6MA); ret = msm_gpios_request_enable(ltr502_light_gpio_cfg_data, 1); if(ret < 0) printk(KERN_ERR "%s: Failed to obtain acc int GPIO %d. Code: %d\n", __func__, ltr502_pdata.int_gpio, ret); return ret; }
static int rpr400_setup(void) { int retval = 0; retval = msm_gpios_request_enable(rpr400_cfg_data, sizeof(rpr400_cfg_data)/sizeof(struct msm_gpio)); if(retval) { printk(KERN_ERR "%s: Failed to obtain L/P sensor interrupt. Code: %d.", __func__, retval); } i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, &rpr400_i2c_info, 1); return retval; }
static void gsbi_qup_i2c_gpio_config(int adap_id, int config_type) { int rc; if (lge_bd_rev == LGE_REV_A) { if (adap_id < 0 || adap_id > 0) return; } else if (lge_bd_rev == LGE_REV_B) { if (adap_id < 0 || adap_id > 1) return; } else { if (adap_id < 0 || adap_id > 1) return; } /* Each adapter gets 2 lines from the table */ if (config_type) rc = msm_gpios_request_enable(&qup_i2c_gpios_hw[adap_id * 2], 2); else rc = msm_gpios_request_enable(&qup_i2c_gpios_io[adap_id * 2], 2); if (rc < 0) pr_err("QUP GPIO request/enable failed: %d\n", rc); }
static int tricolor_leds_gpio_setup(void) { int ret = 0; if(machine_is_msm8625_qrd5() || machine_is_msm7x27a_qrd5a()) { tricolor_leds_gpio_cfg_data[0].gpio_cfg = GPIO_CFG(LED_FLASH_EN1, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA); } else if(machine_is_msm8625_qrd7()) { tricolor_leds_gpio_cfg_data[0].gpio_cfg = GPIO_CFG(QRD7_LED_FLASH_EN, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA); } ret = msm_gpios_request_enable(tricolor_leds_gpio_cfg_data, sizeof(tricolor_leds_gpio_cfg_data)/sizeof(struct msm_gpio)); if( ret<0 ) printk(KERN_ERR "%s: Failed to obtain tricolor_leds GPIO . Code: %d\n", __func__, ret); return ret; }
static void pico_direct_inputs_gpio(void) { int res; static struct msm_gpio matirx_inputs_gpio_table[] = { { GPIO_CFG(PICO_POWER_KEY, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), "power_key" }, { GPIO_CFG(PICO_GPIO_VOL_DOWN, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), "volumn_down" }, { GPIO_CFG(PICO_GPIO_VOL_DOWN, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), "volumn_up" }, }; res = msm_gpios_request_enable(matirx_inputs_gpio_table, ARRAY_SIZE(matirx_inputs_gpio_table)); if (res) { pr_err("%s: unable to enable gpios for matirx_inputs_gpio_table\n", __func__); return; } }
int pedestal_gpio_setup(unsigned int pedestal_type) { int32_t rc = -ENODEV; if(pedestal_type >= PEDESTAL_TYPE_UNDEF) return rc; spin_lock_irq(&g_pdriverdata->pedestal_lock); if(g_gpio_irq_state.pedestal_gpio_req_state[pedestal_type] > 0) { PEDESTAL_ERR("pedestal_gpio_setup: request gpio again!\n"); } else { rc = msm_gpios_request_enable(&pedestal_gpio_cfg[pedestal_type],1); if(!rc) g_gpio_irq_state.pedestal_gpio_req_state[pedestal_type]++; } spin_unlock_irq(&g_pdriverdata->pedestal_lock); return rc; }
static void msm7x27a_cfg_smsc911x(void) { int res; res = msm_gpios_request_enable(smsc911x_gpios, ARRAY_SIZE(smsc911x_gpios)); if (res) { pr_err("%s: unable to enable gpios for SMSC911x\n", __func__); return; } /* ETH_FIFO_SEL */ res = gpio_direction_output(ETH_FIFO_SEL_GPIO, 0); if (res) { pr_err("%s: unable to get direction for gpio %d\n", __func__, ETH_FIFO_SEL_GPIO); msm_gpios_disable_free(smsc911x_gpios, ARRAY_SIZE(smsc911x_gpios)); return; } gpio_set_value(ETH_FIFO_SEL_GPIO, 0); }
static int mpu3050_gpio_setup(void) { int ret = 0; ret = msm_gpios_request_enable(mpu3050_gpio_cfg_data, sizeof(mpu3050_gpio_cfg_data)/sizeof(struct msm_gpio)); if( ret<0 ) printk(KERN_ERR "Failed to obtain mpu3050 int GPIO!\n"); else printk("mpu3050 int GPIO request!\n"); if(machine_is_msm8625_qrd5() || machine_is_msm7x27a_qrd5a() ) { if (ARRAY_SIZE(mpu3050_boardinfo_qrd5)) i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, mpu3050_boardinfo_qrd5, ARRAY_SIZE(mpu3050_boardinfo_qrd5)); } else { if (ARRAY_SIZE(mpu3050_boardinfo)) i2c_register_board_info(MSM_GSBI1_QUP_I2C_BUS_ID, mpu3050_boardinfo, ARRAY_SIZE(mpu3050_boardinfo)); } printk("i2c_register_board_info for MPU3050\n"); return ret; }
static void msm7x30_init_uart2(void) { msm_gpios_request_enable(uart2_config_data, ARRAY_SIZE(uart2_config_data)); }
static void msm7x30_cfg_bcmdhd(void) { if (msm_gpios_request_enable(bcmdhd_gpios, ARRAY_SIZE(bcmdhd_gpios))) printk(KERN_ERR "%s: unable to enable gpios\n", __func__); }