static void mdm_update_gpio_configs(enum gpio_update_config gpio_config) { /* Some gpio configuration may need updating after modem bootup.*/ switch (gpio_config) { case GPIO_UPDATE_RUNNING_CONFIG: if (mdm_drv->pdata->mdm2ap_status_gpio_run_cfg) { if (msm_gpiomux_write(mdm_drv->mdm2ap_status_gpio, GPIOMUX_ACTIVE, mdm_drv->pdata->mdm2ap_status_gpio_run_cfg, &mdm2ap_status_old_config)) pr_err("%s: failed updating running gpio config\n", __func__); else mdm2ap_status_valid_old_config = 1; } break; case GPIO_UPDATE_BOOTING_CONFIG: if (mdm2ap_status_valid_old_config) { msm_gpiomux_write(mdm_drv->mdm2ap_status_gpio, GPIOMUX_ACTIVE, &mdm2ap_status_old_config, NULL); mdm2ap_status_valid_old_config = 0; } break; default: pr_err("%s: called with no config\n", __func__); break; } }
static void mdm_update_gpio_configs(struct mdm_ctrl *mdm, enum gpio_update_config gpio_config) { struct device *dev = mdm->dev; /* Some gpio configuration may need updating after modem bootup.*/ switch (gpio_config) { case GPIO_UPDATE_RUNNING_CONFIG: if (mdm->mdm2ap_status_gpio_run_cfg) { if (msm_gpiomux_write(MDM_GPIO(mdm, MDM2AP_STATUS), GPIOMUX_ACTIVE, mdm->mdm2ap_status_gpio_run_cfg, &mdm->mdm2ap_status_old_config)) dev_err(dev, "switch to run failed\n"); else mdm->mdm2ap_status_valid_old_config = 1; } break; case GPIO_UPDATE_BOOTING_CONFIG: if (mdm->mdm2ap_status_valid_old_config) { msm_gpiomux_write(MDM_GPIO(mdm, MDM2AP_STATUS), GPIOMUX_ACTIVE, &mdm->mdm2ap_status_old_config, NULL); mdm->mdm2ap_status_valid_old_config = 0; } break; default: dev_err(dev, "%s: called with no config\n", __func__); break; } }
static void qsc_update_gpio_configs(enum gpio_update_config gpio_config) { #if 0 switch (gpio_config) { case GPIO_UPDATE_RUNNING_CONFIG: if (mdm_drv->pdata->mdm2ap_status_gpio_run_cfg) { if (msm_gpiomux_write(mdm_drv->mdm2ap_status_gpio, GPIOMUX_ACTIVE, mdm_drv->pdata->mdm2ap_status_gpio_run_cfg, &mdm2ap_status_old_config)) pr_err("%s: failed updating running gpio config\n", __func__); else mdm2ap_status_valid_old_config = 1; } break; case GPIO_UPDATE_BOOTING_CONFIG: if (mdm2ap_status_valid_old_config) { msm_gpiomux_write(mdm_drv->mdm2ap_status_gpio, GPIOMUX_ACTIVE, &mdm2ap_status_old_config, NULL); mdm2ap_status_valid_old_config = 0; } break; default: pr_err("%s: called with no config\n", __func__); break; } #endif return; }
static void isdbt_set_config_poweron(void) { #if defined(CONFIG_SEC_GPIO_SETTINGS) struct pinctrl *isdbt_pinctrl; /* Get pinctrl if target uses pinctrl */ isdbt_pinctrl = devm_pinctrl_get_select(isdbt_device, "isdbt_gpio_active"); if (IS_ERR(isdbt_pinctrl)) { DPRINTK("Target does not use pinctrl\n"); isdbt_pinctrl = NULL; } #else #if defined(CONFIG_MTV_QUALCOMM) if(msm_gpiomux_write(dt_pdata->isdbt_spi_mosi, GPIOMUX_ACTIVE, &spi_active_config, NULL) < 0) DPRINTK("spi_mosi Port request error!!!\n"); if(msm_gpiomux_write(dt_pdata->isdbt_spi_miso, GPIOMUX_ACTIVE, &spi_active_config, NULL) < 0) DPRINTK("spi_miso Port request error!!!\n"); if(msm_gpiomux_write(dt_pdata->isdbt_spi_cs, GPIOMUX_ACTIVE, &spi_active_config, NULL) < 0) DPRINTK("spi_cs Port request error!!!\n"); if(msm_gpiomux_write(dt_pdata->isdbt_spi_clk, GPIOMUX_ACTIVE, &spi_active_config, NULL) < 0) DPRINTK("spi_clk Port request error!!!\n"); #elif defined(CONFIG_MTV_BROADCOM) struct pin_config SdioPinCfgs; SdioPinCfgs.name = dt_pdata->isdbt_irq; pinmux_get_pin_config(&SdioPinCfgs); SdioPinCfgs.reg.b.slew_rate_ctrl = 0; pinmux_set_pin_config(&SdioPinCfgs); SdioPinCfgs.name = dt_pdata->isdbt_rst; pinmux_get_pin_config(&SdioPinCfgs); SdioPinCfgs.reg.b.input_dis = 1; SdioPinCfgs.reg.b.drv_sth = 0; SdioPinCfgs.func = PF_GPIO00; SdioPinCfgs.reg.b.sel = 4; pinmux_set_pin_config(&SdioPinCfgs); #elif defined(CONFIG_MTV_SPREADTRUM) sprd_restore_spi_pin_cfg(); #endif #endif gpio_direction_output(dt_pdata->isdbt_pwr_en, 0); if (gpio_is_valid(dt_pdata->isdbt_pwr_en2)) gpio_direction_output(dt_pdata->isdbt_pwr_en2, 0); if (gpio_is_valid(dt_pdata->isdbt_ant_sel)) gpio_direction_output(dt_pdata->isdbt_ant_sel, 0); if (gpio_is_valid(dt_pdata->isdbt_rst)) gpio_direction_output(dt_pdata->isdbt_rst, 0); gpio_direction_input(dt_pdata->isdbt_irq); }
static void isdbt_set_config_poweroff(void) { #if defined(CONFIG_SEC_GPIO_SETTINGS) struct pinctrl *isdbt_pinctrl; #endif gpio_direction_input(dt_pdata->isdbt_pwr_en); if (gpio_is_valid(dt_pdata->isdbt_pwr_en2)) gpio_direction_input(dt_pdata->isdbt_pwr_en2); if (gpio_is_valid(dt_pdata->isdbt_ant_sel)) gpio_direction_input(dt_pdata->isdbt_ant_sel); if (gpio_is_valid(dt_pdata->isdbt_rst)) gpio_direction_input(dt_pdata->isdbt_rst); #if defined(CONFIG_SEC_GPIO_SETTINGS) /* Get pinctrl if target uses pinctrl */ isdbt_pinctrl = devm_pinctrl_get_select(isdbt_device, "isdbt_gpio_suspend"); if (IS_ERR(isdbt_pinctrl)) { DPRINTK("Target does not use pinctrl\n"); isdbt_pinctrl = NULL; } #else #if defined(CONFIG_MTV_QUALCOMM) if(msm_gpiomux_write(dt_pdata->isdbt_spi_mosi, GPIOMUX_SUSPENDED, &spi_suspend_config, NULL) < 0) DPRINTK("spi_mosi Port request error!!!\n"); if(msm_gpiomux_write(dt_pdata->isdbt_spi_miso, GPIOMUX_SUSPENDED, &spi_suspend_config, NULL) < 0) DPRINTK("spi_miso Port request error!!!\n"); if(msm_gpiomux_write(dt_pdata->isdbt_spi_cs, GPIOMUX_SUSPENDED, &spi_suspend_config, NULL) < 0) DPRINTK("spi_cs Port request error!!!\n"); if(msm_gpiomux_write(dt_pdata->isdbt_spi_clk, GPIOMUX_SUSPENDED, &spi_suspend_config, NULL) < 0) DPRINTK("spi_clk Port request error!!!\n"); #elif defined(CONFIG_MTV_BROADCOM) // broadcom #elif defined(CONFIG_MTV_SPREADTRUM) unsigned int reg, value; unsigned long flags; int i, regs_count; regs_count = sizeof(spi_pin_group)/sizeof(struct spi_pin_desc); for (i = 0; i < regs_count; i++) { reg = spi_pin_group[i].reg; local_irq_save(flags); value = ((__raw_readl(reg) & ~SPI_PIN_FUNC_MASK) | (SPI_PIN_FUNC_GPIO)); __raw_writel(value, reg); local_irq_restore(flags); } #endif #endif }
static void uart_gpio_disable(struct felica_dev *dev) { if (msm_gpiomux_write(GSBI7_UART_TX_GPIO, GPIOMUX_ACTIVE, &unused_gpio, NULL)) { dev_dbg(dev->dev, "%s: msm_gpiomux_write %d failed.", __func__, GSBI7_UART_TX_GPIO); } if (msm_gpiomux_write(GSBI7_UART_RX_GPIO, GPIOMUX_ACTIVE, &unused_gpio, NULL)) { dev_dbg(dev->dev, "%s: msm_gpiomux_write %d failed.", __func__, GSBI7_UART_RX_GPIO); } }
static int msm7x30_i2c_0_init(void) { msm_gpiomux_write(70, 0, GPIOMUX_FUNC_1 | GPIOMUX_PULL_NONE | GPIOMUX_DIR_INPUT | GPIOMUX_DRV_16MA | GPIOMUX_VALID); msm_gpiomux_write(71, 0, GPIOMUX_FUNC_1 | GPIOMUX_PULL_NONE | GPIOMUX_DIR_INPUT | GPIOMUX_DRV_16MA | GPIOMUX_VALID); }
static void cxd2235agg_setup_uart_gpio(struct cxd2235agg_data *my_data, int val) { int id = val ? 1 : 0; dev_dbg(&my_data->pdev->dev, ": %s: %d-%d\n", __func__, val, id); if (msm_gpiomux_write(my_data->gpios[TX_PIN], GPIOMUX_ACTIVE, &tx_cfg[id], NULL)) dev_err(&my_data->pdev->dev, "%s: msm_gpiomux_write %d failed.", __func__, my_data->gpios[TX_PIN]); if (msm_gpiomux_write(my_data->gpios[RX_PIN], GPIOMUX_ACTIVE, &rx_cfg[id], NULL)) dev_err(&my_data->pdev->dev, "%s: msm_gpiomux_write %d failed.", __func__, my_data->gpios[RX_PIN]); }
static int qrd_gpios_request_enable(const struct msm_gpio *table, int size) { int i; const struct msm_gpio *g; struct gpiomux_setting setting; int rc = msm_gpios_request(table, size); if (!rc){ for (i = 0; i < size; i++) { g = table + i; /* use msm_gpiomux_write which can save old configuration */ setting.func = GPIO_FUNC(g->gpio_cfg); setting.dir = GPIO_DIR(g->gpio_cfg); setting.pull = GPIO_PULL(g->gpio_cfg); setting.drv = GPIO_DRVSTR(g->gpio_cfg); msm_gpiomux_write(GPIO_PIN(g->gpio_cfg), GPIOMUX_ACTIVE, &setting, NULL); pr_debug("I2C pin %d func %d dir %d pull %d drvstr %d\n", GPIO_PIN(g->gpio_cfg), GPIO_FUNC(g->gpio_cfg), GPIO_DIR(g->gpio_cfg), GPIO_PULL(g->gpio_cfg), GPIO_DRVSTR(g->gpio_cfg)); } } return rc; }
static void msm7x30_speaker_amp_init(void) { msm_gpiomux_write(82, 0, GPIOMUX_FUNC_GPIO | GPIOMUX_PULL_NONE | GPIOMUX_DIR_OUTPUT | GPIOMUX_DRV_2MA | GPIOMUX_VALID); gpio_request(82, "poweramp"); gpio_direction_output(82, 1); }
void msm_gpiomux_install(struct msm_gpiomux_config *configs, unsigned nconfigs) { unsigned c, s; int rc; for (c = 0; c < nconfigs; ++c) { for (s = 0; s < GPIOMUX_NSETTINGS; ++s) { rc = msm_gpiomux_write(configs[c].gpio, s, configs[c].settings[s], NULL); if (rc) pr_err("%s: write failure: %d\n", __func__, rc); } } }
static int msm7x30_spi_init(void) { msm_gpiomux_write(45, 0, GPIOMUX_FUNC_1 | GPIOMUX_PULL_NONE | GPIOMUX_DIR_INPUT | GPIOMUX_DRV_2MA | GPIOMUX_VALID); msm_gpiomux_write(46, 0, GPIOMUX_FUNC_1 | GPIOMUX_PULL_NONE | GPIOMUX_DIR_INPUT | GPIOMUX_DRV_2MA | GPIOMUX_VALID); msm_gpiomux_write(47, 0, GPIOMUX_FUNC_1 | GPIOMUX_PULL_NONE | GPIOMUX_DIR_INPUT | GPIOMUX_DRV_2MA | GPIOMUX_VALID); msm_gpiomux_write(48, 0, GPIOMUX_FUNC_1 | GPIOMUX_PULL_NONE | GPIOMUX_DIR_INPUT | GPIOMUX_DRV_2MA | GPIOMUX_VALID); }
static int __init msm7x30_ssbi_pmic_init(void) { int ret; pr_info("%s()\n", __func__); msm_gpiomux_write(MSM7X30_GPIO_PMIC_INT_N, 0, GPIOMUX_FUNC_GPIO | GPIOMUX_PULL_NONE | GPIOMUX_DIR_INPUT | GPIOMUX_DRV_2MA | GPIOMUX_VALID); ret = gpiochip_reserve(msm7x30_pm8058_pdata.gpio_base, PM8058_NUM_GPIOS); WARN(ret, "can't reserve pm8058 gpios. badness will ensue...\n"); msm_device_ssbi_pmic.dev.platform_data = &msm7x30_ssbi_pmic_pdata; return platform_device_register(&msm_device_ssbi_pmic); }
static int configure_pins(struct msm_gpiomux_config *config, struct msm_gpiomux_config *oldconfig, unsigned int num_configs) { int rc = 0, j, i; for (i = 0; i < num_configs; i++) { for (j = 0; j < GPIOMUX_NSETTINGS; j++) { (oldconfig + i)->gpio = (config + i)->gpio; rc = msm_gpiomux_write((config + i)->gpio, j, (config + i)->settings[j], (oldconfig + i)->settings[j]); if (rc < 0) break; } } return rc; }
static void earjack_debugger_set_gpiomux_uart(int enable) { if (enable) { msm_gpiomux_write(MAKO_UART_TX_GPIO, GPIOMUX_ACTIVE, &gsbi4_uart, NULL); msm_gpiomux_write(MAKO_UART_TX_GPIO, GPIOMUX_SUSPENDED, &gsbi4_uart, NULL); msm_gpiomux_write(MAKO_UART_RX_GPIO, GPIOMUX_ACTIVE, &gsbi4_uart, NULL); msm_gpiomux_write(MAKO_UART_RX_GPIO, GPIOMUX_SUSPENDED, &gsbi4_uart, NULL); } else { msm_gpiomux_write(MAKO_UART_TX_GPIO, GPIOMUX_ACTIVE, &gsbi4_gpio, NULL); msm_gpiomux_write(MAKO_UART_TX_GPIO, GPIOMUX_SUSPENDED, &gsbi4_gpio, NULL); msm_gpiomux_write(MAKO_UART_RX_GPIO, GPIOMUX_ACTIVE, &gsbi4_gpio, NULL); msm_gpiomux_write(MAKO_UART_RX_GPIO, GPIOMUX_SUSPENDED, &gsbi4_gpio, NULL); } }
static void fluid_cyttsp_init(void) { vreg_l8 = _get_vreg("gp7", 1800, true); vreg_l16 = _get_vreg("gp10", 2600, true); vreg_l15 = _get_vreg("gp6", 3050, true); if (!vreg_l8 || !vreg_l16 || !vreg_l15) { pr_err("%s: can't get vregs\n", __func__); _put_vreg(vreg_l8); _put_vreg(vreg_l15); _put_vreg(vreg_l16); return; } /* enable interrupt gpio */ msm_gpiomux_write(MSM7X30_FLUID_GPIO_TOUCH_INT_N, 0, GPIOMUX_FUNC_GPIO | GPIOMUX_PULL_UP | GPIOMUX_DIR_INPUT | GPIOMUX_DRV_6MA | GPIOMUX_VALID); }
static int __tpiu_enable_setb(struct tpiu_drvdata *drvdata) { int i, ret; if (!drvdata->setb_gpiocnt) return -EINVAL; for (i = 0; i < drvdata->setb_gpiocnt; i++) { ret = gpio_request(drvdata->setb_gpios[i], NULL); if (ret) { dev_err(drvdata->dev, "gpio_request failed for setb_gpio: %u\n", drvdata->setb_gpios[i]); goto err0; } ret = msm_gpiomux_write(drvdata->setb_gpios[i], GPIOMUX_ACTIVE, &drvdata->setb_cfgs[i], &old_cfg); if (ret < 0) { dev_err(drvdata->dev, "gpio write failed for setb_gpio: %u\n", drvdata->setb_gpios[i]); goto err1; } } return 0; err1: gpio_free(drvdata->setb_gpios[i]); err0: i--; while (i >= 0) { gpio_free(drvdata->setb_gpios[i]); i--; } return ret; }
static int __tpiu_enable_setb(struct tpiu_drvdata *drvdata) { int i, ret; struct pinctrl *pctrl; struct pinctrl_state *setb_pctrl; if (drvdata->tpiu_pctrl) { pctrl = devm_pinctrl_get(drvdata->dev); if (IS_ERR(pctrl)) { ret = PTR_ERR(pctrl); goto err0; } setb_pctrl = pinctrl_lookup_state(pctrl, "setb-pctrl"); if (IS_ERR(setb_pctrl)) { dev_err(drvdata->dev, "pinctrl get state failed for setb\n"); ret = PTR_ERR(setb_pctrl); goto err0; } ret = pinctrl_select_state(pctrl, setb_pctrl); if (ret) { dev_err(drvdata->dev, "pinctrl enable state failed for setb\n"); goto err0; } drvdata->tpiu_pctrl->pctrl = pctrl; drvdata->tpiu_pctrl->setb_pctrl = setb_pctrl; return 0; } if (!drvdata->setb_gpiocnt) return -EINVAL; for (i = 0; i < drvdata->setb_gpiocnt; i++) { ret = gpio_request(drvdata->setb_gpios[i], NULL); if (ret) { dev_err(drvdata->dev, "gpio_request failed for setb_gpio: %u\n", drvdata->setb_gpios[i]); goto err1; } ret = msm_gpiomux_write(drvdata->setb_gpios[i], GPIOMUX_ACTIVE, &drvdata->setb_cfgs[i], &old_cfg); if (ret < 0) { dev_err(drvdata->dev, "gpio write failed for setb_gpio: %u\n", drvdata->setb_gpios[i]); goto err2; } } return 0; err2: gpio_free(drvdata->setb_gpios[i]); err1: i--; while (i >= 0) { gpio_free(drvdata->setb_gpios[i]); i--; } return ret; err0: devm_pinctrl_put(pctrl); return ret; }
static int pn547_i2c_recovery(struct pn547_dev *data) { int ret, i; struct gpiomux_setting old_config[2]; struct gpiomux_setting recovery_config = { .func = GPIOMUX_FUNC_GPIO, .drv = GPIOMUX_DRV_8MA, .pull = GPIOMUX_PULL_NONE, }; if ((data->sda_gpio < 0) || (data->scl_gpio < 0)) { pr_info("%s - no sda, scl gpio\n", __func__); return -1; } pr_info("################# %s #################\n", __func__); ret = msm_gpiomux_write(data->sda_gpio, GPIOMUX_ACTIVE, &recovery_config, &old_config[0]); if (ret < 0) { pr_err("%s sda_gpio have no active setting %d\n", __func__, ret); goto exit; } ret = msm_gpiomux_write(data->scl_gpio, GPIOMUX_ACTIVE, &recovery_config, &old_config[1]); if (ret < 0) { pr_err("%s scl_gpio have no active setting %d\n", __func__, ret); goto exit; } ret = gpio_request(data->sda_gpio, "SENSOR_SDA"); if (ret < 0) { pr_err("%s - gpio %d request failed (%d)\n", __func__, data->sda_gpio, ret); goto exit; } ret = gpio_request(data->scl_gpio, "SENSOR_SCL"); if (ret < 0) { pr_err("%s - gpio %d request failed (%d)\n", __func__, data->scl_gpio, ret); gpio_free(data->scl_gpio); goto exit; } ret = gpio_direction_output(data->sda_gpio, 1); if (ret < 0) { pr_err("%s - failed to set gpio %d as output (%d)\n", __func__, data->sda_gpio, ret); goto exit_to_free; } ret = gpio_direction_output(data->scl_gpio, 1); if (ret < 0) { pr_err("%s - failed to set gpio %d as output (%d)\n", __func__, data->scl_gpio, ret); goto exit_to_free; } for (i = 0; i < 36; i++) { udelay(2); gpio_set_value_cansleep(data->scl_gpio, 0); udelay(2); gpio_set_value_cansleep(data->scl_gpio, 1); } ret = gpio_direction_input(data->sda_gpio); if (ret < 0) { pr_err("%s - failed to set gpio %d as input (%d)\n", __func__, data->sda_gpio, ret); goto exit_to_free; } ret = gpio_direction_input(data->scl_gpio); if (ret < 0) { pr_err("%s - failed to set gpio %d as input (%d)\n", __func__, data->scl_gpio, ret); goto exit_to_free; } exit_to_free: gpio_free(data->sda_gpio); gpio_free(data->scl_gpio); exit: msm_gpiomux_write(data->sda_gpio, GPIOMUX_ACTIVE, &old_config[0], NULL); msm_gpiomux_write(data->scl_gpio, GPIOMUX_ACTIVE, &old_config[1], NULL); return ret; }