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