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__);
}
